@f3liz/rescript-autogen-openapi 0.2.0 → 0.3.0

package/lib/es6/src/generators/IRToTypeScriptGenerator.mjs

@@ -118,7 +118,7 @@ function generateNamedType(namedSchema) {
   if (typeof match !== "object" || match.TAG !== "Object") {
     exit = 1;
   } else {
-    declaration = `export interface ` + namedSchema.name + ` ` + typeCode;
+    declaration = typeCode === "Record<string, never>" ? `export type ` + namedSchema.name + ` = ` + typeCode + `;` : `export interface ` + namedSchema.name + ` ` + typeCode;
   }
   if (exit === 1) {
     declaration = `export type ` + namedSchema.name + ` = ` + typeCode + `;`;

package/lib/es6/src/generators/ModuleGenerator.mjs

@@ -31,7 +31,7 @@ function generateSchemaCodeForDict(schemaDict) {
       name: name + `Schema`,
       description: schema.description,
       type_: ir
-    }, undefined, undefined, undefined);
+    }, undefined, undefined, undefined, match$1[2]);
     return [
       CodegenUtils.indent(match$1[0], 2),
       CodegenUtils.indent(match$2[0], 2),

package/lib/es6/src/generators/SchemaCodeGenerator.mjs

@@ -20,7 +20,7 @@ function generateTypeCodeAndSchemaCode(name, schema) {
     name: name + `Schema`,
     description: schema.description,
     type_: ir
-  }, undefined, undefined, undefined);
+  }, undefined, undefined, undefined, match$1[2]);
   return match$1[0] + `\n\n` + match$2[0];
 }
 

package/lib/es6/src/types/GenerationContext.mjs

@@ -1,15 +1,19 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as SchemaIR from "../core/SchemaIR.mjs";
 
