@f3liz/rescript-autogen-openapi 0.1.0

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

@@ -0,0 +1,490 @@
+// 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 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 normalizedType = Stdlib_Option.map(schema.type, parseTypeString);
+  let baseType;
+  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: constraints_minLength,
+            maxLength: constraints_maxLength,
+            pattern: constraints_pattern
+          };
+          baseType = {
+            TAG: "String",
+            constraints: constraints
+          };
+          break;
+        case "Number" :
+          let constraints_minimum = schema.minimum;
+          let constraints_maximum = schema.maximum;
+          let constraints$1 = {
+            minimum: constraints_minimum,
+            maximum: constraints_maximum,
+            multipleOf: undefined
+          };
+          baseType = {
+            TAG: "Number",
+            constraints: constraints$1
+          };
+          break;
+        case "Integer" :
+          let constraints_minimum$1 = schema.minimum;
+          let constraints_maximum$1 = schema.maximum;
+          let constraints$2 = {
+            minimum: constraints_minimum$1,
+            maximum: constraints_maximum$1,
+            multipleOf: undefined
+          };
+          baseType = {
+            TAG: "Integer",
+            constraints: constraints$2
+          };
+          break;
+        case "Boolean" :
+          baseType = "Boolean";
+          break;
+        case "Object" :
+          let schemas = schema.allOf;
+          if (schemas !== undefined) {
+            let types = schemas.map(s => parseJsonSchemaWithContext(ctx, depth + 1 | 0, s));
+            baseType = {
+              TAG: "Intersection",
+              _0: types
+            };
+          } else {
+            let propsDict = schema.properties;
+            let properties;
+            if (propsDict !== undefined) {
+              let required = Stdlib_Option.getOr(schema.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 = {
+              TAG: "Object",
+              properties: properties,
+              additionalProperties: undefined
+            };
+          }
+          break;
+        case "Null" :
+          baseType = "Null";
+          break;
+        case "Unknown" :
+          baseType = "Unknown";
+          break;
+      }
+    } else {
+      let itemSchema = schema.items;
+      let items = itemSchema !== undefined ? parseJsonSchemaWithContext(ctx, depth + 1 | 0, itemSchema) : "Unknown";
+      baseType = {
+        TAG: "Array",
+        items: items,
+        constraints: {
+          minItems: undefined,
+          maxItems: undefined,
+          uniqueItems: false
+        }
+      };
+    }
+  } 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;
+    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 = {
+        TAG: "Union",
+        _0: literals
+      };
+    } else if (match$1 !== undefined) {
+      baseType = 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
+      });
+    } else if (match$2 !== undefined) {
+      let types$1 = match$2.map(s => parseJsonSchemaWithContext(ctx, depth + 1 | 0, s));
+      baseType = {
+        TAG: "Intersection",
+        _0: types$1
+      };
+    } else if (match$3 !== undefined) {
+      let types$2 = match$3.map(s => parseJsonSchemaWithContext(ctx, depth + 1 | 0, s));
+      baseType = {
+        TAG: "Union",
+        _0: types$2
+      };
+    } else if (match$4 !== undefined) {
+      let types$3 = match$4.map(s => parseJsonSchemaWithContext(ctx, depth + 1 | 0, s));
+      baseType = {
+        TAG: "Union",
+        _0: types$3
+      };
+    } else {
+      baseType = "Unknown";
+    }
+  }
+  if (isNullable) {
+    return {
+      TAG: "Option",
+      _0: baseType
+    };
+  } else {
+    return baseType;
+  }
+}
+
+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 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]);
+  });
+  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,
+  addWarning,
+  parseJsonSchemaWithContext,
+  parseJsonSchema,
+  parseNamedSchema,
+  parseComponentSchemas,
+  resolveReference,
+  inlineSimpleReferences,
+  optimizeIR,
+}
+/* No side effect */

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

