@f3liz/rescript-autogen-openapi 0.1.7 → 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}") ` : ""
@@ -48,102 +63,262 @@ let rec generateTypeWithContext = (~ctx: GenerationContext.t, ~depth=0, irType:
       | NullLiteral => "unit"
       }
     | Union(types) =>
-      // Attempt to simplify common union patterns
-      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
+        }
       )
+      let hasNull = Array.length(nonNullTypes) < Array.length(types)
 
-      if (
-        hasArray &&
-        hasNonArray &&
-        SchemaIR.equals(Option.getOr(arrayItemType, Unknown), Option.getOr(nonArrayType, Unknown))
-      ) {
-        `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
-      ) {
-        let variants =
-          types
-          ->Array.map(t =>
-            switch t {
-            | Literal(StringLiteral(s)) => `#${CodegenUtils.toPascalCase(s)}`
-            | _ => "#Unknown"
-            }
-          )
-          ->Array.join(" | ")
-        `[${variants}]`
+      // If the union is just [T, null], treat as option<T>
+      if hasNull && Array.length(nonNullTypes) == 1 {
+        let inner = generateTypeWithContext(~ctx, ~depth=depth + 1, ~inline=true, nonNullTypes->Array.getUnsafe(0))
+        `option<${inner}>`
       } else {
-        addWarning(
-          ctx,
-          ComplexUnionSimplified({
-            location: ctx.path,
-            types: types->Array.map(SchemaIR.toString)->Array.join(" | "),
-          }),
+        // Work with the non-null types (re-wrap in option at the end if hasNull)
+        let effectiveTypes = hasNull ? nonNullTypes : types
+
+        // Attempt to simplify common union patterns
+        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))
+            },
         )
-        "JSON.t"
+
+        let result = if (
+          hasArray &&
+          hasNonArray &&
+          Array.length(effectiveTypes) == 2 &&
+          SchemaIR.equals(Option.getOr(arrayItemType, Unknown), Option.getOr(nonArrayType, Unknown))
+        ) {
+          `array<${recurseInline(Option.getOr(arrayItemType, Unknown))}>`
+        } else if (
+          effectiveTypes->Array.every(t =>
+            switch t {
+            | Literal(StringLiteral(_)) => true
+            | _ => false
+            }
+          ) &&
+          Array.length(effectiveTypes) > 0 &&
+          Array.length(effectiveTypes) <= 50
+        ) {
+          // Polymorphic variants: valid inline
+          let variants =
+            effectiveTypes
+            ->Array.map(t =>
+              switch t {
+              | Literal(StringLiteral(s)) => `#${CodegenUtils.toPascalCase(s)}`
+              | _ => "#Unknown"
+              }
+            )
+            ->Array.join(" | ")
+          `[${variants}]`
+        } else if Array.length(effectiveTypes) > 0 {
+          // 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"
+              }
+              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
+            }
+            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"
+        }
+
+        hasNull ? `option<${result}>` : result
       }
     | Intersection(types) =>
-      // Basic support for intersections by picking the last reference or falling back
+      // Support for intersections: merge object properties or pick last reference
       if types->Array.every(t =>
         switch t {
         | Reference(_) => true
         | _ => 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 {
-        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]))
+            },
         )
-        "JSON.t"
+        if Array.length(objectProps) > 0 && Array.length(nonObjectTypes) == 0 {
+          // All objects: merge properties
+          let fields =
+            objectProps
+            ->Array.map(((name, fieldType, isRequired)) => {
+              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}") ` : ""
+              `  ${aliasAnnotation}${escapedName}: ${finalType},`
+            })
+            ->Array.join("\n")
+          `{\n${fields}\n}`
+        } else if Array.length(nonObjectTypes) > 0 && Array.length(objectProps) == 0 {
+          // No objects: pick last type as best effort
+          generateTypeWithContext(~ctx, ~depth=depth + 1, ~inline, types->Array.get(Array.length(types) - 1)->Option.getOr(Unknown))
+        } else {
+          addWarning(
+            ctx,
+            IntersectionNotFullySupported({location: ctx.path, note: "Mixed object/non-object intersection"}),
+          )
+          // Merge what we can, ignore non-object parts
+          let fields =
+            objectProps
+            ->Array.map(((name, fieldType, isRequired)) => {
+              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}") ` : ""
+              `  ${aliasAnnotation}${escapedName}: ${finalType},`
+            })
+            ->Array.join("\n")
+          `{\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="",
@@ -173,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,
   )
 }
 
@@ -185,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
     })
@@ -193,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
+  }
+}