-function make(path, insideComponentSchemasOpt, availableSchemas, modulePrefixOpt, param) {
+function make(path, insideComponentSchemasOpt, availableSchemas, modulePrefixOpt, selfRefName, param) {
   let insideComponentSchemas = insideComponentSchemasOpt !== undefined ? insideComponentSchemasOpt : false;
   let modulePrefix = modulePrefixOpt !== undefined ? modulePrefixOpt : "";
   return {
     warnings: [],
+    extractedTypes: [],
+    extractCounter: 0,
     path: path,
     insideComponentSchemas: insideComponentSchemas,
     availableSchemas: availableSchemas,
-    modulePrefix: modulePrefix
+    modulePrefix: modulePrefix,
+    selfRefName: selfRefName
   };
 }
 
@@ -17,8 +21,27 @@ function addWarning(ctx, warning) {
   ctx.warnings.push(warning);
 }
 
+function extractType(ctx, baseName, isUnboxedOpt, irType) {
+  let isUnboxed = isUnboxedOpt !== undefined ? isUnboxedOpt : false;
+  let existing = ctx.extractedTypes.find(param => SchemaIR.equals(param.irType, irType));
+  if (existing !== undefined) {
+    return existing.typeName;
+  }
+  ctx.extractCounter = ctx.extractCounter + 1 | 0;
+  let first = baseName.charAt(0);
+  let lowerBaseName = first === "" ? "extracted" : first.toLowerCase() + baseName.slice(1);
+  let typeName = lowerBaseName + `_` + ctx.extractCounter.toString();
+  ctx.extractedTypes.push({
+    typeName: typeName,
+    irType: irType,
+    isUnboxed: isUnboxed
+  });
+  return typeName;
+}
+
 export {
   make,
   addWarning,
+  extractType,
 }
 /* No side effect */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@f3liz/rescript-autogen-openapi",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Generate ReScript code with Sury schemas from OpenAPI 3.1 specs. Supports multiple forks with diff/merge capabilities.",
   "keywords": [
     "rescript",
@@ -38,7 +38,8 @@
   "dependencies": {
     "@readme/openapi-parser": "^5.5.0",
     "js-convert-case": "^4.2.0",
-    "pathe": "^2.0.3"
+    "pathe": "^2.0.3",
+    "toposort": "^2.0.2"
   },
   "devDependencies": {
     "rescript": "^12.1.0",

package/src/bindings/Toposort.res

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MPL-2.0
+
+// Toposort.res - ReScript bindings for the toposort npm package
+
+type toposortModule
+
+@module("toposort") external toposortModule: toposortModule = "default"
+
+// toposort.array(nodes, edges) — sort nodes topologically given directed edges
+// edges: array of [from, to] meaning "from depends on to" (to must come before from)
+// Returns sorted array (dependencies first)
+// Throws on cycles
+@send
+external array: (toposortModule, array<string>, array<(string, string)>) => array<string> = "array"
+
+let sortArray = (nodes, edges) => toposortModule->array(nodes, edges)

package/src/core/CodegenUtils.res

@@ -128,3 +128,53 @@ let generateDocString = (~summary=?, ~description=?, ()): string => {
 
 // Shared type signature for the fetch function used in generated code
 let fetchTypeSignature = "(~url: string, ~method_: string, ~body: option<JSON.t>) => Promise.t<JSON.t>"
+
+// Generate variant constructor name from an IR type
+let rec variantConstructorName = (irType: SchemaIR.irType): string => {
+  switch irType {
+  | String(_) => "String"
+  | Number(_) => "Float"
+  | Integer(_) => "Int"
+  | Boolean => "Bool"
+  | Null => "Null"
+  | Array(_) => "Array"
+  | Object(_) => "Object"
+  | Reference(ref) =>
+    let name = if ref->String.includes("/") {
+      ref->String.split("/")->Array.get(ref->String.split("/")->Array.length - 1)->Option.getOr("Ref")
+    } else {
+      ref
+    }
+    toPascalCase(name)
+  | Literal(StringLiteral(s)) => toPascalCase(s)
+  | Literal(NumberLiteral(_)) => "Number"
+  | Literal(BooleanLiteral(_)) => "Bool"
+  | Literal(NullLiteral) => "Null"
+  | Option(inner) => variantConstructorName(inner)
+  | Intersection(_) => "Intersection"
+  | Union(_) => "Union"
+  | Unknown => "Unknown"
+  }
+}
+
+// Deduplicate variant constructor names by appending counter suffix
+let deduplicateNames = (names: array<string>): array<string> => {
+  let counts: Dict.t<int> = Dict.make()
+  let result: array<string> = []
+  names->Array.forEach(name => {
+    let count = counts->Dict.get(name)->Option.getOr(0)
+    counts->Dict.set(name, count + 1)
+  })
+  let seen: Dict.t<int> = Dict.make()
+  names->Array.forEach(name => {
+    let total = counts->Dict.get(name)->Option.getOr(1)
+    if total > 1 {
+      let idx = seen->Dict.get(name)->Option.getOr(0) + 1
+      seen->Dict.set(name, idx)
+      result->Array.push(`${name}${Int.toString(idx)}`)
+    } else {
+      result->Array.push(name)
+    }
+  })
+  result
+}

package/src/core/SchemaIR.res

@@ -205,6 +205,39 @@ let rec equals = (a: irType, b: irType): bool => {
   | (Boolean, Boolean) => true
   | (Null, Null) => true
   | (Array({items: itemsA, _}), Array({items: itemsB, _})) => equals(itemsA, itemsB)
+  | (Object({properties: propsA, additionalProperties: addA}), Object({properties: propsB, additionalProperties: addB})) =>
+    Array.length(propsA) == Array.length(propsB) &&
+    propsA->Array.everyWithIndex((propA, i) => {
+      switch propsB->Array.get(i) {
+      | Some(propB) => {
+          let (nameA, typeA, reqA) = propA
+          let (nameB, typeB, reqB) = propB
+          nameA == nameB && reqA == reqB && equals(typeA, typeB)
+        }
+      | None => false
+      }
+    }) &&
+    switch (addA, addB) {
+    | (Some(a), Some(b)) => equals(a, b)
+    | (None, None) => true
+    | _ => false
+    }
+  | (Union(typesA), Union(typesB)) =>
+    Array.length(typesA) == Array.length(typesB) &&
+    typesA->Array.everyWithIndex((tA, i) =>
+      switch typesB->Array.get(i) {
+      | Some(tB) => equals(tA, tB)
+      | None => false
+      }
+    )
+  | (Intersection(typesA), Intersection(typesB)) =>
+    Array.length(typesA) == Array.length(typesB) &&
+    typesA->Array.everyWithIndex((tA, i) =>
+      switch typesB->Array.get(i) {
+      | Some(tB) => equals(tA, tB)
+      | None => false
+      }
+    )
   | (Reference(refA), Reference(refB)) => refA == refB
   | (Option(innerA), Option(innerB)) => equals(innerA, innerB)
   | (Literal(litA), Literal(litB)) => {

package/src/core/SchemaIRParser.res

@@ -5,6 +5,7 @@
 // Helper to convert raw JSON type string to our variant
 // This is needed because Obj.magic from JSON gives us raw strings like "string", "object", etc.
 // but our variant constructors compile to "String", "Object", etc. in JS
+// Also handles OpenAPI 3.1 array form: type: ["string", "null"]
 let parseTypeString = (rawType: Types.jsonSchemaType): Types.jsonSchemaType => {
   // The rawType might actually be a raw string from JSON, so we need to handle that
   // We use Obj.magic to get the underlying JS value and check it
@@ -34,6 +35,21 @@ let parseTypeString = (rawType: Types.jsonSchemaType): Types.jsonSchemaType => {
   }
 }
 
+// Check if the type field is an array (OpenAPI 3.1: type: ["string", "null"])
+// Returns Some(array of parsed types) if array, None otherwise
+let parseTypeAsArray = (rawType: Types.jsonSchemaType): option<array<Types.jsonSchemaType>> => {
+  let raw: 'a = Obj.magic(rawType)
+  if Array.isArray(raw) {
+    let arr: array<string> = Obj.magic(raw)
+    Some(arr->Array.map(s => {
+      let t: Types.jsonSchemaType = Obj.magic(s)
+      parseTypeString(t)
+    }))
+  } else {
+    None
+  }
+}
+
 // Parsing context to collect warnings
 type parsingContext = {
   mutable warnings: array<Types.warning>,
@@ -68,6 +84,44 @@ let rec parseJsonSchemaWithContext = (
       // Check if nullable
       let isNullable = schema.nullable->Option.getOr(false)
       
+      // Handle OpenAPI 3.1 array type: type: ["string", "null"]
+      // But skip if anyOf/oneOf is present — those are more specific
+      let hasComposition = schema.anyOf->Option.isSome || schema.oneOf->Option.isSome
+      let typeAsArray = if hasComposition {
+        None
+      } else {
+        schema.type_->Option.flatMap(parseTypeAsArray)
+      }
+      // When composition is preferred, check if the type_ is actually an array
+      // and clear it so the None branch runs the composition handlers
+      let schema = if hasComposition && schema.type_->Option.flatMap(parseTypeAsArray)->Option.isSome {
+        {...schema, type_: None}
+      } else {
+        schema
+      }
+      
+      switch typeAsArray {
+      | Some(types) if Array.length(types) > 1 => {
+          // Array type form — convert to Union of parsed types
+          let irTypes = types->Array.map(t => {
+            let subSchema = {...schema, type_: Some(t), nullable: None}
+            parseJsonSchemaWithContext(~ctx, ~depth=depth + 1, subSchema)
+          })
+          let baseType = SchemaIR.Union(irTypes)
+          if isNullable {
+            SchemaIR.Option(baseType)
+          } else {
+            baseType
+          }
+        }
+      | Some(types) if Array.length(types) == 1 => {
+          // Single-element array: treat as that type
+          let subSchema = {...schema, type_: Some(types->Array.getUnsafe(0)), nullable: None}
+          let baseType = parseJsonSchemaWithContext(~ctx, ~depth=depth + 1, subSchema)
+          if isNullable { SchemaIR.Option(baseType) } else { baseType }
+        }
+      | _ => {
+      
       // Normalize the type field (raw JSON strings like "string" -> variant String)
       let normalizedType = schema.type_->Option.map(parseTypeString)
       
@@ -164,8 +218,8 @@ let rec parseJsonSchemaWithContext = (
               SchemaIR.Union(literals)
             }
            | (_, Some(_), _, _, _) => {
-              // Has properties, treat as object
-              parseJsonSchemaWithContext(~ctx, ~depth=depth + 1, {...schema, type_: Some(Object)})
+              // Has properties, treat as object (clear nullable to avoid double wrapping)
+              parseJsonSchemaWithContext(~ctx, ~depth=depth + 1, {...schema, type_: Some(Object), nullable: None})
             }
           | (_, _, Some(schemas), _, _) => {
               // allOf - intersection
@@ -193,6 +247,8 @@ let rec parseJsonSchemaWithContext = (
       } else {
         baseType
       }
+    } // end | _ => (typeAsArray arm)
+    } // end switch typeAsArray
     }
   }
   }
@@ -216,6 +272,37 @@ let parseNamedSchema = (~name: string, ~schema: Types.jsonSchema): (SchemaIR.nam
   }, ctx.warnings)
 }
 
+// Normalize $ref paths in IR: "#/components/schemas/Name" → "Name" (when Name exists in available schemas)
+let rec normalizeReferences = (~availableNames: array<string>, irType: SchemaIR.irType): SchemaIR.irType => {
+  switch irType {
+  | SchemaIR.Reference(ref) => {
+      let parts = ref->String.split("/")
+      let name = parts->Array.get(parts->Array.length - 1)->Option.getOr("")
+      if availableNames->Array.includes(name) {
+        SchemaIR.Reference(name)
+      } else {
+        irType
+      }
+    }
+  | SchemaIR.Array({items, constraints}) =>
+    SchemaIR.Array({items: normalizeReferences(~availableNames, items), constraints})
+  | SchemaIR.Object({properties, additionalProperties}) => {
+      let newProperties = properties->Array.map(((n, t, r)) =>
+        (n, normalizeReferences(~availableNames, t), r)
+      )
+      let newAdditional = additionalProperties->Option.map(t => normalizeReferences(~availableNames, t))
+      SchemaIR.Object({properties: newProperties, additionalProperties: newAdditional})
+    }
+  | SchemaIR.Union(types) =>
+    SchemaIR.Union(types->Array.map(t => normalizeReferences(~availableNames, t)))
+  | SchemaIR.Intersection(types) =>
+    SchemaIR.Intersection(types->Array.map(t => normalizeReferences(~availableNames, t)))
+  | SchemaIR.Option(inner) =>
+    SchemaIR.Option(normalizeReferences(~availableNames, inner))
+  | other => other
+  }
+}
+
 // Parse all component schemas
 let parseComponentSchemas = (schemas: dict<Types.jsonSchema>): (SchemaIR.schemaContext, array<Types.warning>) => {
   let namedSchemas = Dict.make()
@@ -227,6 +314,13 @@ let parseComponentSchemas = (schemas: dict<Types.jsonSchema>): (SchemaIR.schemaC
     allWarnings->Array.pushMany(warnings)
   })
   
+  // Resolve $ref paths in the IR: normalize "#/components/schemas/Name" to just "Name"
+  let availableNames = Dict.keysToArray(namedSchemas)
+  namedSchemas->Dict.toArray->Array.forEach(((name, namedSchema)) => {
+    let resolved = normalizeReferences(~availableNames, namedSchema.type_)
+    Dict.set(namedSchemas, name, {...namedSchema, type_: resolved})
+  })
+  
   ({schemas: namedSchemas}, allWarnings)
 }
 

package/src/generators/ComponentSchemaGenerator.res

@@ -6,8 +6,8 @@ open Types
 let rec extractReferencedSchemaNames = (irType: SchemaIR.irType) =>
   switch irType {
   | Reference(ref) =>
-    let parts = ref->String.split("/")
-    [parts->Array.get(parts->Array.length - 1)->Option.getOr("")]
+    // After normalization, ref is just the schema name (no path prefix)
+    [ref]
   | Array({items}) => extractReferencedSchemaNames(items)
   | Object({properties}) => properties->Array.flatMap(((_name, fieldType, _)) => extractReferencedSchemaNames(fieldType))
   | Union(types)
@@ -31,88 +31,171 @@ let generate = (~spec, ~outputDir) => {
     let schemas = Dict.valuesToArray(context.schemas)
     let schemaNameMap = Dict.fromArray(schemas->Array.map(s => (s.name, s)))
 
-    // Map each schema to its internal dependencies (other schemas in the same spec)
-    let dependencyMap = schemas->Array.reduce(Dict.make(), (acc, schema) => {
+    // Build dependency edges for topological sort
+    // Edge (A, B) means "A depends on B" so B must come before A
+    let allNodes = schemas->Array.map(s => s.name)
+    let edges = schemas->Array.flatMap(schema => {
       let references =
         extractReferencedSchemaNames(schema.type_)->Array.filter(name =>
           Dict.has(schemaNameMap, name) && name != schema.name
         )
-      Dict.set(acc, schema.name, references)
-      acc
+      references->Array.map(dep => (schema.name, dep))
     })
 
-    // Topological sort (Kahn's algorithm) to handle schema dependencies
-    let sortedSchemas = []
-    let inDegreeMap = schemas->Array.reduce(Dict.make(), (acc, schema) => {
-      let degree = Dict.get(dependencyMap, schema.name)->Option.mapOr(0, Array.length)
-      Dict.set(acc, schema.name, degree)
-      acc
-    })
-
-    let queue = schemas->Array.filter(schema => Dict.get(inDegreeMap, schema.name)->Option.getOr(0) == 0)
-
-    while Array.length(queue) > 0 {
-      let schema = switch Array.shift(queue) {
-      | Some(v) => v
-      | None => schemas->Array.getUnsafe(0) // Should not happen
-      }
-      sortedSchemas->Array.push(schema)
-
-      schemas->Array.forEach(otherSchema => {
-        let dependsOnCurrent =
-          Dict.get(dependencyMap, otherSchema.name)
-          ->Option.getOr([])
-          ->Array.some(name => name == schema.name)
-
-        if dependsOnCurrent {
-          let currentDegree = Dict.get(inDegreeMap, otherSchema.name)->Option.getOr(0)
-          let newDegree = currentDegree - 1
-          Dict.set(inDegreeMap, otherSchema.name, newDegree)
-          if newDegree == 0 {
-            queue->Array.push(otherSchema)
-          }
+    // Use toposort with cycle tolerance: if there's a cycle, catch and fall back
+    // Note: toposort returns dependents first, dependencies last.
+    // We reverse to get execution order (dependencies first).
+    let sortedNames = try {
+      Toposort.sortArray(allNodes, edges)->Array.toReversed
+    } catch {
+    | _ =>
+      // Cycles exist — remove back-edges and re-sort
+      let visited = Dict.make()
+      let inStack = Dict.make()
+      let cycleEdges: array<(string, string)> = []
+      
+      let rec dfs = (node) => {
+        if Dict.get(inStack, node)->Option.getOr(false) {
+          ()
+        } else if Dict.get(visited, node)->Option.getOr(false) {
+          ()
+        } else {
+          Dict.set(visited, node, true)
+          Dict.set(inStack, node, true)
+          edges->Array.forEach(((from, to)) => {
+            if from == node {
+              if Dict.get(inStack, to)->Option.getOr(false) {
+                cycleEdges->Array.push((from, to))
+              } else {
+                dfs(to)
+              }
+            }
+          })
+          Dict.set(inStack, node, false)
         }
-      })
+      }
+      allNodes->Array.forEach(dfs)
+      
+      let nonCycleEdges = edges->Array.filter(((from, to)) =>
+        !(cycleEdges->Array.some(((cf, ct)) => cf == from && ct == to))
+      )
+      try {
+        Toposort.sortArray(allNodes, nonCycleEdges)->Array.toReversed
+      } catch {
+      | _ => allNodes->Array.toSorted((a, b) => String.compare(a, b))
+      }
     }
 
-    // Ensure all schemas are included even if there's a circular dependency
-    let sortedNames = sortedSchemas->Array.map(s => s.name)
-    let remainingSchemas =
-      schemas
-      ->Array.filter(s => !(sortedNames->Array.some(name => name == s.name)))
-      ->Array.toSorted((a, b) => String.compare(a.name, b.name))
-
-    let finalSortedSchemas = Array.concat(sortedSchemas, remainingSchemas)
+    let finalSortedSchemas = sortedNames->Array.filterMap(name => Dict.get(schemaNameMap, name))
     let availableSchemaNames = finalSortedSchemas->Array.map(s => s.name)
     let warnings = Array.copy(parseWarnings)
 
+    // Detect self-referencing schemas (schema references itself directly or indirectly through properties)
+    let selfRefSchemas = Dict.make()
+    finalSortedSchemas->Array.forEach(schema => {
+      let refs = extractReferencedSchemaNames(schema.type_)
+      if refs->Array.some(name => name == schema.name) {
+        Dict.set(selfRefSchemas, schema.name, true)
+      }
+    })
+
     let moduleCodes = finalSortedSchemas->Array.map(schema => {
+      let isSelfRef = Dict.get(selfRefSchemas, schema.name)->Option.getOr(false)
+      let selfRefName = isSelfRef ? Some(schema.name) : None
+      
       let typeCtx = GenerationContext.make(
         ~path=`ComponentSchemas.${schema.name}`,
         ~insideComponentSchemas=true,
         ~availableSchemas=availableSchemaNames,
+        ~selfRefName?,
         (),
       )
+
+      let typeCode = IRToTypeGenerator.generateTypeWithContext(~ctx=typeCtx, ~depth=0, schema.type_)
+
+      // Iteratively resolve nested extractions using typeCtx
+      let processed = ref(0)
+      while processed.contents < Array.length(typeCtx.extractedTypes) {
+        let idx = processed.contents
+        let {irType, isUnboxed, _}: GenerationContext.extractedType = typeCtx.extractedTypes->Array.getUnsafe(idx)
+        if !isUnboxed {
+          ignore(IRToTypeGenerator.generateTypeWithContext(~ctx=typeCtx, ~depth=0, ~inline=false, irType))
+        } else {
+          switch irType {
+          | Union(types) =>
+            types->Array.forEach(memberType => {
+              ignore(IRToTypeGenerator.generateTypeWithContext(~ctx=typeCtx, ~depth=0, ~inline=true, memberType))
+            })
+          | _ => ignore(IRToTypeGenerator.generateTypeWithContext(~ctx=typeCtx, ~depth=0, ~inline=false, irType))
+          }
+        }
+        processed := idx + 1
+      }
+
+      let allExtracted = Array.copy(typeCtx.extractedTypes)->Array.toReversed
+      let extractedTypeMap = if Array.length(allExtracted) > 0 { Some(allExtracted) } else { None }
+
+      // Generate schema with extracted type map for correct references
       let schemaCtx = GenerationContext.make(
         ~path=`ComponentSchemas.${schema.name}`,
         ~insideComponentSchemas=true,
         ~availableSchemas=availableSchemaNames,
+        ~selfRefName?,
         (),
       )
-
-      let typeCode = IRToTypeGenerator.generateTypeWithContext(~ctx=typeCtx, ~depth=0, schema.type_)
-      let schemaCode = IRToSuryGenerator.generateSchemaWithContext(~ctx=schemaCtx, ~depth=0, schema.type_)
+      let schemaCode = IRToSuryGenerator.generateSchemaWithContext(~ctx=schemaCtx, ~depth=0, ~extractedTypeMap?, schema.type_)
 
       warnings->Array.pushMany(typeCtx.warnings)
       warnings->Array.pushMany(schemaCtx.warnings)
 
+      // Generate extracted auxiliary types and schemas (use ctx for dedup)
+      let extractedTypeDefs = allExtracted->Array.map(({typeName, irType, isUnboxed}: GenerationContext.extractedType) => {
+        let auxTypeCode = if isUnboxed {
+          switch irType {
+          | Union(types) =>
+            let body = IRToTypeGenerator.generateUnboxedVariantBody(~ctx=typeCtx, types)
+            `@unboxed type ${typeName} = ${body}`
+          | _ =>
+            let auxType = IRToTypeGenerator.generateTypeWithContext(~ctx=typeCtx, ~depth=0, irType)
+            `type ${typeName} = ${auxType}`
+          }
+        } else {
+          let auxType = IRToTypeGenerator.generateTypeWithContext(~ctx=typeCtx, ~depth=0, irType)
+          `type ${typeName} = ${auxType}`
+        }
+        let auxSchemaCtx = GenerationContext.make(
+          ~path=`ComponentSchemas.${schema.name}.${typeName}`,
+          ~insideComponentSchemas=true,
+          ~availableSchemas=availableSchemaNames,
+          (),
+        )
+        // Exclude the current type from the map to avoid self-reference
+        let filteredMap = allExtracted->Array.filter(({typeName: tn}: GenerationContext.extractedType) => tn != typeName)
+        let auxExtractedTypeMap = if Array.length(filteredMap) > 0 { Some(filteredMap) } else { None }
+        let auxSchema = IRToSuryGenerator.generateSchemaWithContext(~ctx=auxSchemaCtx, ~depth=0, ~extractedTypeMap=?auxExtractedTypeMap, irType)
+        `  ${auxTypeCode}\n  let ${typeName}Schema = ${auxSchema}`
+      })
+
       let docComment = schema.description->Option.mapOr("", d =>
         CodegenUtils.generateDocString(~description=d, ())
       )
 
+      let extractedBlock = if Array.length(extractedTypeDefs) > 0 {
+        extractedTypeDefs->Array.join("\n") ++ "\n"
+      } else {
+        ""
+      }
+
+      // Use `type rec t` for self-referential types
+      let typeKeyword = isSelfRef ? "type rec t" : "type t"
+      // Wrap schema in S.recursive for self-referential types
+      let finalSchemaCode = isSelfRef
+        ? `S.recursive("${schema.name}", schema => ${schemaCode})`
+        : schemaCode
+
       `${docComment}module ${CodegenUtils.toPascalCase(schema.name)} = {
-  type t = ${typeCode}
-  let schema = ${schemaCode}
+${extractedBlock}  ${typeKeyword} = ${typeCode}
+  let schema = ${finalSchemaCode}
 }`
     })
 

package/src/generators/EndpointGenerator.res

@@ -10,13 +10,14 @@ let getJsonSchemaFromRequestBody = (requestBody: option<requestBody>) =>
 
 let generateTypeCodeAndSchemaCode = (~jsonSchema, ~typeName, ~schemaName, ~modulePrefix="") => {
   let (ir, _) = SchemaIRParser.parseJsonSchema(jsonSchema)
-  let (typeCode, _) = IRToTypeGenerator.generateNamedType(
+  let (typeCode, _, extractedTypes) = IRToTypeGenerator.generateNamedType(
     ~namedSchema={name: typeName, description: jsonSchema.description, type_: ir},
     ~modulePrefix,
   )
   let (schemaCode, _) = IRToSuryGenerator.generateNamedSchema(
     ~namedSchema={name: schemaName, description: jsonSchema.description, type_: ir},
     ~modulePrefix,
+    ~extractedTypes,
   )
   (typeCode, schemaCode)
 }
@@ -34,7 +35,10 @@ let generateEndpointFunction = (endpoint: endpoint, ~overrideDir=?, ~moduleName=
   
   let bodyParam = hasRequestBody
     ? (isRequestBodyRequired ? `~body: ${requestTypeName}` : `~body: option<${requestTypeName}>=?`)
-    : "~body as _"
+    : ""
+  
+  // Clean up function signature: handle comma between body and fetch params
+  let paramSep = hasRequestBody ? ", " : ""
   
   let bodyValueConversion = hasRequestBody
     ? (
@@ -83,7 +87,7 @@ let generateEndpointFunction = (endpoint: endpoint, ~overrideDir=?, ~moduleName=
   
   let code = `
     |${docComment->String.trimEnd}
-    |let ${functionName} = (${bodyParam}, ~fetch: ${CodegenUtils.fetchTypeSignature}): promise<${functionName}Response> => {
+    |let ${functionName} = (${bodyParam}${paramSep}~fetch: ${CodegenUtils.fetchTypeSignature}): promise<${functionName}Response> => {
     |${bodyValueConversion}
     |  fetch(
     |    ~url="${endpoint.path}",