Merge branch 'nim-working-version-fastcomments' into devon-fixes-all

Author: winrid

docs/generators/nim.md

@@ -226,8 +226,8 @@ These options may be applied as additional-properties (cli) or configOptions (pl
 |Polymorphism|✗|OAS2,OAS3
 |Union|✗|OAS3
 |allOf|✗|OAS2,OAS3
-|anyOf|✗|OAS3
-|oneOf|✗|OAS3
+|anyOf|✓|OAS3
+|oneOf|✓|OAS3
 |not|✗|OAS3
 
 ### Security Feature

modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/NimClientCodegen.java

@@ -34,6 +34,7 @@
 
 import java.io.File;
 import java.util.*;
+import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 import static org.openapitools.codegen.utils.CamelizeOption.LOWERCASE_FIRST_LETTER;
@@ -78,6 +79,10 @@ public NimClientCodegen() {
                 .excludeSchemaSupportFeatures(
                         SchemaSupportFeature.Polymorphism
                 )
+                .includeSchemaSupportFeatures(
+                        SchemaSupportFeature.oneOf,
+                        SchemaSupportFeature.anyOf
+                )
                 .excludeParameterFeatures(
                         ParameterFeature.Cookie
                 )
@@ -172,26 +177,166 @@ public NimClientCodegen() {
         typeMapping.put("AnyType", "JsonNode");
     }
 
+
+    @Override
+    public Map<String, ModelsMap> postProcessAllModels(Map<String, ModelsMap> allModels) {
+        allModels = super.postProcessAllModels(allModels);
+
+        // First pass: identify all models that have fields with custom JSON names
+        Set<String> modelsWithCustomJson = new HashSet<>();
+
+        for (Map.Entry<String, ModelsMap> entry : allModels.entrySet()) {
+            ModelsMap modelsMap = entry.getValue();
+            for (ModelMap mo : modelsMap.getModels()) {
+                CodegenModel cm = mo.getModel();
+
+                // Check if this model has fields with custom JSON names
+                for (CodegenProperty var : cm.vars) {
+                    if (var.vendorExtensions.containsKey("x-json-name")) {
+                        modelsWithCustomJson.add(cm.classname);
+                        break;
+                    }
+                }
+            }
+        }
+
+        // Second pass: cascade custom JSON handling to parent models and mark array fields
+        // We need multiple passes to handle transitive dependencies
+        boolean changed = true;
+        while (changed) {
+            changed = false;
+            for (Map.Entry<String, ModelsMap> entry : allModels.entrySet()) {
+                ModelsMap modelsMap = entry.getValue();
+                for (ModelMap mo : modelsMap.getModels()) {
+                    CodegenModel cm = mo.getModel();
+
+                    // Check if any field's type needs custom JSON and mark array fields appropriately
+                    for (CodegenProperty var : cm.vars) {
+                        String fieldType = var.complexType != null ? var.complexType : var.baseType;
+
+                        // Handle arrays - check if the inner type has custom JSON
+                        if (var.isArray && var.items != null) {
+                            String innerType = var.items.complexType != null ? var.items.complexType : var.items.baseType;
+                            if (innerType != null && modelsWithCustomJson.contains(innerType)) {
+                                // Mark this array field as containing types with custom JSON
+                                var.vendorExtensions.put("x-is-array-with-custom-json", "true");
+                                var.vendorExtensions.put("x-array-inner-type", innerType);
+                            }
+                            fieldType = innerType;
+                        }
+
+                        // Cascade custom JSON to parent model if not already marked
+                        if (fieldType != null && modelsWithCustomJson.contains(fieldType)) {
+                            if (!cm.vendorExtensions.containsKey("x-has-custom-json-names")) {
+                                cm.vendorExtensions.put("x-has-custom-json-names", true);
+                                modelsWithCustomJson.add(cm.classname);
+                                changed = true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        return allModels;
+    }
+
+    /**
+     * Strips surrounding quotes from integer enum values.
+     * The base OpenAPI Generator stores all enum values as quoted strings (e.g., "0", "1", "2")
+     * regardless of the enum's actual type. For Nim integer enums, we need the raw numbers
+     * without quotes so they serialize correctly: %(0) instead of %("0")
+     */
+    private void stripQuotesFromIntegerEnumValues(Map<String, Object> allowableValues) {
+        if (allowableValues == null || !allowableValues.containsKey("enumVars")) {
+            return;
+        }
+
+        @SuppressWarnings("unchecked")
+        List<Map<String, Object>> enumVars = (List<Map<String, Object>>) allowableValues.get("enumVars");
+        for (Map<String, Object> enumVar : enumVars) {
+            Object value = enumVar.get("value");
+            if (value instanceof String) {
+                String strValue = (String) value;
+                // Remove surrounding quotes if present
+                if (strValue.startsWith("\"") && strValue.endsWith("\"")) {
+                    enumVar.put("value", strValue.substring(1, strValue.length() - 1));
+                }
+            }
+        }
+    }
+
     @Override
     public ModelsMap postProcessModels(ModelsMap objs) {
         objs = postProcessModelsEnum(objs);
 
-        // Mark top-level string enums for proper enum generation in template
         for (ModelMap mo : objs.getModels()) {
             CodegenModel cm = mo.getModel();
+
             if (cm.isEnum && cm.allowableValues != null && cm.allowableValues.containsKey("enumVars")) {
                 cm.vendorExtensions.put("x-is-top-level-enum", true);
+
+                // For integer enums, strip quotes from enum values
+                if (cm.vendorExtensions.containsKey("x-is-integer-enum")) {
+                    stripQuotesFromIntegerEnumValues(cm.allowableValues);
+                }
             }
 
+            // Check if any fields need custom JSON name mapping
+            boolean hasCustomJsonNames = false;
+
             // Fix dataType fields that contain underscored type names
             // This handles cases like Table[string, Record_string__foo__value]
+            // Also wrap optional fields in Option[T]
             for (CodegenProperty var : cm.vars) {
                 if (var.dataType != null && var.dataType.contains("Record_")) {
                     var.dataType = fixRecordTypeReferences(var.dataType);
                 }
                 if (var.datatypeWithEnum != null && var.datatypeWithEnum.contains("Record_")) {
                     var.datatypeWithEnum = fixRecordTypeReferences(var.datatypeWithEnum);
                 }
+
+                // Check if the field name was changed from the original (baseName)
+                // This happens for fields like "_id" which are renamed to "id"
+                // But we need to exclude cases where the name is just escaped with backticks
+                // (e.g., "from" becomes "`from`" because it's a reserved word)
+                if (var.baseName != null && !var.baseName.equals(var.name)) {
+                    // Check if this is just a reserved word escaping (name is `baseName`)
+                    String escapedName = "`" + var.baseName + "`";
+                    if (!var.name.equals(escapedName)) {
+                        // This is a real rename, not just escaping
+                        var.vendorExtensions.put("x-json-name", var.baseName);
+                        hasCustomJsonNames = true;
+                    }
+                }
+
+                // Wrap optional (non-required) or nullable fields in Option[T]
+                // For non-enum fields only (enums are handled specially in the template)
+                if ((!var.required || var.isNullable) && !var.isReadOnly && !var.isEnum) {
+                    String baseType = var.dataType;
+                    if (baseType != null && !baseType.startsWith("Option[")) {
+                        var.dataType = "Option[" + baseType + "]";
+                        if (var.datatypeWithEnum != null) {
+                            var.datatypeWithEnum = "Option[" + var.datatypeWithEnum + "]";
+                        }
+                    }
+                }
+
+                // For enum fields, set x-is-optional if they are not required
+                if (var.isEnum && (!var.required || var.isNullable)) {
+                    var.vendorExtensions.put("x-is-optional", true);
+                }
+
+                // Always set x-is-optional based on the final dataType (for non-enum fields)
+                // This ensures consistency between type declaration and JSON handling
+                if (!var.isEnum && var.dataType != null && var.dataType.startsWith("Option[")) {
+                    var.vendorExtensions.put("x-is-optional", true);
+                }
+            }
+
+            // Mark the model as needing custom JSON deserialization if any fields have custom names
+            if (hasCustomJsonNames) {
+                cm.vendorExtensions.put("x-has-custom-json-names", true);
             }
         }
 
@@ -213,7 +358,7 @@ private String fixRecordTypeReferences(String typeString) {
 
         // Match Record_ followed by any characters until end or comma/bracket
         Pattern pattern = Pattern.compile("Record_[a-z_]+");
-        java.util.regex.Matcher matcher = pattern.matcher(result);
+        Matcher matcher = pattern.matcher(result);
 
         StringBuffer sb = new StringBuffer();
         while (matcher.find()) {
@@ -311,7 +456,106 @@ private String normalizeSchemaName(String name) {
     public CodegenModel fromModel(String name, Schema schema) {
         // Normalize the schema name before any processing
         name = normalizeSchemaName(name);
-        return super.fromModel(name, schema);
+        CodegenModel mdl = super.fromModel(name, schema);
+
+        // Detect integer enums - check both the schema type and the dataType
+        if (mdl.isEnum) {
+            String schemaType = schema != null ? schema.getType() : null;
+            if ("integer".equals(schemaType) || "int".equals(mdl.dataType) || "int64".equals(mdl.dataType)) {
+                mdl.vendorExtensions.put("x-is-integer-enum", true);
+            }
+        }
+
+        // Handle oneOf/anyOf schemas to use Nim object variants
+        if (mdl.getComposedSchemas() != null) {
+            if (mdl.getComposedSchemas().getOneOf() != null && !mdl.getComposedSchemas().getOneOf().isEmpty()) {
+                mdl.vendorExtensions.put("x-is-one-of", true);
+                processComposedSchemaVariants(mdl, mdl.getComposedSchemas().getOneOf(), schema);
+            } else if (mdl.getComposedSchemas().getAnyOf() != null && !mdl.getComposedSchemas().getAnyOf().isEmpty()) {
+                mdl.vendorExtensions.put("x-is-any-of", true);
+                processComposedSchemaVariants(mdl, mdl.getComposedSchemas().getAnyOf(), schema);
+            }
+        }
+
+        return mdl;
+    }
+
+    /**
+     * Process oneOf/anyOf schemas to generate proper variant names for Nim object variants.
+     */
+    private void processComposedSchemaVariants(CodegenModel mdl, List<CodegenProperty> variants, Schema schema) {
+        List<CodegenProperty> newVariants = new ArrayList<>();
+        List<Schema> schemas = ModelUtils.getInterfaces(schema);
+
+        if (variants.size() != schemas.size()) {
+            LOGGER.warn("Variant size does not match schema interfaces size for model " + mdl.name);
+            return;
+        }
+
+        for (int i = 0; i < variants.size(); i++) {
+            CodegenProperty variant = variants.get(i);
+            Schema variantSchema = schemas.get(i);
+
+            // Create a clone to avoid modifying the original
+            CodegenProperty newVariant = variant.clone();
+
+            // Sanitize baseName to remove underscores and properly format for Nim
+            if (newVariant.baseName != null) {
+                // Remove trailing underscores and convert to proper format
+                String sanitizedBase = newVariant.baseName.replaceAll("_+$", ""); // Remove trailing underscores
+                if (sanitizedBase.length() > 0 && Character.isUpperCase(sanitizedBase.charAt(0))) {
+                    newVariant.baseName = toModelName(sanitizedBase);
+                } else {
+                    newVariant.baseName = sanitizeNimIdentifier(sanitizedBase);
+                }
+            }
+
+            // Sanitize dataType to remove underscores and properly format for Nim
+            // For model types (not primitives), use toModelName to get the proper type name
+            if (newVariant.dataType != null) {
+                // Check if this is a model type (starts with uppercase) vs primitive
+                if (newVariant.dataType.length() > 0 && Character.isUpperCase(newVariant.dataType.charAt(0))) {
+                    // This is likely a model type, use toModelName to properly format it
+                    newVariant.dataType = toModelName(newVariant.dataType);
+                } else {
+                    // Primitive type, just sanitize
+                    newVariant.dataType = sanitizeNimIdentifier(newVariant.dataType);
+                }
+            }
+            if (newVariant.datatypeWithEnum != null) {
+                if (newVariant.datatypeWithEnum.length() > 0 && Character.isUpperCase(newVariant.datatypeWithEnum.charAt(0))) {
+                    newVariant.datatypeWithEnum = toModelName(newVariant.datatypeWithEnum);
+                } else {
+                    newVariant.datatypeWithEnum = sanitizeNimIdentifier(newVariant.datatypeWithEnum);
+                }
+            }
+
+            // Set variant name based on schema reference or type
+            if (variantSchema.get$ref() != null && !variantSchema.get$ref().isEmpty()) {
+                String refName = ModelUtils.getSimpleRef(variantSchema.get$ref());
+                if (refName != null) {
+                    newVariant.setName(toModelName(refName));
+                    newVariant.setBaseName(refName);
+                }
+            } else if (variantSchema.getType() != null) {
+                // For primitive types or inline schemas
+                String typeName = variantSchema.getType();
+                if (variantSchema.getTitle() != null && !variantSchema.getTitle().isEmpty()) {
+                    typeName = variantSchema.getTitle();
+                }
+                newVariant.setName(camelize(typeName));
+                newVariant.setBaseName(typeName);
+            }
+
+            newVariants.add(newVariant);
+        }
+
+        // Replace the original variants with the processed ones
+        if (mdl.getComposedSchemas().getOneOf() != null) {
+            mdl.getComposedSchemas().setOneOf(newVariants);
+        } else if (mdl.getComposedSchemas().getAnyOf() != null) {
+            mdl.getComposedSchemas().setAnyOf(newVariants);
+        }
     }
 
     @Override

modules/openapi-generator/src/main/resources/nim-client/api.mustache

@@ -18,10 +18,7 @@ const basepath = "{{{basePath}}}"
 template constructResult[T](response: Response): untyped =
   if response.code in {Http200, Http201, Http202, Http204, Http206}:
     try:
-      when name(stripGenericParams(T.typedesc).typedesc) == name(Table):
-        (some(json.to(parseJson(response.body), T.typedesc)), response)
-      else:
-        (some(marshal.to[T](response.body)), response)
+      (some(to(parseJson(response.body), T)), response)
     except JsonParsingError:
       # The server returned a malformed response though the response code is 2XX
       # TODO: need better error handling
@@ -37,9 +34,11 @@ proc {{{operationId}}}*(httpClient: HttpClient{{#allParams}}, {{{paramName}}}: {
   httpClient.headers["Content-Type"] = "application/x-www-form-urlencoded"{{/isMultipart}}{{#isMultipart}}
   httpClient.headers["Content-Type"] = "multipart/form-data"{{/isMultipart}}{{/hasFormParams}}{{#hasHeaderParams}}{{#headerParams}}
   httpClient.headers["{{{baseName}}}"] = {{{paramName}}}{{#isArray}}.join(","){{/isArray}}{{/headerParams}}{{#description}} ## {{{.}}}{{/description}}{{/hasHeaderParams}}{{#hasQueryParams}}
-  let url_encoded_query_params = encodeQuery([{{#queryParams}}
-    ("{{{baseName}}}", ${{{paramName}}}{{#isArray}}.join(","){{/isArray}}), # {{{description}}}{{/queryParams}}
-  ]){{/hasQueryParams}}{{#hasFormParams}}{{^isMultipart}}
+  var query_params_list: seq[(string, string)] = @[]{{#queryParams}}{{#required}}
+  query_params_list.add(("{{{baseName}}}", ${{{paramName}}}{{#isArray}}.join(","){{/isArray}})){{/required}}{{^required}}
+  if {{#isArray}}{{{paramName}}}.len > 0{{/isArray}}{{^isArray}}${{{paramName}}} != ""{{/isArray}}:
+    query_params_list.add(("{{{baseName}}}", ${{{paramName}}}{{#isArray}}.join(","){{/isArray}})){{/required}}{{/queryParams}}
+  let url_encoded_query_params = encodeQuery(query_params_list){{/hasQueryParams}}{{#hasFormParams}}{{^isMultipart}}
   let form_data = encodeQuery([{{#formParams}}
     ("{{{baseName}}}", ${{{paramName}}}{{#isArray}}.join(","){{/isArray}}), # {{{description}}}{{/formParams}}
   ]){{/isMultipart}}{{#isMultipart}}