@@ -0,0 +1,146 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as OpenapiParser from "@readme/openapi-parser";
+
+function jsonToSpec(json) {
+  let obj = Stdlib_JSON.Decode.object(json);
+  if (obj === undefined) {
+    return {
+      TAG: "Error",
+      _0: "Invalid OpenAPI spec: root is not an object"
+    };
+  }
+  let pathsDict = Stdlib_Option.getOr(Stdlib_Option.flatMap(obj["paths"], Stdlib_JSON.Decode.object), {});
+  let infoObj = Stdlib_Option.getOr(Stdlib_Option.flatMap(obj["info"], Stdlib_JSON.Decode.object), {});
+  let openAPISpec_openapi = Stdlib_Option.getOr(Stdlib_Option.flatMap(obj["openapi"], Stdlib_JSON.Decode.string), "3.1.0");
+  let openAPISpec_info = {
+    title: Stdlib_Option.getOr(Stdlib_Option.flatMap(infoObj["title"], Stdlib_JSON.Decode.string), "Untitled API"),
+    version: Stdlib_Option.getOr(Stdlib_Option.flatMap(infoObj["version"], Stdlib_JSON.Decode.string), "0.0.0"),
+    description: Stdlib_Option.flatMap(infoObj["description"], Stdlib_JSON.Decode.string)
+  };
+  let openAPISpec_paths = Object.fromEntries(Object.entries(pathsDict).map(param => [
+    param[0],
+    param[1]
+  ]));
+  let openAPISpec_components = Stdlib_Option.map(obj["components"], _comp => ({
+    schemas: Stdlib_Option.map(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(_comp), c => c["schemas"]), Stdlib_JSON.Decode.object), schemas => Object.fromEntries(Object.entries(schemas).map(param => [
+      param[0],
+      param[1]
+    ])))
+  }));
+  let openAPISpec = {
+    openapi: openAPISpec_openapi,
+    info: openAPISpec_info,
+    paths: openAPISpec_paths,
+    components: openAPISpec_components
+  };
+  return {
+    TAG: "Ok",
+    _0: openAPISpec
+  };
+}
+
+async function resolve(source, timeout) {
+  try {
+    let options = {
+      timeoutMs: Stdlib_Option.getOr(timeout, 60000)
+    };
+    return jsonToSpec(await OpenapiParser.bundle(source, options));
+  } catch (raw_err) {
+    let err = Primitive_exceptions.internalToException(raw_err);
+    if (err.RE_EXN_ID !== "JsExn") {
+      return {
+        TAG: "Error",
+        _0: "Unknown error resolving spec"
+      };
+    }
+    let message = Stdlib_Option.getOr(Stdlib_JsExn.message(err._1), "Unknown error resolving spec");
+    return {
+      TAG: "Error",
+      _0: `Failed to resolve spec: ` + message
+    };
+  }
+}
+
+async function parseOnly(source, timeout) {
+  try {
+    let options = {
+      timeoutMs: Stdlib_Option.getOr(timeout, 60000)
+    };
+    return jsonToSpec(await OpenapiParser.parse(source, options));
+  } catch (raw_err) {
+    let err = Primitive_exceptions.internalToException(raw_err);
+    if (err.RE_EXN_ID !== "JsExn") {
+      return {
+        TAG: "Error",
+        _0: "Unknown error parsing spec"
+      };
+    }
+    let message = Stdlib_Option.getOr(Stdlib_JsExn.message(err._1), "Unknown error parsing spec");
+    return {
+      TAG: "Error",
+      _0: `Failed to parse spec: ` + message
+    };
+  }
+}
+
+async function bundleSpec(source, timeout) {
+  try {
+    let options = {
+      timeoutMs: Stdlib_Option.getOr(timeout, 60000)
+    };
+    let bundled = await OpenapiParser.bundle(source, options);
+    return {
+      TAG: "Ok",
+      _0: bundled
+    };
+  } catch (raw_err) {
+    let err = Primitive_exceptions.internalToException(raw_err);
+    if (err.RE_EXN_ID !== "JsExn") {
+      return {
+        TAG: "Error",
+        _0: "Unknown error bundling spec"
+      };
+    }
+    let message = Stdlib_Option.getOr(Stdlib_JsExn.message(err._1), "Unknown error bundling spec");
+    return {
+      TAG: "Error",
+      _0: `Failed to bundle spec: ` + message
+    };
+  }
+}
+
+async function validateSpec(source, timeout) {
+  try {
+    let options = {
+      timeoutMs: Stdlib_Option.getOr(timeout, 60000)
+    };
+    return jsonToSpec(await OpenapiParser.validate(source, options));
+  } catch (raw_err) {
+    let err = Primitive_exceptions.internalToException(raw_err);
+    if (err.RE_EXN_ID !== "JsExn") {
+      return {
+        TAG: "Error",
+        _0: "Unknown error validating spec"
+      };
+    }
+    let message = Stdlib_Option.getOr(Stdlib_JsExn.message(err._1), "Unknown error validating spec");
+    return {
+      TAG: "Error",
+      _0: `Failed to validate spec: ` + message
+    };
+  }
+}
+
+export {
+  jsonToSpec,
+  resolve,
+  parseOnly,
+  bundleSpec,
+  validateSpec,
+}
+/* Stdlib_JsExn Not a pure module */