@f3liz/rescript-autogen-openapi 0.3.1

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

@@ -0,0 +1,592 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as SchemaIR from "../core/SchemaIR.mjs";
+import * as CodegenUtils from "../core/CodegenUtils.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as JsConvertCase from "js-convert-case";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as GenerationContext from "../types/GenerationContext.mjs";
+import * as IRToSuryGenerator from "./IRToSuryGenerator.mjs";
+import * as ReferenceResolver from "../core/ReferenceResolver.mjs";
+
+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";
+    }
+    let recurseInline = nextIrType => generateTypeWithContext(ctx, depth + 1 | 0, true, nextIrType);
+    if (typeof irType !== "object") {
+      switch (irType) {
+        case "Boolean" :
+          return "bool";
+        case "Null" :
+          return "unit";
+        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>";
+            }
+          }
+          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 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 = 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 [
+                true,
+                param[1],
+                t.items,
+                param[3]
+              ];
+            }
+          });
+          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]);
+            }
+          } 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 [
+                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 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: "Mixed object/non-object intersection"
+          });
+          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 {
+          payloadType = `(dict<JSON.t>)`;
+        }
+      } 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;
+              }
+            }
+            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) {
+  let depth = depthOpt !== undefined ? depthOpt : 0;
+  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, undefined);
+  return [
+    generateTypeWithContext(ctx, depth, undefined, irType),
+    ctx.warnings
+  ];
+}
+
+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, 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 [
+    allDefs.join("\n\n"),
+    ctx.warnings,
+    reversedExtracted
+  ];
+}
+
+function generateAllTypes(context) {
+  let warnings = [];
+  let types = Object.values(context.schemas).toSorted((a, b) => Primitive_string.compare(a.name, b.name)).map(s => {
+    let match = generateNamedType(s, undefined, undefined, undefined);
+    warnings.push(...match[1]);
+    return match[0];
+  });
+  return [
+    types,
+    warnings
+  ];
+}
+
+function generateTypeAndSchema(namedSchema) {
+  let match = generateNamedType(namedSchema, undefined, undefined, undefined);
+  let match$1 = IRToSuryGenerator.generateNamedSchema(namedSchema, undefined, undefined, undefined, match[2]);
+  return [
+    [
+      match[0],
+      match$1[0]
+    ],
+    match[1].concat(match$1[1])
+  ];
+}
+
+let addWarning = GenerationContext.addWarning;
+
+export {
+  addWarning,
+  generateTypeWithContext,
+  generateUnboxedVariantBody,
+  generateType,
+  generateNamedType,
+  generateAllTypes,
+  generateTypeAndSchema,
+}
+/* CodegenUtils Not a pure module */