@f3liz/rescript-autogen-openapi 0.2.0 → 0.3.0

package/lib/es6/src/bindings/Toposort.mjs

@@ -0,0 +1,12 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import Toposort from "toposort";
+
+function sortArray(nodes, edges) {
+  return Toposort.array(nodes, edges);
+}
+
+export {
+  sortArray,
+}
+/* toposort Not a pure module */

package/lib/es6/src/core/CodegenUtils.mjs

@@ -167,6 +167,79 @@ function generateDocString(summary, description, param) {
   }), "");
 }
 
+function variantConstructorName(_irType) {
+  while (true) {
+    let irType = _irType;
+    if (typeof irType !== "object") {
+      switch (irType) {
+        case "Boolean" :
+          return "Bool";
+        case "Null" :
+          return "Null";
+        case "Unknown" :
+          return "Unknown";
+      }
+    } else {
+      switch (irType.TAG) {
+        case "String" :
+          return "String";
+        case "Number" :
+          return "Float";
+        case "Integer" :
+          return "Int";
+        case "Array" :
+          return "Array";
+        case "Object" :
+          return "Object";
+        case "Literal" :
+          let s = irType._0;
+          if (typeof s !== "object") {
+            return "Null";
+          }
+          switch (s.TAG) {
+            case "StringLiteral" :
+              return JsConvertCase.toPascalCase(s._0);
+            case "NumberLiteral" :
+              return "Number";
+            case "BooleanLiteral" :
+              return "Bool";
+          }
+        case "Union" :
+          return "Union";
+        case "Intersection" :
+          return "Intersection";
+        case "Reference" :
+          let ref = irType._0;
+          return JsConvertCase.toPascalCase(ref.includes("/") ? Stdlib_Option.getOr(ref.split("/")[ref.split("/").length - 1 | 0], "Ref") : ref);
+        case "Option" :
+          _irType = irType._0;
+          continue;
+      }
+    }
+  };
+}
+
+function deduplicateNames(names) {
+  let counts = {};
+  let result = [];
+  names.forEach(name => {
+    let count = Stdlib_Option.getOr(counts[name], 0);
+    counts[name] = count + 1 | 0;
+  });
+  let seen = {};
+  names.forEach(name => {
+    let total = Stdlib_Option.getOr(counts[name], 1);
+    if (total > 1) {
+      let idx = Stdlib_Option.getOr(seen[name], 0) + 1 | 0;
+      seen[name] = idx;
+      result.push(name + idx.toString());
+      return;
+    }
+    result.push(name);
+  });
+  return result;
+}
+
 let fetchTypeSignature = "(~url: string, ~method_: string, ~body: option<JSON.t>) => Promise.t<JSON.t>";
 
 export {
@@ -182,5 +255,7 @@ export {
   generateDocComment,
   generateDocString,
   fetchTypeSignature,
+  variantConstructorName,
+  deduplicateNames,
 }
 /* js-convert-case Not a pure module */

package/lib/es6/src/core/SchemaIR.mjs

@@ -230,6 +230,36 @@ function equals(_a, _b) {
           _b = b.items;
           _a = a.items;
           continue;
+        case "Object" :
+          if (typeof b !== "object") {
+            return false;
+          }
+          if (b.TAG !== "Object") {
+            return false;
+          }
+          let addB = b.additionalProperties;
+          let propsB = b.properties;
+          let addA = a.additionalProperties;
+          let propsA = a.properties;
+          if (!(propsA.length === propsB.length && propsA.every((propA, i) => {
+              let propB = propsB[i];
+              if (propB !== undefined && propA[0] === propB[0] && propA[2] === propB[2]) {
+                return equals(propA[1], propB[1]);
+              } else {
+                return false;
+              }
+            }))) {
+            return false;
+          }
+          if (addA === undefined) {
+            return addB === undefined;
+          }
+          if (addB === undefined) {
+            return false;
+          }
+          _b = addB;
+          _a = addA;
+          continue;
         case "Literal" :
           if (typeof b !== "object") {
             return false;
@@ -262,6 +292,48 @@ function equals(_a, _b) {
                 return litA._0 === litB._0;
               }
           }
+        case "Union" :
+          if (typeof b !== "object") {
+            return false;
+          }
+          if (b.TAG !== "Union") {
+            return false;
+          }
+          let typesB = b._0;
+          let typesA = a._0;
+          if (typesA.length === typesB.length) {
+            return typesA.every((tA, i) => {
+              let tB = typesB[i];
+              if (tB !== undefined) {
+                return equals(tA, tB);
+              } else {
+                return false;
+              }
+            });
+          } else {
+            return false;
+          }
+        case "Intersection" :
+          if (typeof b !== "object") {
+            return false;
+          }
+          if (b.TAG !== "Intersection") {
+            return false;
+          }
+          let typesB$1 = b._0;
+          let typesA$1 = a._0;
+          if (typesA$1.length === typesB$1.length) {
+            return typesA$1.every((tA, i) => {
+              let tB = typesB$1[i];
+              if (tB !== undefined) {
+                return equals(tA, tB);
+              } else {
+                return false;
+              }
+            });
+          } else {
+            return false;
+          }
         case "Reference" :
           if (typeof b !== "object" || b.TAG !== "Reference") {
             return false;
@@ -278,8 +350,6 @@ function equals(_a, _b) {
           _b = b._0;
           _a = a._0;
           continue;
-        default:
-          return false;
       }
     }
   };

package/lib/es6/src/core/SchemaIRParser.mjs

@@ -42,6 +42,12 @@ function parseTypeString(rawType) {
   }
 }
 
