@f3liz/rescript-autogen-openapi 0.1.7 → 0.2.0

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

@@ -97,7 +97,22 @@ function generateSchemaWithContext(ctx, depthOpt, irType) {
         }
       case "Union" :
         let types = irType._0;
-        let match = Stdlib_Array.reduce(types, [
+        let nonNullTypes = types.filter(t => {
+          if (typeof t !== "object") {
+            return t !== "Null";
+          }
+          if (t.TAG !== "Literal") {
+            return true;
+          }
+          let tmp = t._0;
+          return typeof tmp === "object";
+        });
+        let hasNull = nonNullTypes.length < types.length;
+        if (hasNull && nonNullTypes.length === 1) {
+          return `S.nullableAsOption(` + recurse(nonNullTypes[0]) + `)`;
+        }
+        let effectiveTypes = hasNull ? nonNullTypes : types;
+        let match = Stdlib_Array.reduce(effectiveTypes, [
           false,
           false,
           undefined,
@@ -122,39 +137,97 @@ function generateSchemaWithContext(ctx, depthOpt, irType) {
           }
         });
         let arrayItemType = match[2];
-        if (match[0] && match[1] && SchemaIR.equals(Stdlib_Option.getOr(arrayItemType, "Unknown"), Stdlib_Option.getOr(match[3], "Unknown"))) {
-          return `S.array(` + recurse(Stdlib_Option.getOr(arrayItemType, "Unknown")) + `)`;
-        } else if (types.every(t => {
+        let result = match[0] && match[1] && effectiveTypes.length === 2 && SchemaIR.equals(Stdlib_Option.getOr(arrayItemType, "Unknown"), Stdlib_Option.getOr(match[3], "Unknown")) ? `S.array(` + recurse(Stdlib_Option.getOr(arrayItemType, "Unknown")) + `)` : (
+            effectiveTypes.every(t => {
+              if (typeof t !== "object") {
+                return false;
+              }
+              if (t.TAG !== "Literal") {
+                return false;
+              }
+              let tmp = t._0;
+              if (typeof tmp !== "object") {
+                return false;
+              } else {
+                return tmp.TAG === "StringLiteral";
+              }
+            }) && effectiveTypes.length !== 0 && effectiveTypes.length <= 50 ? `S.union([` + effectiveTypes.map(recurse).join(", ") + `])` : (
+                effectiveTypes.length !== 0 ? `S.union([` + effectiveTypes.map(recurse).join(", ") + `])` : "S.json"
+              )
+          );
+        if (hasNull) {
+          return `S.nullableAsOption(` + result + `)`;
+        } else {
+          return result;
+        }
+      case "Intersection" :
+        let types$1 = irType._0;
+        if (types$1.every(t => {
             if (typeof t !== "object") {
               return false;
+            } else {
+              return t.TAG === "Reference";
             }
-            if (t.TAG !== "Literal") {
-              return false;
+          }) && types$1.length !== 0) {
+          return recurse(Stdlib_Option.getOr(types$1[types$1.length - 1 | 0], "Unknown"));
+        }
+        let match$1 = Stdlib_Array.reduce(types$1, [
+          [],
+          []
+        ], (param, t) => {
+          let nonObj = param[1];
+          let props = param[0];
+          if (typeof t !== "object") {
+            return [
+              props,
+              nonObj.concat([t])
+            ];
+          } else if (t.TAG === "Object") {
+            return [
+              props.concat(t.properties),
+              nonObj
+            ];
+          } else {
+            return [
+              props,
+              nonObj.concat([t])
+            ];
+          }
+        });
+        let nonObjectTypes = match$1[1];
+        let objectProps = match$1[0];
+        if (objectProps.length !== 0 && nonObjectTypes.length === 0) {
+          let fields$1 = objectProps.map(param => {
+            let name = param[0];
+            let schemaCode = recurse(param[1]);
+            let camelName = CodegenUtils.escapeKeyword(JsConvertCase.toCamelCase(name));
+            if (param[2]) {
+              return `    ` + camelName + `: s.field("` + name + `", ` + schemaCode + `),`;
+            } else {
+              return `    ` + camelName + `: s.fieldOr("` + name + `", S.nullableAsOption(` + schemaCode + `), None),`;
             }
-            let tmp = t._0;
-            return typeof tmp !== "object" ? false : tmp.TAG === "StringLiteral";
-          }) && types.length !== 0 && types.length <= 50) {
-          return `S.union([` + types.map(recurse).join(", ") + `])`;
-        } else {
-          GenerationContext.addWarning(ctx, {
-            TAG: "ComplexUnionSimplified",
-            location: ctx.path,
-            types: types.map(SchemaIR.toString).join(" | ")
-          });
-          return "S.json";
+          }).join("\n");
+          return `S.object(s => {\n` + fields$1 + `\n  })`;
         }
-      case "Intersection" :
-        let types$1 = irType._0;
-        if (types$1.every(t => typeof t !== "object" ? false : t.TAG === "Reference") && types$1.length !== 0) {
+        if (nonObjectTypes.length !== 0 && objectProps.length === 0) {
           return recurse(Stdlib_Option.getOr(types$1[types$1.length - 1 | 0], "Unknown"));
-        } else {
-          GenerationContext.addWarning(ctx, {
-            TAG: "IntersectionNotFullySupported",
-            location: ctx.path,
-            note: "Complex intersection"
-          });
-          return "S.json";
         }
+        GenerationContext.addWarning(ctx, {
+          TAG: "IntersectionNotFullySupported",
+          location: ctx.path,
+          note: "Mixed object/non-object intersection"
+        });
+        let fields$2 = objectProps.map(param => {
+          let name = param[0];
+          let schemaCode = recurse(param[1]);
+          let camelName = CodegenUtils.escapeKeyword(JsConvertCase.toCamelCase(name));
+          if (param[2]) {
+            return `    ` + camelName + `: s.field("` + name + `", ` + schemaCode + `),`;
+          } else {
+            return `    ` + camelName + `: s.fieldOr("` + name + `", S.nullableAsOption(` + schemaCode + `), None),`;
+          }
+        }).join("\n");
+        return `S.object(s => {\n` + fields$2 + `\n  })`;
       case "Reference" :
         let ref = irType._0;
         let available = ctx.availableSchemas;

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

@@ -75,7 +75,23 @@ function generateTypeWithContext(ctx, depthOpt, irType) {
         }
       case "Union" :
         let types = irType._0;
-        let match = Stdlib_Array.reduce(types, [
+        let nonNullTypes = types.filter(t => {
+          if (typeof t !== "object") {
+            return t !== "Null";
+          }
+          if (t.TAG !== "Literal") {
+            return true;
+          }
+          let tmp = t._0;
+          return typeof tmp === "object";
+        });
+        let hasNull = nonNullTypes.length < types.length;
+        if (hasNull && nonNullTypes.length === 1) {
+          let inner = recurse(nonNullTypes[0]);
+          return `option<` + inner + `>`;
+        }
+        let effectiveTypes = hasNull ? nonNullTypes : types;
+        let match = Stdlib_Array.reduce(effectiveTypes, [
           false,
           false,
           undefined,
@@ -100,10 +116,10 @@ function generateTypeWithContext(ctx, depthOpt, irType) {
           }
         });
         let arrayItemType = match[2];
-        if (match[0] && match[1] && SchemaIR.equals(Stdlib_Option.getOr(arrayItemType, "Unknown"), Stdlib_Option.getOr(match[3], "Unknown"))) {
-          return `array<` + recurse(Stdlib_Option.getOr(arrayItemType, "Unknown")) + `>`;
-        }
-        if (types.every(t => {
+        let result;
+        if (match[0] && match[1] && effectiveTypes.length === 2 && SchemaIR.equals(Stdlib_Option.getOr(arrayItemType, "Unknown"), Stdlib_Option.getOr(match[3], "Unknown"))) {
+          result = `array<` + recurse(Stdlib_Option.getOr(arrayItemType, "Unknown")) + `>`;
+        } else if (effectiveTypes.every(t => {
             if (typeof t !== "object") {
               return false;
             }
@@ -116,8 +132,8 @@ function generateTypeWithContext(ctx, depthOpt, irType) {
             } else {
               return tmp.TAG === "StringLiteral";
             }
-          }) && types.length !== 0 && types.length <= 50) {
-          let variants = types.map(t => {
+          }) && effectiveTypes.length !== 0 && effectiveTypes.length <= 50) {
+          let variants = effectiveTypes.map(t => {
             if (typeof t !== "object") {
               return "#Unknown";
             }
@@ -131,26 +147,155 @@ function generateTypeWithContext(ctx, depthOpt, irType) {
               return `#` + JsConvertCase.toPascalCase(s._0);
             }
           }).join(" | ");
-          return `[` + variants + `]`;
+          result = `[` + variants + `]`;
+        } else if (effectiveTypes.length !== 0) {
+          let hasPrimitives = {
+            contents: false
+          };
+          let variantCases = effectiveTypes.map((t, i) => {
+            let match;
+            let exit = 0;
+            if (typeof t !== "object") {
+              if (t === "Boolean") {
+                hasPrimitives.contents = true;
+                match = [
+                  "Bool",
+                  "bool"
+                ];
+              } else {
+                exit = 1;
+              }
+            } else {
+              switch (t.TAG) {
+                case "String" :
+                  hasPrimitives.contents = true;
+                  match = [
+                    "String",
+                    "string"
+                  ];
+                  break;
+                case "Number" :
+                  hasPrimitives.contents = true;
+                  match = [
+                    "Float",
+                    "float"
+                  ];
+                  break;
+                case "Integer" :
+                  hasPrimitives.contents = true;
+                  match = [
+                    "Int",
+                    "int"
+                  ];
+                  break;
+                case "Array" :
+                  match = [
+                    "Array",
+                    `array<` + recurse(t.items) + `>`
+                  ];
+                  break;
+                case "Object" :
+                  match = [
+                    "Object",
+                    recurse(t)
+                  ];
+                  break;
+                case "Reference" :
+                  let ref = t._0;
+                  let name = Stdlib_Option.getOr(ref.split("/")[ref.split("/").length - 1 | 0], "");
+                  match = [
+                    JsConvertCase.toPascalCase(name),
+                    recurse(t)
+                  ];
+                  break;
+                default:
+                  exit = 1;
+              }
+            }
+            if (exit === 1) {
+              match = [
+                `V` + i.toString(),
+                recurse(t)
+              ];
+            }
+            return `  | ` + match[0] + `(` + match[1] + `)`;
+          });
+          let unboxedAttr = hasPrimitives.contents ? "@unboxed " : "";
+          result = unboxedAttr + `[\n` + variantCases.join("\n") + `\n]`;
+        } else {
+          result = "JSON.t";
+        }
+        if (hasNull) {
+          return `option<` + result + `>`;
+        } else {
+          return result;
         }
-        GenerationContext.addWarning(ctx, {
-          TAG: "ComplexUnionSimplified",
-          location: ctx.path,
-          types: types.map(SchemaIR.toString).join(" | ")
-        });
-        return "JSON.t";
       case "Intersection" :
         let types$1 = irType._0;
-        if (types$1.every(t => typeof t !== "object" ? false : t.TAG === "Reference") && types$1.length !== 0) {
+        if (types$1.every(t => {
+            if (typeof t !== "object") {
+              return false;
+            } else {
+              return t.TAG === "Reference";
+            }
+          }) && types$1.length !== 0) {
           return recurse(Stdlib_Option.getOr(types$1[types$1.length - 1 | 0], "Unknown"));
-        } else {
-          GenerationContext.addWarning(ctx, {
-            TAG: "IntersectionNotFullySupported",
-            location: ctx.path,
-            note: "Complex intersection"
-          });
-          return "JSON.t";
         }
+        let match$1 = Stdlib_Array.reduce(types$1, [
+          [],
+          []
+        ], (param, t) => {
+          let nonObj = param[1];
+          let props = param[0];
+          if (typeof t !== "object") {
+            return [
+              props,
+              nonObj.concat([t])
+            ];
+          } else if (t.TAG === "Object") {
+            return [
+              props.concat(t.properties),
+              nonObj
+            ];
+          } else {
+            return [
+              props,
+              nonObj.concat([t])
+            ];
+          }
+        });
+        let nonObjectTypes = match$1[1];
+        let objectProps = match$1[0];
+        if (objectProps.length !== 0 && nonObjectTypes.length === 0) {
+          let fields$1 = objectProps.map(param => {
+            let name = param[0];
+            let typeCode = recurse(param[1]);
+            let finalType = param[2] ? typeCode : `option<` + typeCode + `>`;
+            let camelName = JsConvertCase.toCamelCase(name);
+            let escapedName = CodegenUtils.escapeKeyword(camelName);
+            let aliasAnnotation = escapedName !== name ? `@as("` + name + `") ` : "";
+            return `  ` + aliasAnnotation + escapedName + `: ` + finalType + `,`;
+          }).join("\n");
+          return `{\n` + fields$1 + `\n}`;
+        }
+        if (nonObjectTypes.length !== 0 && objectProps.length === 0) {
+          return recurse(Stdlib_Option.getOr(types$1[types$1.length - 1 | 0], "Unknown"));
+        }
+        GenerationContext.addWarning(ctx, {
+          TAG: "IntersectionNotFullySupported",
+          location: ctx.path,
+          note: "Mixed object/non-object intersection"
+        });
+        let fields$2 = objectProps.map(param => {
+          let name = param[0];
+          let typeCode = recurse(param[1]);
+          let finalType = param[2] ? typeCode : `option<` + typeCode + `>`;
+          let camelName = JsConvertCase.toCamelCase(name);
+          let escapedName = CodegenUtils.escapeKeyword(camelName);
+          let aliasAnnotation = escapedName !== name ? `@as("` + name + `") ` : "";
+          return `  ` + aliasAnnotation + escapedName + `: ` + finalType + `,`;
+        }).join("\n");
+        return `{\n` + fields$2 + `\n}`;
       case "Reference" :
         let ref = irType._0;
         let available = ctx.availableSchemas;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@f3liz/rescript-autogen-openapi",
-  "version": "0.1.7",
+  "version": "0.2.0",
   "description": "Generate ReScript code with Sury schemas from OpenAPI 3.1 specs. Supports multiple forks with diff/merge capabilities.",
   "keywords": [
     "rescript",
@@ -29,7 +29,8 @@
     "build": "rescript && node scripts/generate-dts.mjs",
     "clean": "rescript clean",
     "watch": "rescript build -w",
-    "test": "node --test"
+    "test": "node --test",
+    "prepublishOnly": "npm run build && npm test"
   },
   "main": "lib/es6/src/Codegen.mjs",
   "types": "lib/es6/src/Codegen.d.ts",

package/src/generators/IRToSuryGenerator.res

@@ -66,40 +66,56 @@ 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 {
+          // Generate S.union for mixed-type unions
+          `S.union([${effectiveTypes->Array.map(recurse)->Array.join(", ")}])`
+        } else {
+          "S.json"
+        }
+
+        hasNull ? `S.nullableAsOption(${result})` : result
       }
     | Intersection(types) =>
       if types->Array.every(t =>
@@ -110,11 +126,47 @@ 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
+              isRequired
+                ? `    ${camelName}: s.field("${name}", ${schemaCode}),`
+                : `    ${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
+              isRequired
+                ? `    ${camelName}: s.field("${name}", ${schemaCode}),`
+                : `    ${camelName}: s.fieldOr("${name}", S.nullableAsOption(${schemaCode}), None),`
+            })
+            ->Array.join("\n")
+          `S.object(s => {\n${fields}\n  })`
+        }
       }
     | Reference(ref) =>
       let schemaPath = switch ctx.availableSchemas {

package/src/generators/IRToTypeGenerator.res

@@ -48,54 +48,89 @@ 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 = recurse(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<${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
+        ) {
+          let variants =
+            effectiveTypes
+            ->Array.map(t =>
+              switch t {
+              | Literal(StringLiteral(s)) => `#${CodegenUtils.toPascalCase(s)}`
+              | _ => "#Unknown"
+              }
+            )
+            ->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))
+              }
+            | _ => (`V${Int.toString(i)}`, recurse(t))
+            }
+            `  | ${tag}(${typeStr})`
+          })
+          let unboxedAttr = hasPrimitives.contents ? "@unboxed " : ""
+          `${unboxedAttr}[\n${variantCases->Array.join("\n")}\n]`
+        } 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
@@ -104,11 +139,51 @@ let rec generateTypeWithContext = (~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]))
+            },
         )
-        "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 = recurse(fieldType)
+              let finalType = isRequired ? 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
+          recurse(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 = recurse(fieldType)
+              let finalType = isRequired ? 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)}>`
     | Reference(ref) =>