@f3liz/rescript-autogen-openapi 0.1.7 → 0.3.0

package/src/generators/IRToSuryGenerator.res

@@ -16,13 +16,27 @@ let applyConstraints = (base, min, max, toString) => {
   }
 }
 
-let rec generateSchemaWithContext = (~ctx: GenerationContext.t, ~depth=0, irType: SchemaIR.irType): string => {
+// When extractedTypeMap is provided, complex inline types reference extracted schemas instead of regenerating
+let rec generateSchemaWithContext = (~ctx: GenerationContext.t, ~depth=0, ~extractedTypeMap: option<array<GenerationContext.extractedType>>=?, irType: SchemaIR.irType): string => {
   // We keep a high depth limit just to prevent infinite recursion on circular schemas that escaped IRBuilder
   if depth > 100 {
     addWarning(ctx, DepthLimitReached({depth, path: ctx.path}))
     "S.json"
   } else {
-    let recurse = nextIrType => generateSchemaWithContext(~ctx, ~depth=depth + 1, nextIrType)
+    let recurse = nextIrType => generateSchemaWithContext(~ctx, ~depth=depth + 1, ~extractedTypeMap?, nextIrType)
+
+    // Check if this irType was extracted — if so, reference the schema by name
+    let foundExtracted = switch extractedTypeMap {
+    | Some(extracted) =>
+      extracted->Array.find(({irType: extractedIr}: GenerationContext.extractedType) =>
+        SchemaIR.equals(extractedIr, irType)
+      )
+    | None => None
+    }
+
+    switch foundExtracted {
+    | Some({typeName}) => `${typeName}Schema`
+    | None =>
 
     switch irType {
     | String({constraints: c}) =>
@@ -43,7 +57,7 @@ let rec generateSchemaWithContext = (~ctx: GenerationContext.t, ~depth=0, irType
       if Array.length(properties) == 0 {
         switch additionalProperties {
         | Some(valueType) => `S.dict(${recurse(valueType)})`
-        | None => "S.json"
+        | None => "S.dict(S.json)"
         }
       } else {
         let fields =
@@ -51,9 +65,18 @@ let rec generateSchemaWithContext = (~ctx: GenerationContext.t, ~depth=0, irType
           ->Array.map(((name, fieldType, isRequired)) => {
             let schemaCode = recurse(fieldType)
             let camelName = name->CodegenUtils.toCamelCase->CodegenUtils.escapeKeyword
-            isRequired
-              ? `    ${camelName}: s.field("${name}", ${schemaCode}),`
-              : `    ${camelName}: s.fieldOr("${name}", S.nullableAsOption(${schemaCode}), None),`
+            let alreadyNullable = String.startsWith(schemaCode, "S.nullableAsOption(") || switch fieldType {
+              | Option(_) => true
+              | Union(types) => types->Array.some(t => switch t { | Null | Literal(NullLiteral) => true | _ => false })
+              | _ => false
+            }
+            if isRequired {
+              `    ${camelName}: s.field("${name}", ${schemaCode}),`
+            } else if alreadyNullable {
+              `    ${camelName}: s.fieldOr("${name}", ${schemaCode}, None),`
+            } else {
+              `    ${camelName}: s.fieldOr("${name}", S.nullableAsOption(${schemaCode}), None),`
+            }
           })
           ->Array.join("\n")
         `S.object(s => {\n${fields}\n  })`
@@ -66,40 +89,116 @@ let rec generateSchemaWithContext = (~ctx: GenerationContext.t, ~depth=0, irType
       | NullLiteral => "S.literal(null)"
       }
     | Union(types) =>
-      let (hasArray, hasNonArray, arrayItemType, nonArrayType) = types->Array.reduce(
-        (false, false, None, None),
-        ((hArr, hNonArr, arrItem, nonArr), t) =>
-          switch t {
-          | Array({items}) => (true, hNonArr, Some(items), nonArr)
-          | _ => (hArr, true, arrItem, Some(t))
-          },
+      // Separate Null from non-null members (handles OpenAPI 3.1 nullable via oneOf)
+      let nonNullTypes = types->Array.filter(t =>
+        switch t {
+        | Null | Literal(NullLiteral) => false
+        | _ => true
+        }
       )
-      if (
-        hasArray &&
-        hasNonArray &&
-        SchemaIR.equals(Option.getOr(arrayItemType, Unknown), Option.getOr(nonArrayType, Unknown))
-      ) {
-        `S.array(${recurse(Option.getOr(arrayItemType, Unknown))})`
-      } else if (
-        types->Array.every(t =>
-          switch t {
-          | Literal(StringLiteral(_)) => true
-          | _ => false
-          }
-        ) &&
-        Array.length(types) > 0 &&
-        Array.length(types) <= 50
-      ) {
-        `S.union([${types->Array.map(recurse)->Array.join(", ")}])`
+      let hasNull = Array.length(nonNullTypes) < Array.length(types)
+
+      // If the union is just [T, null], treat as nullable
+      if hasNull && Array.length(nonNullTypes) == 1 {
+        `S.nullableAsOption(${recurse(nonNullTypes->Array.getUnsafe(0))})`
       } else {
-        addWarning(
-          ctx,
-          ComplexUnionSimplified({
-            location: ctx.path,
-            types: types->Array.map(SchemaIR.toString)->Array.join(" | "),
-          }),
+        let effectiveTypes = hasNull ? nonNullTypes : types
+
+        let (hasArray, hasNonArray, arrayItemType, nonArrayType) = effectiveTypes->Array.reduce(
+          (false, false, None, None),
+          ((hArr, hNonArr, arrItem, nonArr), t) =>
+            switch t {
+            | Array({items}) => (true, hNonArr, Some(items), nonArr)
+            | _ => (hArr, true, arrItem, Some(t))
+            },
         )
-        "S.json"
+
+        let result = if (
+          hasArray &&
+          hasNonArray &&
+          Array.length(effectiveTypes) == 2 &&
+          SchemaIR.equals(Option.getOr(arrayItemType, Unknown), Option.getOr(nonArrayType, Unknown))
+        ) {
+          `S.array(${recurse(Option.getOr(arrayItemType, Unknown))})`
+        } else if (
+          effectiveTypes->Array.every(t =>
+            switch t {
+            | Literal(StringLiteral(_)) => true
+            | _ => false
+            }
+          ) &&
+          Array.length(effectiveTypes) > 0 &&
+          Array.length(effectiveTypes) <= 50
+        ) {
+          `S.union([${effectiveTypes->Array.map(recurse)->Array.join(", ")}])`
+        } else if Array.length(effectiveTypes) > 0 {
+          // Check if @unboxed variant is valid (same logic as type generator)
+          let canUnbox = {
+            let runtimeKinds: Dict.t<int> = Dict.make()
+            effectiveTypes->Array.forEach(t => {
+              let kind = switch t {
+              | Boolean | Literal(BooleanLiteral(_)) => "boolean"
+              | String(_) | Literal(StringLiteral(_)) => "string"
+              | Number(_) | Integer(_) | Literal(NumberLiteral(_)) => "number"
+              | Array(_) => "array"
+              | Object(_) | Reference(_) | Intersection(_) => "object"
+              | Null | Literal(NullLiteral) => "null"
+              | _ => "unknown"
+              }
+              let count = runtimeKinds->Dict.get(kind)->Option.getOr(0)
+              runtimeKinds->Dict.set(kind, count + 1)
+            })
+            Dict.valuesToArray(runtimeKinds)->Array.every(count => count <= 1)
+          }
+          
+          if canUnbox {
+            // @unboxed variant with S.union + S.shape
+            let rawNames = effectiveTypes->Array.map(CodegenUtils.variantConstructorName)
+            let names = CodegenUtils.deduplicateNames(rawNames)
+            
+            let branches = effectiveTypes->Array.mapWithIndex((memberType, i) => {
+              let constructorName = names->Array.getUnsafe(i)
+              switch memberType {
+              | Object({properties, additionalProperties}) =>
+                if Array.length(properties) == 0 {
+                  switch additionalProperties {
+                  | Some(valueType) => `S.dict(${recurse(valueType)})->S.shape(v => ${constructorName}(v))`
+                  | None => `S.dict(S.json)->S.shape(v => ${constructorName}(v))`
+                  }
+                } else {
+                  let fields = properties->Array.map(((name, fieldType, isRequired)) => {
+                    let schemaCode = recurse(fieldType)
+                    let camelName = name->CodegenUtils.toCamelCase->CodegenUtils.escapeKeyword
+                    let alreadyNullable = String.startsWith(schemaCode, "S.nullableAsOption(") || switch fieldType {
+                      | Option(_) => true
+                      | Union(unionTypes) => unionTypes->Array.some(t => switch t { | Null | Literal(NullLiteral) => true | _ => false })
+                      | _ => false
+                    }
+                    if isRequired {
+                      `      ${camelName}: s.field("${name}", ${schemaCode}),`
+                    } else if alreadyNullable {
+                      `      ${camelName}: s.fieldOr("${name}", ${schemaCode}, None),`
+                    } else {
+                      `      ${camelName}: s.fieldOr("${name}", S.nullableAsOption(${schemaCode}), None),`
+                    }
+                  })->Array.join("\n")
+                  `S.object(s => ${constructorName}({\n${fields}\n    }))`
+                }
+              | _ =>
+                let innerSchema = recurse(memberType)
+                `${innerSchema}->S.shape(v => ${constructorName}(v))`
+              }
+            })
+            `S.union([${branches->Array.join(", ")}])`
+          } else {
+            // Can't use @unboxed: pick last schema (matching type gen)
+            recurse(effectiveTypes->Array.getUnsafe(Array.length(effectiveTypes) - 1))
+          }
+        } else {
+          "S.json"
+        }
+
+        hasNull ? `S.nullableAsOption(${result})` : result
       }
     | Intersection(types) =>
       if types->Array.every(t =>
@@ -110,43 +209,110 @@ let rec generateSchemaWithContext = (~ctx: GenerationContext.t, ~depth=0, irType
       ) && Array.length(types) > 0 {
         recurse(types->Array.get(Array.length(types) - 1)->Option.getOr(Unknown))
       } else {
-        addWarning(
-          ctx,
-          IntersectionNotFullySupported({location: ctx.path, note: "Complex intersection"}),
+        // Try to merge all Object types in the intersection
+        let (objectProps, nonObjectTypes) = types->Array.reduce(
+          ([], []),
+          ((props, nonObj), t) =>
+            switch t {
+            | Object({properties}) => (Array.concat(props, properties), nonObj)
+            | _ => (props, Array.concat(nonObj, [t]))
+            },
         )
-        "S.json"
+        if Array.length(objectProps) > 0 && Array.length(nonObjectTypes) == 0 {
+          // All objects: merge properties into single S.object
+          let fields =
+            objectProps
+            ->Array.map(((name, fieldType, isRequired)) => {
+              let schemaCode = recurse(fieldType)
+              let camelName = name->CodegenUtils.toCamelCase->CodegenUtils.escapeKeyword
+              let alreadyNullable = String.startsWith(schemaCode, "S.nullableAsOption(") || switch fieldType {
+                | Option(_) => true
+                | Union(types) => types->Array.some(t => switch t { | Null | Literal(NullLiteral) => true | _ => false })
+                | _ => false
+              }
+              if isRequired {
+                `    ${camelName}: s.field("${name}", ${schemaCode}),`
+              } else if alreadyNullable {
+                `    ${camelName}: s.fieldOr("${name}", ${schemaCode}, None),`
+              } else {
+                `    ${camelName}: s.fieldOr("${name}", S.nullableAsOption(${schemaCode}), None),`
+              }
+            })
+            ->Array.join("\n")
+          `S.object(s => {\n${fields}\n  })`
+        } else if Array.length(nonObjectTypes) > 0 && Array.length(objectProps) == 0 {
+          recurse(types->Array.get(Array.length(types) - 1)->Option.getOr(Unknown))
+        } else {
+          addWarning(
+            ctx,
+            IntersectionNotFullySupported({location: ctx.path, note: "Mixed object/non-object intersection"}),
+          )
+          let fields =
+            objectProps
+            ->Array.map(((name, fieldType, isRequired)) => {
+              let schemaCode = recurse(fieldType)
+              let camelName = name->CodegenUtils.toCamelCase->CodegenUtils.escapeKeyword
+              let alreadyNullable = String.startsWith(schemaCode, "S.nullableAsOption(") || switch fieldType {
+                | Option(_) => true
+                | Union(types) => types->Array.some(t => switch t { | Null | Literal(NullLiteral) => true | _ => false })
+                | _ => false
+              }
+              if isRequired {
+                `    ${camelName}: s.field("${name}", ${schemaCode}),`
+              } else if alreadyNullable {
+                `    ${camelName}: s.fieldOr("${name}", ${schemaCode}, None),`
+              } else {
+                `    ${camelName}: s.fieldOr("${name}", S.nullableAsOption(${schemaCode}), None),`
+              }
+            })
+            ->Array.join("\n")
+          `S.object(s => {\n${fields}\n  })`
+        }
       }
     | Reference(ref) =>
-      let schemaPath = switch ctx.availableSchemas {
-      | Some(available) =>
-        let name =
-          ref
-          ->String.split("/")
-          ->Array.get(ref->String.split("/")->Array.length - 1)
-          ->Option.getOr("")
-        available->Array.includes(name)
-          ? `${CodegenUtils.toPascalCase(name)}.schema`
-          : `ComponentSchemas.${CodegenUtils.toPascalCase(name)}.schema`
-      | None =>
-        ReferenceResolver.refToSchemaPath(
-          ~insideComponentSchemas=ctx.insideComponentSchemas,
-          ~modulePrefix=ctx.modulePrefix,
-          ref,
-        )->Option.getOr("S.json")
+      // After IR normalization, ref may be just the schema name
+      let refName = if ref->String.includes("/") {
+        ref->String.split("/")->Array.get(ref->String.split("/")->Array.length - 1)->Option.getOr("")
+      } else {
+        ref
       }
-      if schemaPath == "S.json" {
-        addWarning(
-          ctx,
-          FallbackToJson({
-            reason: `Unresolved ref: ${ref}`,
-            context: {path: ctx.path, operation: "gen ref", schema: None},
-          }),
-        )
+      
+      // Detect self-reference using selfRefName from context
+      let isSelfRef = switch ctx.selfRefName {
+      | Some(selfName) => refName == selfName
+      | None => false
+      }
+
+      if isSelfRef {
+        "schema" // Self-reference: use the recursive schema binding
+      } else {
+        let schemaPath = switch ctx.availableSchemas {
+        | Some(available) =>
+          available->Array.includes(refName)
+            ? `${CodegenUtils.toPascalCase(refName)}.schema`
+            : `ComponentSchemas.${CodegenUtils.toPascalCase(refName)}.schema`
+        | None =>
+          ReferenceResolver.refToSchemaPath(
+            ~insideComponentSchemas=ctx.insideComponentSchemas,
+            ~modulePrefix=ctx.modulePrefix,
+            ref,
+          )->Option.getOr("S.json")
+        }
+        if schemaPath == "S.json" {
+          addWarning(
+            ctx,
+            FallbackToJson({
+              reason: `Unresolved ref: ${ref}`,
+              context: {path: ctx.path, operation: "gen ref", schema: None},
+            }),
+          )
+        }
+        schemaPath
       }
-      schemaPath
     | Option(inner) => `S.nullableAsOption(${recurse(inner)})`
     | Unknown => "S.json"
     }
+    } // end switch foundExtracted
   }
 }
 
@@ -167,6 +333,7 @@ let generateNamedSchema = (
   ~insideComponentSchemas=false,
   ~availableSchemas=?,
   ~modulePrefix="",
+  ~extractedTypes: array<GenerationContext.extractedType>=[],
 ) => {
   let ctx = GenerationContext.make(
     ~path=`schema.${namedSchema.name}`,
@@ -179,8 +346,28 @@ let generateNamedSchema = (
   | Some(d) => CodegenUtils.generateDocComment(~description=d, ())
   | None => ""
   }
+  let extractedTypeMap = if Array.length(extractedTypes) > 0 { Some(extractedTypes) } else { None }
+  let mainSchema = generateSchemaWithContext(~ctx, ~depth=0, ~extractedTypeMap?, namedSchema.type_)
+
+  // Generate schemas for extracted auxiliary types
+  // Exclude the type being generated from the map to avoid self-reference
+  let extractedDefs = extractedTypes->Array.map(({typeName, irType}: GenerationContext.extractedType) => {
+    let auxCtx = GenerationContext.make(
+      ~path=`schema.${typeName}`,
+      ~insideComponentSchemas,
+      ~availableSchemas?,
+      ~modulePrefix,
+      (),
+    )
+    let filteredMap = extractedTypes->Array.filter(({typeName: tn}: GenerationContext.extractedType) => tn != typeName)
+    let auxExtractedTypeMap = if Array.length(filteredMap) > 0 { Some(filteredMap) } else { None }
+    let auxSchema = generateSchemaWithContext(~ctx=auxCtx, ~depth=0, ~extractedTypeMap=?auxExtractedTypeMap, irType)
+    `let ${typeName}Schema = ${auxSchema}`
+  })
+
+  let allDefs = Array.concat(extractedDefs, [`${doc}let ${namedSchema.name}Schema = ${mainSchema}`])
   (
-    `${doc}let ${namedSchema.name}Schema = ${generateSchemaWithContext(~ctx, ~depth=0, namedSchema.type_)}`,
+    allDefs->Array.join("\n\n"),
     ctx.warnings,
   )
 }