+function parseTypeAsArray(rawType) {
+  if (Array.isArray(rawType)) {
+    return rawType.map(parseTypeString);
+  }
+}
+
 function addWarning(ctx, warning) {
   ctx.warnings.push(warning);
 }
@@ -64,67 +70,188 @@ function parseJsonSchemaWithContext(ctx, depthOpt, schema) {
     };
   }
   let isNullable = Stdlib_Option.getOr(schema.nullable, false);
-  let normalizedType = Stdlib_Option.map(schema.type, parseTypeString);
-  let baseType;
+  let hasComposition = Stdlib_Option.isSome(schema.anyOf) || Stdlib_Option.isSome(schema.oneOf);
+  let typeAsArray = hasComposition ? undefined : Stdlib_Option.flatMap(schema.type, parseTypeAsArray);
+  let schema$1 = hasComposition && Stdlib_Option.isSome(Stdlib_Option.flatMap(schema.type, parseTypeAsArray)) ? ({
+      type: undefined,
+      properties: schema.properties,
+      items: schema.items,
+      required: schema.required,
+      enum: schema.enum,
+      $ref: schema.$ref,
+      allOf: schema.allOf,
+      oneOf: schema.oneOf,
+      anyOf: schema.anyOf,
+      description: schema.description,
+      format: schema.format,
+      minLength: schema.minLength,
+      maxLength: schema.maxLength,
+      minimum: schema.minimum,
+      maximum: schema.maximum,
+      pattern: schema.pattern,
+      nullable: schema.nullable
+    }) : schema;
+  if (typeAsArray !== undefined) {
+    if (typeAsArray.length > 1) {
+      let irTypes = typeAsArray.map(t => {
+        let subSchema_type = t;
+        let subSchema_properties = schema$1.properties;
+        let subSchema_items = schema$1.items;
+        let subSchema_required = schema$1.required;
+        let subSchema_enum = schema$1.enum;
+        let subSchema_$ref = schema$1.$ref;
+        let subSchema_allOf = schema$1.allOf;
+        let subSchema_oneOf = schema$1.oneOf;
+        let subSchema_anyOf = schema$1.anyOf;
+        let subSchema_description = schema$1.description;
+        let subSchema_format = schema$1.format;
+        let subSchema_minLength = schema$1.minLength;
+        let subSchema_maxLength = schema$1.maxLength;
+        let subSchema_minimum = schema$1.minimum;
+        let subSchema_maximum = schema$1.maximum;
+        let subSchema_pattern = schema$1.pattern;
+        let subSchema = {
+          type: subSchema_type,
+          properties: subSchema_properties,
+          items: subSchema_items,
+          required: subSchema_required,
+          enum: subSchema_enum,
+          $ref: subSchema_$ref,
+          allOf: subSchema_allOf,
+          oneOf: subSchema_oneOf,
+          anyOf: subSchema_anyOf,
+          description: subSchema_description,
+          format: subSchema_format,
+          minLength: subSchema_minLength,
+          maxLength: subSchema_maxLength,
+          minimum: subSchema_minimum,
+          maximum: subSchema_maximum,
+          pattern: subSchema_pattern,
+          nullable: undefined
+        };
+        return parseJsonSchemaWithContext(ctx, depth + 1 | 0, subSchema);
+      });
+      let baseType = {
+        TAG: "Union",
+        _0: irTypes
+      };
+      if (isNullable) {
+        return {
+          TAG: "Option",
+          _0: baseType
+        };
+      } else {
+        return baseType;
+      }
+    }
+    if (typeAsArray.length === 1) {
+      let subSchema_type = typeAsArray[0];
+      let subSchema_properties = schema$1.properties;
+      let subSchema_items = schema$1.items;
+      let subSchema_required = schema$1.required;
+      let subSchema_enum = schema$1.enum;
+      let subSchema_$ref = schema$1.$ref;
+      let subSchema_allOf = schema$1.allOf;
+      let subSchema_oneOf = schema$1.oneOf;
+      let subSchema_anyOf = schema$1.anyOf;
+      let subSchema_description = schema$1.description;
+      let subSchema_format = schema$1.format;
+      let subSchema_minLength = schema$1.minLength;
+      let subSchema_maxLength = schema$1.maxLength;
+      let subSchema_minimum = schema$1.minimum;
+      let subSchema_maximum = schema$1.maximum;
+      let subSchema_pattern = schema$1.pattern;
+      let subSchema = {
+        type: subSchema_type,
+        properties: subSchema_properties,
+        items: subSchema_items,
+        required: subSchema_required,
+        enum: subSchema_enum,
+        $ref: subSchema_$ref,
+        allOf: subSchema_allOf,
+        oneOf: subSchema_oneOf,
+        anyOf: subSchema_anyOf,
+        description: subSchema_description,
+        format: subSchema_format,
+        minLength: subSchema_minLength,
+        maxLength: subSchema_maxLength,
+        minimum: subSchema_minimum,
+        maximum: subSchema_maximum,
+        pattern: subSchema_pattern,
+        nullable: undefined
+      };
+      let baseType$1 = parseJsonSchemaWithContext(ctx, depth + 1 | 0, subSchema);
+      if (isNullable) {
+        return {
+          TAG: "Option",
+          _0: baseType$1
+        };
+      } else {
+        return baseType$1;
+      }
+    }
+  }
+  let normalizedType = Stdlib_Option.map(schema$1.type, parseTypeString);
+  let baseType$2;
   if (normalizedType !== undefined) {
     if (typeof normalizedType !== "object") {
       switch (normalizedType) {
         case "String" :
-          let constraints_minLength = schema.minLength;
-          let constraints_maxLength = schema.maxLength;
-          let constraints_pattern = schema.pattern;
+          let constraints_minLength = schema$1.minLength;
+          let constraints_maxLength = schema$1.maxLength;
+          let constraints_pattern = schema$1.pattern;
           let constraints = {
             minLength: constraints_minLength,
             maxLength: constraints_maxLength,
             pattern: constraints_pattern
           };
-          baseType = {
+          baseType$2 = {
             TAG: "String",
             constraints: constraints
           };
           break;
         case "Number" :
-          let constraints_minimum = schema.minimum;
-          let constraints_maximum = schema.maximum;
+          let constraints_minimum = schema$1.minimum;
+          let constraints_maximum = schema$1.maximum;
           let constraints$1 = {
             minimum: constraints_minimum,
             maximum: constraints_maximum,
             multipleOf: undefined
           };
-          baseType = {
+          baseType$2 = {
             TAG: "Number",
             constraints: constraints$1
           };
           break;
         case "Integer" :
-          let constraints_minimum$1 = schema.minimum;
-          let constraints_maximum$1 = schema.maximum;
+          let constraints_minimum$1 = schema$1.minimum;
+          let constraints_maximum$1 = schema$1.maximum;
           let constraints$2 = {
             minimum: constraints_minimum$1,
             maximum: constraints_maximum$1,
             multipleOf: undefined
           };
-          baseType = {
+          baseType$2 = {
             TAG: "Integer",
             constraints: constraints$2
           };
           break;
         case "Boolean" :
-          baseType = "Boolean";
+          baseType$2 = "Boolean";
           break;
         case "Object" :
-          let schemas = schema.allOf;
+          let schemas = schema$1.allOf;
           if (schemas !== undefined) {
             let types = schemas.map(s => parseJsonSchemaWithContext(ctx, depth + 1 | 0, s));
-            baseType = {
+            baseType$2 = {
               TAG: "Intersection",
               _0: types
             };
           } else {
-            let propsDict = schema.properties;
+            let propsDict = schema$1.properties;
             let properties;
             if (propsDict !== undefined) {
-              let required = Stdlib_Option.getOr(schema.required, []);
+              let required = Stdlib_Option.getOr(schema$1.required, []);
               properties = Object.entries(propsDict).map(param => {
                 let name = param[0];
                 let isRequired = required.includes(name);
@@ -138,7 +265,7 @@ function parseJsonSchemaWithContext(ctx, depthOpt, schema) {
             } else {
               properties = [];
             }
-            baseType = {
+            baseType$2 = {
               TAG: "Object",
               properties: properties,
               additionalProperties: undefined
@@ -146,16 +273,16 @@ function parseJsonSchemaWithContext(ctx, depthOpt, schema) {
           }
           break;
         case "Null" :
-          baseType = "Null";
+          baseType$2 = "Null";
           break;
         case "Unknown" :
-          baseType = "Unknown";
+          baseType$2 = "Unknown";
           break;
       }
     } else {
-      let itemSchema = schema.items;
+      let itemSchema = schema$1.items;
       let items = itemSchema !== undefined ? parseJsonSchemaWithContext(ctx, depth + 1 | 0, itemSchema) : "Unknown";
-      baseType = {
+      baseType$2 = {
         TAG: "Array",
         items: items,
         constraints: {
@@ -166,11 +293,11 @@ function parseJsonSchemaWithContext(ctx, depthOpt, schema) {
       };
     }
   } else {
-    let match = schema.enum;
-    let match$1 = schema.properties;
-    let match$2 = schema.allOf;
-    let match$3 = schema.oneOf;
-    let match$4 = schema.anyOf;
+    let match = schema$1.enum;
+    let match$1 = schema$1.properties;
+    let match$2 = schema$1.allOf;
+    let match$3 = schema$1.oneOf;
+    let match$4 = schema$1.anyOf;
     if (match !== undefined) {
       let literals = match.map(value => {
         if (value === null) {
@@ -211,59 +338,59 @@ function parseJsonSchemaWithContext(ctx, depthOpt, schema) {
             return "Unknown";
         }
       });
-      baseType = {
+      baseType$2 = {
         TAG: "Union",
         _0: literals
       };
     } else if (match$1 !== undefined) {
-      baseType = parseJsonSchemaWithContext(ctx, depth + 1 | 0, {
+      baseType$2 = parseJsonSchemaWithContext(ctx, depth + 1 | 0, {
         type: "Object",
-        properties: schema.properties,
-        items: schema.items,
-        required: schema.required,
-        enum: schema.enum,
-        $ref: schema.$ref,
-        allOf: schema.allOf,
-        oneOf: schema.oneOf,
-        anyOf: schema.anyOf,
-        description: schema.description,
-        format: schema.format,
-        minLength: schema.minLength,
-        maxLength: schema.maxLength,
-        minimum: schema.minimum,
-        maximum: schema.maximum,
-        pattern: schema.pattern,
-        nullable: schema.nullable
+        properties: schema$1.properties,
+        items: schema$1.items,
+        required: schema$1.required,
+        enum: schema$1.enum,
+        $ref: schema$1.$ref,
+        allOf: schema$1.allOf,
+        oneOf: schema$1.oneOf,
+        anyOf: schema$1.anyOf,
+        description: schema$1.description,
+        format: schema$1.format,
+        minLength: schema$1.minLength,
+        maxLength: schema$1.maxLength,
+        minimum: schema$1.minimum,
+        maximum: schema$1.maximum,
+        pattern: schema$1.pattern,
+        nullable: undefined
       });
     } else if (match$2 !== undefined) {
       let types$1 = match$2.map(s => parseJsonSchemaWithContext(ctx, depth + 1 | 0, s));
-      baseType = {
+      baseType$2 = {
         TAG: "Intersection",
         _0: types$1
       };
     } else if (match$3 !== undefined) {
       let types$2 = match$3.map(s => parseJsonSchemaWithContext(ctx, depth + 1 | 0, s));
-      baseType = {
+      baseType$2 = {
         TAG: "Union",
         _0: types$2
       };
     } else if (match$4 !== undefined) {
       let types$3 = match$4.map(s => parseJsonSchemaWithContext(ctx, depth + 1 | 0, s));
-      baseType = {
+      baseType$2 = {
         TAG: "Union",
         _0: types$3
       };
     } else {
-      baseType = "Unknown";
+      baseType$2 = "Unknown";
     }
   }
   if (isNullable) {
     return {
       TAG: "Option",
-      _0: baseType
+      _0: baseType$2
     };
   } else {
-    return baseType;
+    return baseType$2;
   }
 }
 
@@ -296,6 +423,60 @@ function parseNamedSchema(name, schema) {
   ];
 }
 
+function normalizeReferences(availableNames, irType) {
+  if (typeof irType !== "object") {
+    return irType;
+  }
+  switch (irType.TAG) {
+    case "Array" :
+      return {
+        TAG: "Array",
+        items: normalizeReferences(availableNames, irType.items),
+        constraints: irType.constraints
+      };
+    case "Object" :
+      let newProperties = irType.properties.map(param => [
+        param[0],
+        normalizeReferences(availableNames, param[1]),
+        param[2]
+      ]);
+      let newAdditional = Stdlib_Option.map(irType.additionalProperties, t => normalizeReferences(availableNames, t));
+      return {
+        TAG: "Object",
+        properties: newProperties,
+        additionalProperties: newAdditional
+      };
+    case "Union" :
+      return {
+        TAG: "Union",
+        _0: irType._0.map(t => normalizeReferences(availableNames, t))
+      };
+    case "Intersection" :
+      return {
+        TAG: "Intersection",
+        _0: irType._0.map(t => normalizeReferences(availableNames, t))
+      };
+    case "Reference" :
+      let parts = irType._0.split("/");
+      let name = Stdlib_Option.getOr(parts[parts.length - 1 | 0], "");
+      if (availableNames.includes(name)) {
+        return {
+          TAG: "Reference",
+          _0: name
+        };
+      } else {
+        return irType;
+      }
+    case "Option" :
+      return {
+        TAG: "Option",
+        _0: normalizeReferences(availableNames, irType._0)
+      };
+    default:
+      return irType;
+  }
+}
+
 function parseComponentSchemas(schemas) {
   let namedSchemas = {};
   let allWarnings = [];
@@ -305,6 +486,16 @@ function parseComponentSchemas(schemas) {
     namedSchemas[name] = match[0];
     allWarnings.push(...match[1]);
   });
+  let availableNames = Object.keys(namedSchemas);
+  Object.entries(namedSchemas).forEach(param => {
+    let namedSchema = param[1];
+    let resolved = normalizeReferences(availableNames, namedSchema.type_);
+    namedSchemas[param[0]] = {
+      name: namedSchema.name,
+      description: namedSchema.description,
+      type_: resolved
+    };
+  });
   return [
     {
       schemas: namedSchemas
@@ -478,10 +669,12 @@ function optimizeIR(irType) {
 
 export {
   parseTypeString,
+  parseTypeAsArray,
   addWarning,
   parseJsonSchemaWithContext,
   parseJsonSchema,
   parseNamedSchema,
+  normalizeReferences,
   parseComponentSchemas,
   resolveReference,
   inlineSimpleReferences,