@f3liz/rescript-autogen-openapi 0.2.0 → 0.3.0

package/src/generators/IRToTypeGenerator.res

@@ -5,13 +5,17 @@ open Types
 
 let addWarning = GenerationContext.addWarning
 
-let rec generateTypeWithContext = (~ctx: GenerationContext.t, ~depth=0, irType: SchemaIR.irType): string => {
+// `inline` tracks whether the type appears inside a type constructor (array<_>, option<_>, etc.)
+// where ReScript forbids inline record declarations and variant definitions.
+// When a complex type is encountered inline, it's extracted as a separate named type.
+let rec generateTypeWithContext = (~ctx: GenerationContext.t, ~depth=0, ~inline=false, 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}))
     "JSON.t"
   } else {
-    let recurse = nextIrType => generateTypeWithContext(~ctx, ~depth=depth + 1, nextIrType)
+    // Inside type constructors, records/variants can't appear; recurse as inline
+    let recurseInline = nextIrType => generateTypeWithContext(~ctx, ~depth=depth + 1, ~inline=true, nextIrType)
 
     switch irType {
     | String(_) => "string"
@@ -19,19 +23,30 @@ let rec generateTypeWithContext = (~ctx: GenerationContext.t, ~depth=0, irType:
     | Integer(_) => "int"
     | Boolean => "bool"
     | Null => "unit"
-    | Array({items}) => `array<${recurse(items)}>`
+    | Array({items}) => `array<${recurseInline(items)}>`
     | Object({properties, additionalProperties}) =>
       if Array.length(properties) == 0 {
         switch additionalProperties {
-        | Some(valueType) => `dict<${recurse(valueType)}>`
-        | None => "JSON.t"
+        | Some(valueType) => `dict<${recurseInline(valueType)}>`
+        | None => "dict<JSON.t>"
         }
+      } else if inline {
+        // Extract inline record as a separate named type
+        let baseName = ctx.path->String.split(".")->Array.get(ctx.path->String.split(".")->Array.length - 1)->Option.getOr("item")
+        let typeName = GenerationContext.extractType(ctx, ~baseName, irType)
+        typeName
       } else {
         let fields =
           properties
           ->Array.map(((name, fieldType, isRequired)) => {
-            let typeCode = recurse(fieldType)
-            let finalType = isRequired ? typeCode : `option<${typeCode}>`
+            let typeCode = recurseInline(fieldType)
+            // Avoid double-option: check both generated string and IR type for nullability
+            let alreadyNullable = String.startsWith(typeCode, "option<") || switch fieldType {
+              | Option(_) => true
+              | Union(types) => types->Array.some(t => switch t { | Null | Literal(NullLiteral) => true | _ => false })
+              | _ => false
+            }
+            let finalType = isRequired || alreadyNullable ? typeCode : `option<${typeCode}>`
             let camelName = name->CodegenUtils.toCamelCase
             let escapedName = camelName->CodegenUtils.escapeKeyword
             let aliasAnnotation = escapedName != name ? `@as("${name}") ` : ""
@@ -59,7 +74,7 @@ let rec generateTypeWithContext = (~ctx: GenerationContext.t, ~depth=0, irType:
 
       // If the union is just [T, null], treat as option<T>
       if hasNull && Array.length(nonNullTypes) == 1 {
-        let inner = recurse(nonNullTypes->Array.getUnsafe(0))
+        let inner = generateTypeWithContext(~ctx, ~depth=depth + 1, ~inline=true, nonNullTypes->Array.getUnsafe(0))
         `option<${inner}>`
       } else {
         // Work with the non-null types (re-wrap in option at the end if hasNull)
@@ -81,7 +96,7 @@ let rec generateTypeWithContext = (~ctx: GenerationContext.t, ~depth=0, irType:
           Array.length(effectiveTypes) == 2 &&
           SchemaIR.equals(Option.getOr(arrayItemType, Unknown), Option.getOr(nonArrayType, Unknown))
         ) {
-          `array<${recurse(Option.getOr(arrayItemType, Unknown))}>`
+          `array<${recurseInline(Option.getOr(arrayItemType, Unknown))}>`
         } else if (
           effectiveTypes->Array.every(t =>
             switch t {
@@ -92,6 +107,7 @@ let rec generateTypeWithContext = (~ctx: GenerationContext.t, ~depth=0, irType:
           Array.length(effectiveTypes) > 0 &&
           Array.length(effectiveTypes) <= 50
         ) {
+          // Polymorphic variants: valid inline
           let variants =
             effectiveTypes
             ->Array.map(t =>
@@ -103,26 +119,40 @@ let rec generateTypeWithContext = (~ctx: GenerationContext.t, ~depth=0, irType:
             ->Array.join(" | ")
           `[${variants}]`
         } else if Array.length(effectiveTypes) > 0 {
-          // Generate @unboxed variant for mixed-type unions
-          let hasPrimitives = ref(false)
-          let variantCases = effectiveTypes->Array.mapWithIndex((t, i) => {
-            let (tag, typeStr) = switch t {
-            | String(_) => { hasPrimitives := true; ("String", "string") }
-            | Number(_) => { hasPrimitives := true; ("Float", "float") }
-            | Integer(_) => { hasPrimitives := true; ("Int", "int") }
-            | Boolean => { hasPrimitives := true; ("Bool", "bool") }
-            | Array({items}) => ("Array", `array<${recurse(items)}>`)
-            | Object(_) => ("Object", recurse(t))
-            | Reference(ref) => {
-                let name = ref->String.split("/")->Array.get(ref->String.split("/")->Array.length - 1)->Option.getOr("")
-                (CodegenUtils.toPascalCase(name), recurse(t))
+          // Check if @unboxed variant is valid: each member must have a distinct runtime representation
+          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"
               }
-            | _ => (`V${Int.toString(i)}`, recurse(t))
+              let count = runtimeKinds->Dict.get(kind)->Option.getOr(0)
+              runtimeKinds->Dict.set(kind, count + 1)
+            })
+            // Valid if no kind appears more than once
+            Dict.valuesToArray(runtimeKinds)->Array.every(count => count <= 1)
+          }
+          
+          if canUnbox {
+            // Safe to use @unboxed variant
+            let extractIR = if hasNull {
+              SchemaIR.Union(effectiveTypes)
+            } else {
+              irType
             }
-            `  | ${tag}(${typeStr})`
-          })
-          let unboxedAttr = hasPrimitives.contents ? "@unboxed " : ""
-          `${unboxedAttr}[\n${variantCases->Array.join("\n")}\n]`
+            let baseName = ctx.path->String.split(".")->Array.get(ctx.path->String.split(".")->Array.length - 1)->Option.getOr("union")
+            let typeName = GenerationContext.extractType(ctx, ~baseName, ~isUnboxed=true, extractIR)
+            typeName
+          } else {
+            // Can't use @unboxed: pick the last (most derived/specific) type
+            recurseInline(effectiveTypes->Array.getUnsafe(Array.length(effectiveTypes) - 1))
+          }
         } else {
           "JSON.t"
         }
@@ -137,7 +167,12 @@ let rec generateTypeWithContext = (~ctx: GenerationContext.t, ~depth=0, irType:
         | _ => false
         }
       ) && Array.length(types) > 0 {
-        recurse(types->Array.get(Array.length(types) - 1)->Option.getOr(Unknown))
+        generateTypeWithContext(~ctx, ~depth=depth + 1, ~inline, types->Array.get(Array.length(types) - 1)->Option.getOr(Unknown))
+      } else if inline {
+        // Extract complex intersection as a separate type
+        let baseName = ctx.path->String.split(".")->Array.get(ctx.path->String.split(".")->Array.length - 1)->Option.getOr("intersection")
+        let typeName = GenerationContext.extractType(ctx, ~baseName, irType)
+        typeName
       } else {
         // Try to merge all Object types in the intersection
         let (objectProps, nonObjectTypes) = types->Array.reduce(
@@ -153,8 +188,13 @@ let rec generateTypeWithContext = (~ctx: GenerationContext.t, ~depth=0, irType:
           let fields =
             objectProps
             ->Array.map(((name, fieldType, isRequired)) => {
-              let typeCode = recurse(fieldType)
-              let finalType = isRequired ? typeCode : `option<${typeCode}>`
+              let typeCode = recurseInline(fieldType)
+              let alreadyNullable = String.startsWith(typeCode, "option<") || switch fieldType {
+                | Option(_) => true
+                | Union(types) => types->Array.some(t => switch t { | Null | Literal(NullLiteral) => true | _ => false })
+                | _ => false
+              }
+              let finalType = isRequired || alreadyNullable ? typeCode : `option<${typeCode}>`
               let camelName = name->CodegenUtils.toCamelCase
               let escapedName = camelName->CodegenUtils.escapeKeyword
               let aliasAnnotation = escapedName != name ? `@as("${name}") ` : ""
@@ -164,7 +204,7 @@ let rec generateTypeWithContext = (~ctx: GenerationContext.t, ~depth=0, irType:
           `{\n${fields}\n}`
         } else if Array.length(nonObjectTypes) > 0 && Array.length(objectProps) == 0 {
           // No objects: pick last type as best effort
-          recurse(types->Array.get(Array.length(types) - 1)->Option.getOr(Unknown))
+          generateTypeWithContext(~ctx, ~depth=depth + 1, ~inline, types->Array.get(Array.length(types) - 1)->Option.getOr(Unknown))
         } else {
           addWarning(
             ctx,
@@ -174,8 +214,13 @@ let rec generateTypeWithContext = (~ctx: GenerationContext.t, ~depth=0, irType:
           let fields =
             objectProps
             ->Array.map(((name, fieldType, isRequired)) => {
-              let typeCode = recurse(fieldType)
-              let finalType = isRequired ? typeCode : `option<${typeCode}>`
+              let typeCode = recurseInline(fieldType)
+              let alreadyNullable = String.startsWith(typeCode, "option<") || switch fieldType {
+                | Option(_) => true
+                | Union(types) => types->Array.some(t => switch t { | Null | Literal(NullLiteral) => true | _ => false })
+                | _ => false
+              }
+              let finalType = isRequired || alreadyNullable ? typeCode : `option<${typeCode}>`
               let camelName = name->CodegenUtils.toCamelCase
               let escapedName = camelName->CodegenUtils.escapeKeyword
               let aliasAnnotation = escapedName != name ? `@as("${name}") ` : ""
@@ -185,40 +230,95 @@ let rec generateTypeWithContext = (~ctx: GenerationContext.t, ~depth=0, irType:
           `{\n${fields}\n}`
         }
       }
-    | Option(inner) => `option<${recurse(inner)}>`
+    | Option(inner) => `option<${recurseInline(inner)}>`
     | Reference(ref) =>
-      let typePath = 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)}.t`
-          : `ComponentSchemas.${CodegenUtils.toPascalCase(name)}.t`
-      | None =>
-        ReferenceResolver.refToTypePath(
-          ~insideComponentSchemas=ctx.insideComponentSchemas,
-          ~modulePrefix=ctx.modulePrefix,
-          ref,
-        )->Option.getOr("JSON.t")
+      // After IR normalization, ref may be just the schema name (no path prefix)
+      // Extract the name from the ref (handles both "Name" and "#/components/schemas/Name")
+      let refName = if ref->String.includes("/") {
+        ref->String.split("/")->Array.get(ref->String.split("/")->Array.length - 1)->Option.getOr("")
+      } else {
+        ref
       }
-      if typePath == "JSON.t" {
-        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 {
+        "t" // Use recursive self-reference
+      } else {
+        let typePath = switch ctx.availableSchemas {
+        | Some(available) =>
+          available->Array.includes(refName)
+            ? `${CodegenUtils.toPascalCase(refName)}.t`
+            : `ComponentSchemas.${CodegenUtils.toPascalCase(refName)}.t`
+        | None =>
+          ReferenceResolver.refToTypePath(
+            ~insideComponentSchemas=ctx.insideComponentSchemas,
+            ~modulePrefix=ctx.modulePrefix,
+            ref,
+          )->Option.getOr("JSON.t")
+        }
+        if typePath == "JSON.t" {
+          addWarning(
+            ctx,
+            FallbackToJson({
+              reason: `Unresolved ref: ${ref}`,
+              context: {path: ctx.path, operation: "gen ref", schema: None},
+            }),
+          )
+        }
+        typePath
       }
-      typePath
     | Unknown => "JSON.t"
     }
   }
 }
 
+// Generate @unboxed variant body from a Union IR type.
+// Each member must have a distinct runtime representation (validated by canUnbox check).
+let generateUnboxedVariantBody = (~ctx: GenerationContext.t, types: array<SchemaIR.irType>): string => {
+  let rawNames = types->Array.map(CodegenUtils.variantConstructorName)
+  let names = CodegenUtils.deduplicateNames(rawNames)
+  
+  types->Array.mapWithIndex((irType, i) => {
+    let constructorName = names->Array.getUnsafe(i)
+    let payloadType = switch irType {
+    | Object({properties, additionalProperties}) =>
+      if Array.length(properties) == 0 {
+        switch additionalProperties {
+        | Some(valueType) => {
+            let innerType = generateTypeWithContext(~ctx, ~depth=1, ~inline=true, valueType)
+            `(dict<${innerType}>)`
+          }
+        | None => `(dict<JSON.t>)`
+        }
+      } else {
+        let fields = properties->Array.map(((name, fieldType, isRequired)) => {
+          let typeCode = generateTypeWithContext(~ctx, ~depth=1, ~inline=true, fieldType)
+          let alreadyNullable = String.startsWith(typeCode, "option<") || switch fieldType {
+            | Option(_) => true
+            | Union(unionTypes) => unionTypes->Array.some(t => switch t { | Null | Literal(NullLiteral) => true | _ => false })
+            | _ => false
+          }
+          let finalType = isRequired || alreadyNullable ? typeCode : `option<${typeCode}>`
+          let camelName = name->CodegenUtils.toCamelCase
+          let escapedName = camelName->CodegenUtils.escapeKeyword
+          let aliasAnnotation = escapedName != name ? `@as("${name}") ` : ""
+          `${aliasAnnotation}${escapedName}: ${finalType}`
+        })->Array.join(", ")
+        `({${fields}})`
+      }
+    | _ =>
+      let innerType = generateTypeWithContext(~ctx, ~depth=1, ~inline=true, irType)
+      `(${innerType})`
+    }
+    `${constructorName}${payloadType}`
+  })->Array.join(" | ")
+}
+
 let generateType = (
   ~depth=0,
   ~path="",
@@ -248,9 +348,58 @@ let generateNamedType = (
   | Some(d) => CodegenUtils.generateDocString(~description=d, ())
   | None => ""
   }
+  let mainType = generateTypeWithContext(~ctx, ~depth=0, namedSchema.type_)
+
+  // Iteratively resolve extracted types (handles nested extraction).
+  // Use the same ctx so all nested extractions accumulate in ctx.extractedTypes
+  // and dedup works correctly.
+  let processed = ref(0)
+  while processed.contents < Array.length(ctx.extractedTypes) {
+    let idx = processed.contents
+    let {irType, isUnboxed, _}: GenerationContext.extractedType = ctx.extractedTypes->Array.getUnsafe(idx)
+    if !isUnboxed {
+      // Generate at top level to discover nested extractions
+      ignore(generateTypeWithContext(~ctx, ~depth=0, ~inline=false, irType))
+    } else {
+      // For unboxed variants, walk union members to discover nested extractions
+      switch irType {
+      | Union(types) =>
+        types->Array.forEach(memberType => {
+          ignore(generateTypeWithContext(~ctx, ~depth=0, ~inline=true, memberType))
+        })
+      | _ => ignore(generateTypeWithContext(~ctx, ~depth=0, ~inline=false, irType))
+      }
+    }
+    processed := idx + 1
+  }
+
+  let allExtracted = Array.copy(ctx.extractedTypes)
+
+  // Generate final code for each extracted type.
+  let extractedDefs = allExtracted->Array.map(({typeName, irType, isUnboxed}: GenerationContext.extractedType) => {
+    if isUnboxed {
+      switch irType {
+      | Union(types) =>
+        let body = generateUnboxedVariantBody(~ctx, types)
+        `@unboxed type ${typeName} = ${body}`
+      | _ =>
+        let auxType = generateTypeWithContext(~ctx, ~depth=0, irType)
+        `type ${typeName} = ${auxType}`
+      }
+    } else {
+      let auxType = generateTypeWithContext(~ctx, ~depth=0, irType)
+      `type ${typeName} = ${auxType}`
+    }
+  })
+
+  // Reverse so deeper-nested types are defined first (dependencies before dependents)
+  let reversedExtracted = allExtracted->Array.toReversed
+
+  let allDefs = Array.concat(extractedDefs->Array.toReversed, [`${doc}type ${namedSchema.name} = ${mainType}`])
   (
-    `${doc}type ${namedSchema.name} = ${generateTypeWithContext(~ctx, ~depth=0, namedSchema.type_)}`,
+    allDefs->Array.join("\n\n"),
     ctx.warnings,
+    reversedExtracted,
   )
 }
 
@@ -260,7 +409,7 @@ let generateAllTypes = (~context: SchemaIR.schemaContext) => {
     Dict.valuesToArray(context.schemas)
     ->Array.toSorted((a, b) => String.compare(a.name, b.name))
     ->Array.map(s => {
-      let (code, w) = generateNamedType(~namedSchema=s)
+      let (code, w, _) = generateNamedType(~namedSchema=s)
       warnings->Array.pushMany(w)
       code
     })
@@ -268,7 +417,7 @@ let generateAllTypes = (~context: SchemaIR.schemaContext) => {
 }
 
 let generateTypeAndSchema = (~namedSchema) => {
-  let (tCode, tW) = generateNamedType(~namedSchema)
-  let (sCode, sW) = IRToSuryGenerator.generateNamedSchema(~namedSchema)
+  let (tCode, tW, extractedTypes) = generateNamedType(~namedSchema)
+  let (sCode, sW) = IRToSuryGenerator.generateNamedSchema(~namedSchema, ~extractedTypes)
   ((tCode, sCode), Array.concat(tW, sW))
 }

package/src/generators/IRToTypeScriptGenerator.res

@@ -59,7 +59,12 @@ let generateNamedType = (~namedSchema: SchemaIR.namedSchema) => {
   let typeCode = generateType(~irType=namedSchema.type_)
 
   let declaration = switch namedSchema.type_ {
-  | Object(_) => `export interface ${namedSchema.name} ${typeCode}`
+  | Object(_) => 
+    if typeCode == "Record<string, never>" {
+      `export type ${namedSchema.name} = ${typeCode};`
+    } else {
+      `export interface ${namedSchema.name} ${typeCode}`
+    }
   | _ => `export type ${namedSchema.name} = ${typeCode};`
   }
 

package/src/generators/ModuleGenerator.res

@@ -8,11 +8,12 @@ let generateSchemaCodeForDict = (schemaDict: dict<jsonSchema>) =>
   ->Array.toSorted(((nameA, _), (nameB, _)) => String.compare(nameA, nameB))
   ->Array.flatMap(((name, schema)) => {
     let (ir, _) = SchemaIRParser.parseJsonSchema(schema)
-    let (typeCode, _) = IRToTypeGenerator.generateNamedType(
+    let (typeCode, _, extractedTypes) = IRToTypeGenerator.generateNamedType(
       ~namedSchema={name: name, description: schema.description, type_: ir},
     )
     let (schemaCode, _) = IRToSuryGenerator.generateNamedSchema(
       ~namedSchema={name: `${name}Schema`, description: schema.description, type_: ir},
+      ~extractedTypes,
     )
     [typeCode->CodegenUtils.indent(2), schemaCode->CodegenUtils.indent(2), ""]
   })

package/src/generators/SchemaCodeGenerator.res

@@ -4,11 +4,12 @@
 
 let generateTypeCodeAndSchemaCode = (name, schema: Types.jsonSchema) => {
   let (ir, _) = SchemaIRParser.parseJsonSchema(schema)
-  let (typeCode, _) = IRToTypeGenerator.generateNamedType(
+  let (typeCode, _, extractedTypes) = IRToTypeGenerator.generateNamedType(
     ~namedSchema={name: name, description: schema.description, type_: ir},
   )
   let (schemaCode, _) = IRToSuryGenerator.generateNamedSchema(
     ~namedSchema={name: `${name}Schema`, description: schema.description, type_: ir},
+    ~extractedTypes,
   )
   `${typeCode}\n\n${schemaCode}`
 }

package/src/types/GenerationContext.res

@@ -2,22 +2,55 @@
 
 // GenerationContext.res - Shared context type for IR code generators
 
+// Extracted auxiliary type that was too complex to inline
+type extractedType = {
+  typeName: string,
+  irType: SchemaIR.irType,
+  isUnboxed: bool, // Needs @unboxed annotation (for variant types from mixed unions)
+}
+
 type t = {
   mutable warnings: array<CodegenError.Warning.t>,
+  mutable extractedTypes: array<extractedType>,
+  mutable extractCounter: int,
   path: string,
   insideComponentSchemas: bool, // Whether we're generating inside ComponentSchemas module
   availableSchemas: option<array<string>>, // Schemas available in current module (for fork schemas)
   modulePrefix: string, // Module prefix for qualified references (e.g., "MisskeyIo")
+  selfRefName: option<string>, // Schema name for self-referential type detection (e.g., "DriveFolder")
 }
 
-let make = (~path, ~insideComponentSchemas=false, ~availableSchemas=?, ~modulePrefix="", ()): t => {
+let make = (~path, ~insideComponentSchemas=false, ~availableSchemas=?, ~modulePrefix="", ~selfRefName=?, ()): t => {
   warnings: [],
+  extractedTypes: [],
+  extractCounter: 0,
   path,
   insideComponentSchemas,
   availableSchemas,
   modulePrefix,
+  selfRefName,
 }
 
 let addWarning = (ctx: t, warning: CodegenError.Warning.t): unit => {
   ctx.warnings->Array.push(warning)
 }
+
+let extractType = (ctx: t, ~baseName: string, ~isUnboxed=false, irType: SchemaIR.irType): string => {
+  // Check if this irType was already extracted (avoid duplicates)
+  let existing = ctx.extractedTypes->Array.find(({irType: existingIr}: extractedType) =>
+    SchemaIR.equals(existingIr, irType)
+  )
+  switch existing {
+  | Some({typeName}) => typeName
+  | None =>
+    ctx.extractCounter = ctx.extractCounter + 1
+    // ReScript type names must start with lowercase
+    let lowerBaseName = switch baseName->String.charAt(0) {
+    | "" => "extracted"
+    | first => first->String.toLowerCase ++ baseName->String.sliceToEnd(~start=1)
+    }
+    let typeName = `${lowerBaseName}_${Int.toString(ctx.extractCounter)}`
+    ctx.extractedTypes->Array.push({typeName, irType, isUnboxed})
+    typeName
+  }
+}