@f3liz/rescript-autogen-openapi 0.3.1

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

@@ -0,0 +1,543 @@
+// 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_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as GenerationContext from "../types/GenerationContext.mjs";
+import * as ReferenceResolver from "../core/ReferenceResolver.mjs";
+
+function applyConstraints(base, min, max, toString) {
+  let s1 = min !== undefined ? base + `->S.min(` + toString(Primitive_option.valFromOption(min)) + `)` : base;
+  if (max !== undefined) {
+    return s1 + `->S.max(` + toString(Primitive_option.valFromOption(max)) + `)`;
+  } else {
+    return s1;
+  }
+}
+
+function generateSchemaWithContext(ctx, depthOpt, extractedTypeMap, irType) {
+  let depth = depthOpt !== undefined ? depthOpt : 0;
+  if (depth > 100) {
+    GenerationContext.addWarning(ctx, {
+      TAG: "DepthLimitReached",
+      depth: depth,
+      path: ctx.path
+    });
+    return "S.json";
+  }
+  let recurse = nextIrType => generateSchemaWithContext(ctx, depth + 1 | 0, extractedTypeMap, nextIrType);
+  let foundExtracted = extractedTypeMap !== undefined ? extractedTypeMap.find(param => SchemaIR.equals(param.irType, irType)) : undefined;
+  if (foundExtracted !== undefined) {
+    return foundExtracted.typeName + `Schema`;
+  }
+  if (typeof irType !== "object") {
+    switch (irType) {
+      case "Boolean" :
+        return "S.bool";
+      case "Null" :
+        return "S.null";
+      case "Unknown" :
+        return "S.json";
+    }
+  } else {
+    switch (irType.TAG) {
+      case "String" :
+        let c = irType.constraints;
+        let s = applyConstraints("S.string", c.minLength, c.maxLength, v => v.toString());
+        let p = c.pattern;
+        if (p !== undefined) {
+          return s + `->S.pattern(%re("/` + CodegenUtils.escapeString(p) + `/"))`;
+        } else {
+          return s;
+        }
+      case "Number" :
+        let c$1 = irType.constraints;
+        return applyConstraints("S.float", c$1.minimum, c$1.maximum, v => (v | 0).toString());
+      case "Integer" :
+        let c$2 = irType.constraints;
+        return applyConstraints("S.int", c$2.minimum, c$2.maximum, v => (v | 0).toString());
+      case "Array" :
+        let c$3 = irType.constraints;
+        return applyConstraints(`S.array(` + recurse(irType.items) + `)`, c$3.minItems, c$3.maxItems, v => v.toString());
+      case "Object" :
+        let additionalProperties = irType.additionalProperties;
+        let properties = irType.properties;
+        if (properties.length === 0) {
+          if (additionalProperties !== undefined) {
+            return `S.dict(` + recurse(additionalProperties) + `)`;
+          } else {
+            return "S.dict(S.json)";
+          }
+        }
+        let fields = properties.map(param => {
+          let fieldType = param[1];
+          let name = param[0];
+          let schemaCode = recurse(fieldType);
+          let camelName = CodegenUtils.escapeKeyword(JsConvertCase.toCamelCase(name));
+          let alreadyNullable = true;
+          if (!schemaCode.startsWith("S.nullableAsOption(")) {
+            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;
+          }
+          if (param[2]) {
+            return `    ` + camelName + `: s.field("` + name + `", ` + schemaCode + `),`;
+          } else if (alreadyNullable) {
+            return `    ` + camelName + `: s.fieldOr("` + name + `", ` + schemaCode + `, None),`;
+          } else {
+            return `    ` + camelName + `: s.fieldOr("` + name + `", S.nullableAsOption(` + schemaCode + `), None),`;
+          }
+        }).join("\n");
+        return `S.object(s => {\n` + fields + `\n  })`;
+      case "Literal" :
+        let value = irType._0;
+        if (typeof value !== "object") {
+          return "S.literal(null)";
+        }
+        switch (value.TAG) {
+          case "StringLiteral" :
+            return `S.literal("` + CodegenUtils.escapeString(value._0) + `")`;
+          case "NumberLiteral" :
+            return `S.literal(` + value._0.toString() + `)`;
+          case "BooleanLiteral" :
+            return `S.literal(` + (
+              value._0 ? "true" : "false"
+            ) + `)`;
+        }
+      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) {
+          return `S.nullableAsOption(` + recurse(nonNullTypes[0]) + `)`;
+        }
+        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 = `S.array(` + recurse(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) {
+          result = `S.union([` + effectiveTypes.map(recurse).join(", ") + `])`;
+        } 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 rawNames = effectiveTypes.map(CodegenUtils.variantConstructorName);
+            let names = CodegenUtils.deduplicateNames(rawNames);
+            let branches = effectiveTypes.map((memberType, i) => {
+              let constructorName = names[i];
+              if (typeof memberType === "object" && memberType.TAG === "Object") {
+                let additionalProperties = memberType.additionalProperties;
+                let properties = memberType.properties;
+                if (properties.length === 0) {
+                  if (additionalProperties !== undefined) {
+                    return `S.dict(` + recurse(additionalProperties) + `)->S.shape(v => ` + constructorName + `(v))`;
+                  } else {
+                    return `S.dict(S.json)->S.shape(v => ` + constructorName + `(v))`;
+                  }
+                }
+                let fields = properties.map(param => {
+                  let fieldType = param[1];
+                  let name = param[0];
+                  let schemaCode = recurse(fieldType);
+                  let camelName = CodegenUtils.escapeKeyword(JsConvertCase.toCamelCase(name));
+                  let alreadyNullable = true;
+                  if (!schemaCode.startsWith("S.nullableAsOption(")) {
+                    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;
+                  }
+                  if (param[2]) {
+                    return `      ` + camelName + `: s.field("` + name + `", ` + schemaCode + `),`;
+                  } else if (alreadyNullable) {
+                    return `      ` + camelName + `: s.fieldOr("` + name + `", ` + schemaCode + `, None),`;
+                  } else {
+                    return `      ` + camelName + `: s.fieldOr("` + name + `", S.nullableAsOption(` + schemaCode + `), None),`;
+                  }
+                }).join("\n");
+                return `S.object(s => ` + constructorName + `({\n` + fields + `\n    }))`;
+              }
+              let innerSchema = recurse(memberType);
+              return innerSchema + `->S.shape(v => ` + constructorName + `(v))`;
+            });
+            result = `S.union([` + branches.join(", ") + `])`;
+          } else {
+            result = recurse(effectiveTypes[effectiveTypes.length - 1 | 0]);
+          }
+        } else {
+          result = "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";
+            }
+          }) && 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 fieldType = param[1];
+            let name = param[0];
+            let schemaCode = recurse(fieldType);
+            let camelName = CodegenUtils.escapeKeyword(JsConvertCase.toCamelCase(name));
+            let alreadyNullable = true;
+            if (!schemaCode.startsWith("S.nullableAsOption(")) {
+              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;
+            }
+            if (param[2]) {
+              return `    ` + camelName + `: s.field("` + name + `", ` + schemaCode + `),`;
+            } else if (alreadyNullable) {
+              return `    ` + camelName + `: s.fieldOr("` + name + `", ` + schemaCode + `, None),`;
+            } else {
+              return `    ` + camelName + `: s.fieldOr("` + name + `", S.nullableAsOption(` + schemaCode + `), None),`;
+            }
+          }).join("\n");
+          return `S.object(s => {\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 fieldType = param[1];
+          let name = param[0];
+          let schemaCode = recurse(fieldType);
+          let camelName = CodegenUtils.escapeKeyword(JsConvertCase.toCamelCase(name));
+          let alreadyNullable = true;
+          if (!schemaCode.startsWith("S.nullableAsOption(")) {
+            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;
+          }
+          if (param[2]) {
+            return `    ` + camelName + `: s.field("` + name + `", ` + schemaCode + `),`;
+          } else if (alreadyNullable) {
+            return `    ` + camelName + `: s.fieldOr("` + name + `", ` + schemaCode + `, None),`;
+          } 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 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 "schema";
+        }
+        let available = ctx.availableSchemas;
+        let schemaPath = available !== undefined ? (
+            available.includes(refName) ? JsConvertCase.toPascalCase(refName) + `.schema` : `ComponentSchemas.` + JsConvertCase.toPascalCase(refName) + `.schema`
+          ) : Stdlib_Option.getOr(ReferenceResolver.refToSchemaPath(ctx.insideComponentSchemas, ctx.modulePrefix, ref), "S.json");
+        if (schemaPath === "S.json") {
+          GenerationContext.addWarning(ctx, {
+            TAG: "FallbackToJson",
+            reason: `Unresolved ref: ` + ref,
+            context: {
+              path: ctx.path,
+              operation: "gen ref",
+              schema: undefined
+            }
+          });
+        }
+        return schemaPath;
+      case "Option" :
+        return `S.nullableAsOption(` + recurse(irType._0) + `)`;
+    }
+  }
+}
+
+function generateSchema(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 [
+    generateSchemaWithContext(ctx, depth, undefined, irType),
+    ctx.warnings
+  ];
+}
+
+function generateNamedSchema(namedSchema, insideComponentSchemasOpt, availableSchemas, modulePrefixOpt, extractedTypesOpt) {
+  let insideComponentSchemas = insideComponentSchemasOpt !== undefined ? insideComponentSchemasOpt : false;
+  let modulePrefix = modulePrefixOpt !== undefined ? modulePrefixOpt : "";
+  let extractedTypes = extractedTypesOpt !== undefined ? extractedTypesOpt : [];
+  let ctx = GenerationContext.make(`schema.` + namedSchema.name, insideComponentSchemas, availableSchemas, modulePrefix, undefined, undefined);
+  let d = namedSchema.description;
+  let doc = d !== undefined ? CodegenUtils.generateDocComment(undefined, d, undefined) : "";
+  let extractedTypeMap = extractedTypes.length !== 0 ? extractedTypes : undefined;
+  let mainSchema = generateSchemaWithContext(ctx, 0, extractedTypeMap, namedSchema.type_);
+  let extractedDefs = extractedTypes.map(param => {
+    let typeName = param.typeName;
+    let auxCtx = GenerationContext.make(`schema.` + typeName, insideComponentSchemas, availableSchemas, modulePrefix, undefined, undefined);
+    let filteredMap = extractedTypes.filter(param => param.typeName !== typeName);
+    let auxExtractedTypeMap = filteredMap.length !== 0 ? filteredMap : undefined;
+    let auxSchema = generateSchemaWithContext(auxCtx, 0, auxExtractedTypeMap, param.irType);
+    return `let ` + typeName + `Schema = ` + auxSchema;
+  });
+  let allDefs = extractedDefs.concat([doc + `let ` + namedSchema.name + `Schema = ` + mainSchema]);
+  return [
+    allDefs.join("\n\n"),
+    ctx.warnings
+  ];
+}
+
+function generateAllSchemas(context) {
+  let warnings = [];
+  let schemas = Object.values(context.schemas).toSorted((a, b) => Primitive_string.compare(a.name, b.name)).map(s => {
+    let match = generateNamedSchema(s, undefined, undefined, undefined, undefined);
+    warnings.push(...match[1]);
+    return match[0];
+  });
+  return [
+    schemas,
+    warnings
+  ];
+}
+
+let addWarning = GenerationContext.addWarning;
+
+export {
+  addWarning,
+  applyConstraints,
+  generateSchemaWithContext,
+  generateSchema,
+  generateNamedSchema,
+  generateAllSchemas,
+}
+/* CodegenUtils Not a pure module */