@f3liz/rescript-autogen-openapi 0.3.1

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

@@ -0,0 +1,683 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as SchemaIR from "./SchemaIR.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+function parseTypeString(rawType) {
+  switch (rawType) {
+    case "array" :
+      return {
+        TAG: "Array",
+        _0: "Unknown"
+      };
+    case "boolean" :
+      return "Boolean";
+    case "integer" :
+      return "Integer";
+    case "null" :
+      return "Null";
+    case "number" :
+      return "Number";
+    case "object" :
+      return "Object";
+    case "string" :
+      return "String";
+    default:
+      switch (rawType) {
+        case "Boolean" :
+          return "Boolean";
+        case "Integer" :
+          return "Integer";
+        case "Null" :
+          return "Null";
+        case "Number" :
+          return "Number";
+        case "Object" :
+          return "Object";
+        case "String" :
+          return "String";
+        default:
+          return "Unknown";
+      }
+  }
+}
+
+function parseTypeAsArray(rawType) {
+  if (Array.isArray(rawType)) {
+    return rawType.map(parseTypeString);
+  }
+}
+
+function addWarning(ctx, warning) {
+  ctx.warnings.push(warning);
+}
+
+function parseJsonSchemaWithContext(ctx, depthOpt, schema) {
+  let depth = depthOpt !== undefined ? depthOpt : 0;
+  if (depth > 30) {
+    addWarning(ctx, {
+      TAG: "DepthLimitReached",
+      depth: depth,
+      path: ctx.path
+    });
+    return "Unknown";
+  }
+  let ref = schema.$ref;
+  if (ref !== undefined) {
+    return {
+      TAG: "Reference",
+      _0: ref
+    };
+  }
+  let isNullable = Stdlib_Option.getOr(schema.nullable, false);
+  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$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$2 = {
+            TAG: "String",
+            constraints: constraints
+          };
+          break;
+        case "Number" :
+          let constraints_minimum = schema$1.minimum;
+          let constraints_maximum = schema$1.maximum;
+          let constraints$1 = {
+            minimum: constraints_minimum,
+            maximum: constraints_maximum,
+            multipleOf: undefined
+          };
+          baseType$2 = {
+            TAG: "Number",
+            constraints: constraints$1
+          };
+          break;
+        case "Integer" :
+          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$2 = {
+            TAG: "Integer",
+            constraints: constraints$2
+          };
+          break;
+        case "Boolean" :
+          baseType$2 = "Boolean";
+          break;
+        case "Object" :
+          let schemas = schema$1.allOf;
+          if (schemas !== undefined) {
+            let types = schemas.map(s => parseJsonSchemaWithContext(ctx, depth + 1 | 0, s));
+            baseType$2 = {
+              TAG: "Intersection",
+              _0: types
+            };
+          } else {
+            let propsDict = schema$1.properties;
+            let properties;
+            if (propsDict !== undefined) {
+              let required = Stdlib_Option.getOr(schema$1.required, []);
+              properties = Object.entries(propsDict).map(param => {
+                let name = param[0];
+                let isRequired = required.includes(name);
+                let propType = parseJsonSchemaWithContext(ctx, depth + 1 | 0, param[1]);
+                return [
+                  name,
+                  propType,
+                  isRequired
+                ];
+              });
+            } else {
+              properties = [];
+            }
+            baseType$2 = {
+              TAG: "Object",
+              properties: properties,
+              additionalProperties: undefined
+            };
+          }
+          break;
+        case "Null" :
+          baseType$2 = "Null";
+          break;
+        case "Unknown" :
+          baseType$2 = "Unknown";
+          break;
+      }
+    } else {
+      let itemSchema = schema$1.items;
+      let items = itemSchema !== undefined ? parseJsonSchemaWithContext(ctx, depth + 1 | 0, itemSchema) : "Unknown";
+      baseType$2 = {
+        TAG: "Array",
+        items: items,
+        constraints: {
+          minItems: undefined,
+          maxItems: undefined,
+          uniqueItems: false
+        }
+      };
+    }
+  } else {
+    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) {
+          return {
+            TAG: "Literal",
+            _0: "NullLiteral"
+          };
+        }
+        if (Array.isArray(value)) {
+          return "Unknown";
+        }
+        switch (typeof value) {
+          case "boolean" :
+            return {
+              TAG: "Literal",
+              _0: {
+                TAG: "BooleanLiteral",
+                _0: value
+              }
+            };
+          case "string" :
+            return {
+              TAG: "Literal",
+              _0: {
+                TAG: "StringLiteral",
+                _0: value
+              }
+            };
+          case "number" :
+            return {
+              TAG: "Literal",
+              _0: {
+                TAG: "NumberLiteral",
+                _0: value
+              }
+            };
+          case "object" :
+            return "Unknown";
+        }
+      });
+      baseType$2 = {
+        TAG: "Union",
+        _0: literals
+      };
+    } else if (match$1 !== undefined) {
+      baseType$2 = parseJsonSchemaWithContext(ctx, depth + 1 | 0, {
+        type: "Object",
+        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$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$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$2 = {
+        TAG: "Union",
+        _0: types$3
+      };
+    } else {
+      baseType$2 = "Unknown";
+    }
+  }
+  if (isNullable) {
+    return {
+      TAG: "Option",
+      _0: baseType$2
+    };
+  } else {
+    return baseType$2;
+  }
+}
+
+function parseJsonSchema(depthOpt, schema) {
+  let depth = depthOpt !== undefined ? depthOpt : 0;
+  let ctx = {
+    warnings: [],
+    path: "root"
+  };
+  let irType = parseJsonSchemaWithContext(ctx, depth, schema);
+  return [
+    irType,
+    ctx.warnings
+  ];
+}
+
+function parseNamedSchema(name, schema) {
+  let ctx = {
+    warnings: [],
+    path: `components.schemas.` + name
+  };
+  let type_ = parseJsonSchemaWithContext(ctx, undefined, schema);
+  return [
+    {
+      name: name,
+      description: schema.description,
+      type_: type_
+    },
+    ctx.warnings
+  ];
+}
+
+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 = [];
+  Object.entries(schemas).forEach(param => {
+    let name = param[0];
+    let match = parseNamedSchema(name, param[1]);
+    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
+    },
+    allWarnings
+  ];
+}
+
+function resolveReference(context, ref) {
+  let parts = ref.split("/");
+  let schemaName = parts[parts.length - 1 | 0];
+  if (schemaName !== undefined) {
+    return context.schemas[schemaName];
+  }
+}
+
+function inlineSimpleReferences(context, _irType, _depthOpt, _maxDepthOpt) {
+  while (true) {
+    let depthOpt = _depthOpt;
+    let maxDepthOpt = _maxDepthOpt;
+    let irType = _irType;
+    let depth = depthOpt !== undefined ? depthOpt : 0;
+    let maxDepth = maxDepthOpt !== undefined ? maxDepthOpt : 2;
+    if (depth >= maxDepth) {
+      return irType;
+    }
+    if (typeof irType !== "object") {
+      return irType;
+    }
+    switch (irType.TAG) {
+      case "Array" :
+        return {
+          TAG: "Array",
+          items: inlineSimpleReferences(context, irType.items, depth, maxDepth),
+          constraints: irType.constraints
+        };
+      case "Object" :
+        let newProperties = irType.properties.map(param => [
+          param[0],
+          inlineSimpleReferences(context, param[1], depth, maxDepth),
+          param[2]
+        ]);
+        let newAdditionalProps = Stdlib_Option.map(irType.additionalProperties, type_ => inlineSimpleReferences(context, type_, depth, maxDepth));
+        return {
+          TAG: "Object",
+          properties: newProperties,
+          additionalProperties: newAdditionalProps
+        };
+      case "Union" :
+        return {
+          TAG: "Union",
+          _0: irType._0.map(type_ => inlineSimpleReferences(context, type_, depth, maxDepth))
+        };
+      case "Intersection" :
+        return {
+          TAG: "Intersection",
+          _0: irType._0.map(type_ => inlineSimpleReferences(context, type_, depth, maxDepth))
+        };
+      case "Reference" :
+        let schema = resolveReference(context, irType._0);
+        if (schema === undefined) {
+          return irType;
+        }
+        if (!SchemaIR.isSimpleType(schema.type_)) {
+          return irType;
+        }
+        _maxDepthOpt = maxDepth;
+        _depthOpt = depth + 1 | 0;
+        _irType = schema.type_;
+        continue;
+      case "Option" :
+        return {
+          TAG: "Option",
+          _0: inlineSimpleReferences(context, irType._0, depth, maxDepth)
+        };
+      default:
+        return irType;
+    }
+  };
+}
+
+function optimizeIR(irType) {
+  if (typeof irType !== "object") {
+    return irType;
+  }
+  switch (irType.TAG) {
+    case "Array" :
+      return {
+        TAG: "Array",
+        items: optimizeIR(irType.items),
+        constraints: irType.constraints
+      };
+    case "Object" :
+      let newProperties = irType.properties.map(param => [
+        param[0],
+        optimizeIR(param[1]),
+        param[2]
+      ]);
+      let newAdditionalProps = Stdlib_Option.map(irType.additionalProperties, optimizeIR);
+      return {
+        TAG: "Object",
+        properties: newProperties,
+        additionalProperties: newAdditionalProps
+      };
+    case "Union" :
+      let flattened = irType._0.flatMap(t => {
+        let inner = optimizeIR(t);
+        if (typeof inner !== "object") {
+          return [inner];
+        } else if (inner.TAG === "Union") {
+          return inner._0;
+        } else {
+          return [inner];
+        }
+      });
+      let unique = [];
+      flattened.forEach(type_ => {
+        let typeStr = SchemaIR.toString(type_);
+        let exists = unique.some(t => SchemaIR.toString(t) === typeStr);
+        if (!exists) {
+          unique.push(type_);
+          return;
+        }
+      });
+      let len = unique.length;
+      if (len !== 1) {
+        if (len !== 0) {
+          return {
+            TAG: "Union",
+            _0: unique
+          };
+        } else {
+          return "Unknown";
+        }
+      } else {
+        return unique[0];
+      }
+    case "Intersection" :
+      let flattened$1 = irType._0.flatMap(t => {
+        let inner = optimizeIR(t);
+        if (typeof inner !== "object") {
+          return [inner];
+        } else if (inner.TAG === "Intersection") {
+          return inner._0;
+        } else {
+          return [inner];
+        }
+      });
+      let len$1 = flattened$1.length;
+      if (len$1 !== 1) {
+        if (len$1 !== 0) {
+          return {
+            TAG: "Intersection",
+            _0: flattened$1
+          };
+        } else {
+          return "Unknown";
+        }
+      } else {
+        return flattened$1[0];
+      }
+    case "Option" :
+      return {
+        TAG: "Option",
+        _0: optimizeIR(irType._0)
+      };
+    default:
+      return irType;
+  }
+}
+
+export {
+  parseTypeString,
+  parseTypeAsArray,
+  addWarning,
+  parseJsonSchemaWithContext,
+  parseJsonSchema,
+  parseNamedSchema,
+  normalizeReferences,
+  parseComponentSchemas,
+  resolveReference,
+  inlineSimpleReferences,
+  optimizeIR,
+}
+/* No side effect */