@f3liz/rescript-autogen-openapi 0.1.7 → 0.3.0

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

@@ -19,7 +19,7 @@ function applyConstraints(base, min, max, toString) {
   }
 }
 
-function generateSchemaWithContext(ctx, depthOpt, irType) {
+function generateSchemaWithContext(ctx, depthOpt, extractedTypeMap, irType) {
   let depth = depthOpt !== undefined ? depthOpt : 0;
   if (depth > 100) {
     GenerationContext.addWarning(ctx, {
@@ -29,7 +29,11 @@ function generateSchemaWithContext(ctx, depthOpt, irType) {
     });
     return "S.json";
   }
-  let recurse = nextIrType => generateSchemaWithContext(ctx, depth + 1 | 0, nextIrType);
+  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" :
@@ -66,15 +70,46 @@ function generateSchemaWithContext(ctx, depthOpt, irType) {
           if (additionalProperties !== undefined) {
             return `S.dict(` + recurse(additionalProperties) + `)`;
           } else {
-            return "S.json";
+            return "S.dict(S.json)";
           }
         }
         let fields = properties.map(param => {
+          let fieldType = param[1];
           let name = param[0];
-          let schemaCode = recurse(param[1]);
+          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),`;
           }
@@ -97,7 +132,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,9 +172,10 @@ 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;
+        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;
             }
@@ -132,39 +183,286 @@ function generateSchemaWithContext(ctx, depthOpt, irType) {
               return false;
             }
             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(" | ")
+            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;
           });
-          return "S.json";
+          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 => 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 "S.json";
         }
+        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 available = ctx.availableSchemas;
-        let schemaPath;
-        if (available !== undefined) {
-          let name = Stdlib_Option.getOr(ref.split("/")[ref.split("/").length - 1 | 0], "");
-          schemaPath = available.includes(name) ? JsConvertCase.toPascalCase(name) + `.schema` : `ComponentSchemas.` + JsConvertCase.toPascalCase(name) + `.schema`;
-        } else {
-          schemaPath = Stdlib_Option.getOr(ReferenceResolver.refToSchemaPath(ctx.insideComponentSchemas, ctx.modulePrefix, ref), "S.json");
+        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",
@@ -188,21 +486,33 @@ function generateSchema(depthOpt, pathOpt, insideComponentSchemasOpt, availableS
   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 [
-    generateSchemaWithContext(ctx, depth, irType),
+    generateSchemaWithContext(ctx, depth, undefined, irType),
     ctx.warnings
   ];
 }
 
-function generateNamedSchema(namedSchema, insideComponentSchemasOpt, availableSchemas, modulePrefixOpt) {
+function generateNamedSchema(namedSchema, insideComponentSchemasOpt, availableSchemas, modulePrefixOpt, extractedTypesOpt) {
   let insideComponentSchemas = insideComponentSchemasOpt !== undefined ? insideComponentSchemasOpt : false;
   let modulePrefix = modulePrefixOpt !== undefined ? modulePrefixOpt : "";
-  let ctx = GenerationContext.make(`schema.` + namedSchema.name, insideComponentSchemas, availableSchemas, modulePrefix, undefined);
+  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 [
-    doc + `let ` + namedSchema.name + `Schema = ` + generateSchemaWithContext(ctx, 0, namedSchema.type_),
+    allDefs.join("\n\n"),
     ctx.warnings
   ];
 }
@@ -210,7 +520,7 @@ function generateNamedSchema(namedSchema, insideComponentSchemasOpt, availableSc
 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);
+    let match = generateNamedSchema(s, undefined, undefined, undefined, undefined);
     warnings.push(...match[1]);
     return match[0];
   });