@f3liz/rescript-autogen-openapi 0.1.7 → 0.3.0

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

@@ -10,173 +10,490 @@ import * as GenerationContext from "../types/GenerationContext.mjs";
 import * as IRToSuryGenerator from "./IRToSuryGenerator.mjs";
 import * as ReferenceResolver from "../core/ReferenceResolver.mjs";
 
-function generateTypeWithContext(ctx, depthOpt, irType) {
-  let depth = depthOpt !== undefined ? depthOpt : 0;
-  if (depth > 100) {
-    GenerationContext.addWarning(ctx, {
-      TAG: "DepthLimitReached",
-      depth: depth,
-      path: ctx.path
-    });
-    return "JSON.t";
-  }
-  let recurse = nextIrType => generateTypeWithContext(ctx, depth + 1 | 0, nextIrType);
-  if (typeof irType !== "object") {
-    switch (irType) {
-      case "Boolean" :
-        return "bool";
-      case "Null" :
-        return "unit";
-      case "Unknown" :
-        return "JSON.t";
+function generateTypeWithContext(ctx, _depthOpt, _inlineOpt, _irType) {
+  while (true) {
+    let depthOpt = _depthOpt;
+    let inlineOpt = _inlineOpt;
+    let irType = _irType;
+    let depth = depthOpt !== undefined ? depthOpt : 0;
+    let inline = inlineOpt !== undefined ? inlineOpt : false;
+    if (depth > 100) {
+      GenerationContext.addWarning(ctx, {
+        TAG: "DepthLimitReached",
+        depth: depth,
+        path: ctx.path
+      });
+      return "JSON.t";
     }
-  } else {
-    switch (irType.TAG) {
-      case "String" :
-        return "string";
-      case "Number" :
-        return "float";
-      case "Integer" :
-        return "int";
-      case "Array" :
-        return `array<` + recurse(irType.items) + `>`;
-      case "Object" :
-        let additionalProperties = irType.additionalProperties;
-        let properties = irType.properties;
-        if (properties.length === 0) {
-          if (additionalProperties !== undefined) {
-            return `dict<` + recurse(additionalProperties) + `>`;
-          } else {
-            return "JSON.t";
-          }
-        }
-        let fields = properties.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 + `\n}`;
-      case "Literal" :
-        let tmp = irType._0;
-        if (typeof tmp !== "object") {
+    let recurseInline = nextIrType => generateTypeWithContext(ctx, depth + 1 | 0, true, nextIrType);
+    if (typeof irType !== "object") {
+      switch (irType) {
+        case "Boolean" :
+          return "bool";
+        case "Null" :
           return "unit";
-        }
-        switch (tmp.TAG) {
-          case "StringLiteral" :
-            return "string";
-          case "NumberLiteral" :
-            return "float";
-          case "BooleanLiteral" :
-            return "bool";
-        }
-      case "Union" :
-        let types = irType._0;
-        let match = Stdlib_Array.reduce(types, [
-          false,
-          false,
-          undefined,
-          undefined
-        ], (param, t) => {
-          let arrItem = param[2];
-          let hArr = param[0];
-          if (typeof t !== "object" || t.TAG !== "Array") {
-            return [
-              hArr,
-              true,
-              arrItem,
-              t
-            ];
-          } else {
-            return [
-              true,
-              param[1],
-              t.items,
-              param[3]
-            ];
+        case "Unknown" :
+          return "JSON.t";
+      }
+    } else {
+      switch (irType.TAG) {
+        case "String" :
+          return "string";
+        case "Number" :
+          return "float";
+        case "Integer" :
+          return "int";
+        case "Array" :
+          return `array<` + recurseInline(irType.items) + `>`;
+        case "Object" :
+          let additionalProperties = irType.additionalProperties;
+          let properties = irType.properties;
+          if (properties.length === 0) {
+            if (additionalProperties !== undefined) {
+              return `dict<` + recurseInline(additionalProperties) + `>`;
+            } else {
+              return "dict<JSON.t>";
+            }
           }
-        });
-        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 => {
+          if (inline) {
+            let baseName = Stdlib_Option.getOr(ctx.path.split(".")[ctx.path.split(".").length - 1 | 0], "item");
+            return GenerationContext.extractType(ctx, baseName, undefined, irType);
+          }
+          let fields = properties.map(param => {
+            let fieldType = param[1];
+            let name = param[0];
+            let typeCode = recurseInline(fieldType);
+            let alreadyNullable = true;
+            if (!typeCode.startsWith("option<")) {
+              let tmp;
+              if (typeof fieldType !== "object") {
+                tmp = false;
+              } else {
+                switch (fieldType.TAG) {
+                  case "Union" :
+                    tmp = fieldType._0.some(t => {
+                      if (typeof t !== "object") {
+                        return t === "Null";
+                      }
+                      if (t.TAG !== "Literal") {
+                        return false;
+                      }
+                      let tmp = t._0;
+                      return typeof tmp !== "object";
+                    });
+                    break;
+                  case "Option" :
+                    tmp = true;
+                    break;
+                  default:
+                    tmp = false;
+                }
+              }
+              alreadyNullable = tmp;
+            }
+            let finalType = param[2] || alreadyNullable ? 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 + `\n}`;
+        case "Literal" :
+          let tmp = irType._0;
+          if (typeof tmp !== "object") {
+            return "unit";
+          }
+          switch (tmp.TAG) {
+            case "StringLiteral" :
+              return "string";
+            case "NumberLiteral" :
+              return "float";
+            case "BooleanLiteral" :
+              return "bool";
+          }
+        case "Union" :
+          let types = irType._0;
+          let nonNullTypes = types.filter(t => {
             if (typeof t !== "object") {
-              return false;
+              return t !== "Null";
             }
             if (t.TAG !== "Literal") {
-              return false;
+              return true;
             }
             let tmp = t._0;
-            if (typeof tmp !== "object") {
-              return false;
+            return typeof tmp === "object";
+          });
+          let hasNull = nonNullTypes.length < types.length;
+          if (hasNull && nonNullTypes.length === 1) {
+            let inner = generateTypeWithContext(ctx, depth + 1 | 0, true, nonNullTypes[0]);
+            return `option<` + inner + `>`;
+          }
+          let effectiveTypes = hasNull ? nonNullTypes : types;
+          let match = Stdlib_Array.reduce(effectiveTypes, [
+            false,
+            false,
+            undefined,
+            undefined
+          ], (param, t) => {
+            let arrItem = param[2];
+            let hArr = param[0];
+            if (typeof t !== "object" || t.TAG !== "Array") {
+              return [
+                hArr,
+                true,
+                arrItem,
+                t
+              ];
             } else {
-              return tmp.TAG === "StringLiteral";
-            }
-          }) && types.length !== 0 && types.length <= 50) {
-          let variants = types.map(t => {
-            if (typeof t !== "object") {
-              return "#Unknown";
+              return [
+                true,
+                param[1],
+                t.items,
+                param[3]
+              ];
             }
-            if (t.TAG !== "Literal") {
-              return "#Unknown";
+          });
+          let arrayItemType = match[2];
+          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<` + recurseInline(Stdlib_Option.getOr(arrayItemType, "Unknown")) + `>`;
+          } else if (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) {
+            let variants = effectiveTypes.map(t => {
+              if (typeof t !== "object") {
+                return "#Unknown";
+              }
+              if (t.TAG !== "Literal") {
+                return "#Unknown";
+              }
+              let s = t._0;
+              if (typeof s !== "object" || s.TAG !== "StringLiteral") {
+                return "#Unknown";
+              } else {
+                return `#` + JsConvertCase.toPascalCase(s._0);
+              }
+            }).join(" | ");
+            result = `[` + variants + `]`;
+          } else if (effectiveTypes.length !== 0) {
+            let runtimeKinds = {};
+            effectiveTypes.forEach(t => {
+              let kind;
+              if (typeof t !== "object") {
+                switch (t) {
+                  case "Boolean" :
+                    kind = "boolean";
+                    break;
+                  case "Null" :
+                    kind = "null";
+                    break;
+                  default:
+                    kind = "unknown";
+                }
+              } else {
+                switch (t.TAG) {
+                  case "String" :
+                    kind = "string";
+                    break;
+                  case "Number" :
+                  case "Integer" :
+                    kind = "number";
+                    break;
+                  case "Array" :
+                    kind = "array";
+                    break;
+                  case "Literal" :
+                    let tmp = t._0;
+                    if (typeof tmp !== "object") {
+                      kind = "null";
+                    } else {
+                      switch (tmp.TAG) {
+                        case "StringLiteral" :
+                          kind = "string";
+                          break;
+                        case "NumberLiteral" :
+                          kind = "number";
+                          break;
+                        case "BooleanLiteral" :
+                          kind = "boolean";
+                          break;
+                      }
+                    }
+                    break;
+                  case "Object" :
+                  case "Intersection" :
+                  case "Reference" :
+                    kind = "object";
+                    break;
+                  default:
+                    kind = "unknown";
+                }
+              }
+              let count = Stdlib_Option.getOr(runtimeKinds[kind], 0);
+              runtimeKinds[kind] = count + 1 | 0;
+            });
+            let canUnbox = Object.values(runtimeKinds).every(count => count <= 1);
+            if (canUnbox) {
+              let extractIR = hasNull ? ({
+                  TAG: "Union",
+                  _0: effectiveTypes
+                }) : irType;
+              let baseName$1 = Stdlib_Option.getOr(ctx.path.split(".")[ctx.path.split(".").length - 1 | 0], "union");
+              result = GenerationContext.extractType(ctx, baseName$1, true, extractIR);
+            } else {
+              result = recurseInline(effectiveTypes[effectiveTypes.length - 1 | 0]);
             }
-            let s = t._0;
-            if (typeof s !== "object" || s.TAG !== "StringLiteral") {
-              return "#Unknown";
+          } else {
+            result = "JSON.t";
+          }
+          if (hasNull) {
+            return `option<` + 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";
+              }
+            }) && types$1.length !== 0) {
+            _irType = Stdlib_Option.getOr(types$1[types$1.length - 1 | 0], "Unknown");
+            _inlineOpt = inline;
+            _depthOpt = depth + 1 | 0;
+            continue;
+          }
+          if (inline) {
+            let baseName$2 = Stdlib_Option.getOr(ctx.path.split(".")[ctx.path.split(".").length - 1 | 0], "intersection");
+            return GenerationContext.extractType(ctx, baseName$2, undefined, irType);
+          }
+          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 `#` + JsConvertCase.toPascalCase(s._0);
+              return [
+                props,
+                nonObj.concat([t])
+              ];
             }
-          }).join(" | ");
-          return `[` + variants + `]`;
-        }
-        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) {
-          return recurse(Stdlib_Option.getOr(types$1[types$1.length - 1 | 0], "Unknown"));
-        } else {
+          });
+          let nonObjectTypes = match$1[1];
+          let objectProps = match$1[0];
+          if (objectProps.length !== 0 && nonObjectTypes.length === 0) {
+            let fields$1 = objectProps.map(param => {
+              let fieldType = param[1];
+              let name = param[0];
+              let typeCode = recurseInline(fieldType);
+              let alreadyNullable = true;
+              if (!typeCode.startsWith("option<")) {
+                let tmp;
+                if (typeof fieldType !== "object") {
+                  tmp = false;
+                } else {
+                  switch (fieldType.TAG) {
+                    case "Union" :
+                      tmp = fieldType._0.some(t => {
+                        if (typeof t !== "object") {
+                          return t === "Null";
+                        }
+                        if (t.TAG !== "Literal") {
+                          return false;
+                        }
+                        let tmp = t._0;
+                        return typeof tmp !== "object";
+                      });
+                      break;
+                    case "Option" :
+                      tmp = true;
+                      break;
+                    default:
+                      tmp = false;
+                  }
+                }
+                alreadyNullable = tmp;
+              }
+              let finalType = param[2] || alreadyNullable ? 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) {
+            _irType = Stdlib_Option.getOr(types$1[types$1.length - 1 | 0], "Unknown");
+            _inlineOpt = inline;
+            _depthOpt = depth + 1 | 0;
+            continue;
+          }
           GenerationContext.addWarning(ctx, {
             TAG: "IntersectionNotFullySupported",
             location: ctx.path,
-            note: "Complex intersection"
+            note: "Mixed object/non-object intersection"
           });
-          return "JSON.t";
-        }
-      case "Reference" :
-        let ref = irType._0;
-        let available = ctx.availableSchemas;
-        let typePath;
-        if (available !== undefined) {
-          let name = Stdlib_Option.getOr(ref.split("/")[ref.split("/").length - 1 | 0], "");
-          typePath = available.includes(name) ? JsConvertCase.toPascalCase(name) + `.t` : `ComponentSchemas.` + JsConvertCase.toPascalCase(name) + `.t`;
+          let fields$2 = objectProps.map(param => {
+            let fieldType = param[1];
+            let name = param[0];
+            let typeCode = recurseInline(fieldType);
+            let alreadyNullable = true;
+            if (!typeCode.startsWith("option<")) {
+              let tmp;
+              if (typeof fieldType !== "object") {
+                tmp = false;
+              } else {
+                switch (fieldType.TAG) {
+                  case "Union" :
+                    tmp = fieldType._0.some(t => {
+                      if (typeof t !== "object") {
+                        return t === "Null";
+                      }
+                      if (t.TAG !== "Literal") {
+                        return false;
+                      }
+                      let tmp = t._0;
+                      return typeof tmp !== "object";
+                    });
+                    break;
+                  case "Option" :
+                    tmp = true;
+                    break;
+                  default:
+                    tmp = false;
+                }
+              }
+              alreadyNullable = tmp;
+            }
+            let finalType = param[2] || alreadyNullable ? 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 refName = ref.includes("/") ? Stdlib_Option.getOr(ref.split("/")[ref.split("/").length - 1 | 0], "") : ref;
+          let selfName = ctx.selfRefName;
+          let isSelfRef = selfName !== undefined ? refName === selfName : false;
+          if (isSelfRef) {
+            return "t";
+          }
+          let available = ctx.availableSchemas;
+          let typePath = available !== undefined ? (
+              available.includes(refName) ? JsConvertCase.toPascalCase(refName) + `.t` : `ComponentSchemas.` + JsConvertCase.toPascalCase(refName) + `.t`
+            ) : Stdlib_Option.getOr(ReferenceResolver.refToTypePath(ctx.insideComponentSchemas, ctx.modulePrefix, ref), "JSON.t");
+          if (typePath === "JSON.t") {
+            GenerationContext.addWarning(ctx, {
+              TAG: "FallbackToJson",
+              reason: `Unresolved ref: ` + ref,
+              context: {
+                path: ctx.path,
+                operation: "gen ref",
+                schema: undefined
+              }
+            });
+          }
+          return typePath;
+        case "Option" :
+          return `option<` + recurseInline(irType._0) + `>`;
+      }
+    }
+  };
+}
+
+function generateUnboxedVariantBody(ctx, types) {
+  let rawNames = types.map(CodegenUtils.variantConstructorName);
+  let names = CodegenUtils.deduplicateNames(rawNames);
+  return types.map((irType, i) => {
+    let constructorName = names[i];
+    let payloadType;
+    let exit = 0;
+    if (typeof irType !== "object" || irType.TAG !== "Object") {
+      exit = 1;
+    } else {
+      let additionalProperties = irType.additionalProperties;
+      let properties = irType.properties;
+      if (properties.length === 0) {
+        if (additionalProperties !== undefined) {
+          let innerType = generateTypeWithContext(ctx, 1, true, additionalProperties);
+          payloadType = `(dict<` + innerType + `>)`;
         } else {
-          typePath = Stdlib_Option.getOr(ReferenceResolver.refToTypePath(ctx.insideComponentSchemas, ctx.modulePrefix, ref), "JSON.t");
+          payloadType = `(dict<JSON.t>)`;
         }
-        if (typePath === "JSON.t") {
-          GenerationContext.addWarning(ctx, {
-            TAG: "FallbackToJson",
-            reason: `Unresolved ref: ` + ref,
-            context: {
-              path: ctx.path,
-              operation: "gen ref",
-              schema: undefined
+      } else {
+        let fields = properties.map(param => {
+          let fieldType = param[1];
+          let name = param[0];
+          let typeCode = generateTypeWithContext(ctx, 1, true, fieldType);
+          let alreadyNullable = true;
+          if (!typeCode.startsWith("option<")) {
+            let tmp;
+            if (typeof fieldType !== "object") {
+              tmp = false;
+            } else {
+              switch (fieldType.TAG) {
+                case "Union" :
+                  tmp = fieldType._0.some(t => {
+                    if (typeof t !== "object") {
+                      return t === "Null";
+                    }
+                    if (t.TAG !== "Literal") {
+                      return false;
+                    }
+                    let tmp = t._0;
+                    return typeof tmp !== "object";
+                  });
+                  break;
+                case "Option" :
+                  tmp = true;
+                  break;
+                default:
+                  tmp = false;
+              }
             }
-          });
-        }
-        return typePath;
-      case "Option" :
-        return `option<` + recurse(irType._0) + `>`;
+            alreadyNullable = tmp;
+          }
+          let finalType = param[2] || alreadyNullable ? typeCode : `option<` + typeCode + `>`;
+          let camelName = JsConvertCase.toCamelCase(name);
+          let escapedName = CodegenUtils.escapeKeyword(camelName);
+          let aliasAnnotation = escapedName !== name ? `@as("` + name + `") ` : "";
+          return aliasAnnotation + escapedName + `: ` + finalType;
+        }).join(", ");
+        payloadType = `({` + fields + `})`;
+      }
     }
-  }
+    if (exit === 1) {
+      let innerType$1 = generateTypeWithContext(ctx, 1, true, irType);
+      payloadType = `(` + innerType$1 + `)`;
+    }
+    return constructorName + payloadType;
+  }).join(" | ");
 }
 
 function generateType(depthOpt, pathOpt, insideComponentSchemasOpt, availableSchemas, modulePrefixOpt, irType) {
@@ -184,9 +501,9 @@ function generateType(depthOpt, pathOpt, insideComponentSchemasOpt, availableSch
   let path = pathOpt !== undefined ? pathOpt : "";
   let insideComponentSchemas = insideComponentSchemasOpt !== undefined ? insideComponentSchemasOpt : false;
   let modulePrefix = modulePrefixOpt !== undefined ? modulePrefixOpt : "";
-  let ctx = GenerationContext.make(path, insideComponentSchemas, availableSchemas, modulePrefix, undefined);
+  let ctx = GenerationContext.make(path, insideComponentSchemas, availableSchemas, modulePrefix, undefined, undefined);
   return [
-    generateTypeWithContext(ctx, depth, irType),
+    generateTypeWithContext(ctx, depth, undefined, irType),
     ctx.warnings
   ];
 }
@@ -194,12 +511,45 @@ function generateType(depthOpt, pathOpt, insideComponentSchemasOpt, availableSch
 function generateNamedType(namedSchema, insideComponentSchemasOpt, availableSchemas, modulePrefixOpt) {
   let insideComponentSchemas = insideComponentSchemasOpt !== undefined ? insideComponentSchemasOpt : false;
   let modulePrefix = modulePrefixOpt !== undefined ? modulePrefixOpt : "";
-  let ctx = GenerationContext.make(`type.` + namedSchema.name, insideComponentSchemas, availableSchemas, modulePrefix, undefined);
+  let ctx = GenerationContext.make(`type.` + namedSchema.name, insideComponentSchemas, availableSchemas, modulePrefix, undefined, undefined);
   let d = namedSchema.description;
   let doc = d !== undefined ? CodegenUtils.generateDocString(undefined, d, undefined) : "";
+  let mainType = generateTypeWithContext(ctx, 0, undefined, namedSchema.type_);
+  let processed = 0;
+  while (processed < ctx.extractedTypes.length) {
+    let idx = processed;
+    let match = ctx.extractedTypes[idx];
+    let irType = match.irType;
+    if (match.isUnboxed && typeof irType === "object" && irType.TAG === "Union") {
+      irType._0.forEach(memberType => {
+        generateTypeWithContext(ctx, 0, true, memberType);
+      });
+    } else {
+      generateTypeWithContext(ctx, 0, false, irType);
+    }
+    processed = idx + 1 | 0;
+  };
+  let allExtracted = ctx.extractedTypes.slice();
+  let extractedDefs = allExtracted.map(param => {
+    let irType = param.irType;
+    let typeName = param.typeName;
+    if (param.isUnboxed) {
+      if (typeof irType === "object" && irType.TAG === "Union") {
+        let body = generateUnboxedVariantBody(ctx, irType._0);
+        return `@unboxed type ` + typeName + ` = ` + body;
+      }
+      let auxType = generateTypeWithContext(ctx, 0, undefined, irType);
+      return `type ` + typeName + ` = ` + auxType;
+    }
+    let auxType$1 = generateTypeWithContext(ctx, 0, undefined, irType);
+    return `type ` + typeName + ` = ` + auxType$1;
+  });
+  let reversedExtracted = allExtracted.toReversed();
+  let allDefs = extractedDefs.toReversed().concat([doc + `type ` + namedSchema.name + ` = ` + mainType]);
   return [
-    doc + `type ` + namedSchema.name + ` = ` + generateTypeWithContext(ctx, 0, namedSchema.type_),
-    ctx.warnings
+    allDefs.join("\n\n"),
+    ctx.warnings,
+    reversedExtracted
   ];
 }
 
@@ -218,7 +568,7 @@ function generateAllTypes(context) {
 
 function generateTypeAndSchema(namedSchema) {
   let match = generateNamedType(namedSchema, undefined, undefined, undefined);
-  let match$1 = IRToSuryGenerator.generateNamedSchema(namedSchema, undefined, undefined, undefined);
+  let match$1 = IRToSuryGenerator.generateNamedSchema(namedSchema, undefined, undefined, undefined, match[2]);
   return [
     [
       match[0],
@@ -233,6 +583,7 @@ let addWarning = GenerationContext.addWarning;
 export {
   addWarning,
   generateTypeWithContext,
+  generateUnboxedVariantBody,
   generateType,
   generateNamedType,
   generateAllTypes,