@f3liz/rescript-autogen-openapi 0.3.1

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 */

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

@@ -0,0 +1,92 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+function fromSpec(spec) {
+  let components = spec.components;
+  let schemas;
+  if (components !== undefined) {
+    let s = components.schemas;
+    schemas = s !== undefined ? s : ({});
+  } else {
+    schemas = {};
+  }
+  return {
+    schemas: schemas,
+    visiting: []
+  };
+}
+
+function empty() {
+  return {
+    schemas: {},
+    visiting: []
+  };
+}
+
+function extractSchemaName(ref) {
+  let prefix = "#/components/schemas/";
+  if (ref.startsWith(prefix)) {
+    return ref.slice(prefix.length);
+  }
+}
+
+function isVisiting(registry, name) {
+  return registry.visiting.includes(name);
+}
+
+function startVisiting(registry, name) {
+  registry.visiting = registry.visiting.concat([name]);
+}
+
+function stopVisiting(registry, name) {
+  registry.visiting = registry.visiting.filter(n => n !== name);
+}
+
+function getSchema(registry, name) {
+  return registry.schemas[name];
+}
+
+function resolveRef(registry, ref) {
+  let name = extractSchemaName(ref);
+  if (name !== undefined) {
+    return registry.schemas[name];
+  }
+}
+
+function getSchemaNames(registry) {
+  return Object.keys(registry.schemas);
+}
+
+function hasSchema(registry, name) {
+  return Stdlib_Option.isSome(registry.schemas[name]);
+}
+
+function addSchema(registry, name, schema) {
+  registry.schemas[name] = schema;
+}
+
+function merge(registry, other) {
+  Object.entries(other.schemas).forEach(param => {
+    let name = param[0];
+    if (!hasSchema(registry, name)) {
+      return addSchema(registry, name, param[1]);
+    }
+  });
+}
+
+export {
+  fromSpec,
+  empty,
+  extractSchemaName,
+  isVisiting,
+  startVisiting,
+  stopVisiting,
+  getSchema,
+  resolveRef,
+  getSchemaNames,
+  hasSchema,
+  addSchema,
+  merge,
+}
+/* No side effect */

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

@@ -0,0 +1,251 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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 Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+
+function makeEndpointKey(method, path) {
+  return method + `:` + path;
+}
+
+function schemasEqual(schema1, schema2) {
+  let match = schema1.type;
+  let match$1 = schema2.type;
+  let typeMatches = match !== undefined ? (
+      match$1 !== undefined ? Primitive_object.equal(match, match$1) : false
+    ) : match$1 === undefined;
+  if (!typeMatches) {
+    return false;
+  }
+  if (Primitive_object.notequal(schema1.format, schema2.format)) {
+    return false;
+  }
+  if (Primitive_object.notequal(schema1.nullable, schema2.nullable)) {
+    return false;
+  }
+  if (Primitive_object.notequal(schema1.enum, schema2.enum)) {
+    return false;
+  }
+  let match$2 = schema1.properties;
+  let match$3 = schema2.properties;
+  if (match$2 === undefined) {
+    return match$3 === undefined;
+  }
+  if (match$3 === undefined) {
+    return false;
+  }
+  let keys1 = Object.keys(match$2).toSorted(Primitive_string.compare);
+  let keys2 = Object.keys(match$3).toSorted(Primitive_string.compare);
+  if (Primitive_object.notequal(keys1, keys2)) {
+    return false;
+  } else {
+    return keys1.every(key => {
+      let match$4 = match$2[key];
+      let match$5 = match$3[key];
+      if (match$4 !== undefined && match$5 !== undefined) {
+        return schemasEqual(match$4, match$5);
+      } else {
+        return false;
+      }
+    });
+  }
+}
+
+function compareEndpoints(endpoint1, endpoint2) {
+  let match = endpoint1.requestBody;
+  let match$1 = endpoint2.requestBody;
+  let hasRequestBodyChanged;
+  if (match !== undefined) {
+    if (match$1 !== undefined) {
+      let keys1 = Object.keys(match.content).toSorted(Primitive_string.compare);
+      let keys2 = Object.keys(match$1.content).toSorted(Primitive_string.compare);
+      hasRequestBodyChanged = Primitive_object.notequal(keys1, keys2) ? true : keys1.some(contentType => {
+          let match$2 = match.content[contentType];
+          let match$3 = match$1.content[contentType];
+          if (match$2 === undefined) {
+            return false;
+          }
+          if (match$3 === undefined) {
+            return false;
+          }
+          let match$4 = match$2.schema;
+          let match$5 = match$3.schema;
+          if (match$4 !== undefined && match$5 !== undefined) {
+            return !schemasEqual(match$4, match$5);
+          } else {
+            return false;
+          }
+        });
+    } else {
+      hasRequestBodyChanged = true;
+    }
+  } else {
+    hasRequestBodyChanged = match$1 !== undefined;
+  }
+  let codes1 = Object.keys(endpoint1.responses).toSorted(Primitive_string.compare);
+  let codes2 = Object.keys(endpoint2.responses).toSorted(Primitive_string.compare);
+  let hasResponseChanged = Primitive_object.notequal(codes1, codes2) ? true : codes1.some(code => {
+      let match = endpoint1.responses[code];
+      let match$1 = endpoint2.responses[code];
+      if (match === undefined) {
+        return false;
+      }
+      if (match$1 === undefined) {
+        return false;
+      }
+      let match$2 = match.content;
+      let match$3 = match$1.content;
+      if (match$2 === undefined) {
+        return match$3 !== undefined;
+      }
+      if (match$3 === undefined) {
+        return true;
+      }
+      let contentKeys1 = Object.keys(match$2).toSorted(Primitive_string.compare);
+      let contentKeys2 = Object.keys(match$3).toSorted(Primitive_string.compare);
+      if (Primitive_object.notequal(contentKeys1, contentKeys2)) {
+        return true;
+      } else {
+        return contentKeys1.some(contentType => {
+          let match$4 = match$2[contentType];
+          let match$5 = match$3[contentType];
+          if (match$4 === undefined) {
+            return false;
+          }
+          if (match$5 === undefined) {
+            return false;
+          }
+          let match$6 = match$4.schema;
+          let match$7 = match$5.schema;
+          if (match$6 !== undefined && match$7 !== undefined) {
+            return !schemasEqual(match$6, match$7);
+          } else {
+            return false;
+          }
+        });
+      }
+    });
+  if (hasRequestBodyChanged || hasResponseChanged) {
+    return {
+      path: endpoint1.path,
+      method: endpoint1.method,
+      requestBodyChanged: hasRequestBodyChanged,
+      responseChanged: hasResponseChanged,
+      breakingChange: hasResponseChanged
+    };
+  }
+}
+
+function compareEndpointLists(baseEndpoints, forkEndpoints) {
+  let baseMap = {};
+  baseEndpoints.forEach(ep => {
+    let key = makeEndpointKey(ep.method, ep.path);
+    baseMap[key] = ep;
+  });
+  let forkMap = {};
+  forkEndpoints.forEach(ep => {
+    let key = makeEndpointKey(ep.method, ep.path);
+    forkMap[key] = ep;
+  });
+  let baseKeys = new Set(Object.keys(baseMap));
+  let forkKeys = new Set(Object.keys(forkMap));
+  let added = Stdlib_Array.filterMap(Array.from(forkKeys).filter(key => !baseKeys.has(key)), key => forkMap[key]);
+  let removed = Stdlib_Array.filterMap(Array.from(baseKeys).filter(key => !forkKeys.has(key)), key => baseMap[key]);
+  let modified = Stdlib_Array.filterMap(Array.from(baseKeys).filter(key => forkKeys.has(key)), key => {
+    let match = baseMap[key];
+    let match$1 = forkMap[key];
+    if (match !== undefined && match$1 !== undefined) {
+      return compareEndpoints(match, match$1);
+    }
+  });
+  return [
+    added,
+    removed,
+    modified
+  ];
+}
+
+function compareComponentSchemas(baseSchemas, forkSchemas) {
+  if (baseSchemas === undefined) {
+    if (forkSchemas !== undefined) {
+      return [
+        Object.keys(forkSchemas),
+        [],
+        []
+      ];
+    } else {
+      return [
+        [],
+        [],
+        []
+      ];
+    }
+  }
+  if (forkSchemas === undefined) {
+    return [
+      [],
+      Object.keys(baseSchemas),
+      []
+    ];
+  }
+  let baseKeys = new Set(Object.keys(baseSchemas));
+  let forkKeys = new Set(Object.keys(forkSchemas));
+  let added = Array.from(forkKeys).filter(key => !baseKeys.has(key));
+  let removed = Array.from(baseKeys).filter(key => !forkKeys.has(key));
+  let modified = Stdlib_Array.filterMap(Array.from(baseKeys).filter(key => forkKeys.has(key)), name => {
+    let match = baseSchemas[name];
+    let match$1 = forkSchemas[name];
+    if (match !== undefined && match$1 !== undefined && !schemasEqual(match, match$1)) {
+      return {
+        name: name,
+        breakingChange: true
+      };
+    }
+  });
+  return [
+    added,
+    removed,
+    modified
+  ];
+}
+
+function generateDiff(baseSpec, forkSpec, baseEndpoints, forkEndpoints) {
+  let match = compareEndpointLists(baseEndpoints, forkEndpoints);
+  let match$1 = compareComponentSchemas(Stdlib_Option.flatMap(baseSpec.components, c => c.schemas), Stdlib_Option.flatMap(forkSpec.components, c => c.schemas));
+  return {
+    addedEndpoints: match[0],
+    removedEndpoints: match[1],
+    modifiedEndpoints: match[2],
+    addedSchemas: match$1[0],
+    removedSchemas: match$1[1],
+    modifiedSchemas: match$1[2]
+  };
+}
+
+function hasBreakingChanges(diff) {
+  let hasRemovedEndpoints = diff.removedEndpoints.length !== 0;
+  let hasBreakingEndpointChanges = diff.modifiedEndpoints.some(d => d.breakingChange);
+  let hasBreakingSchemaChanges = diff.modifiedSchemas.some(d => d.breakingChange);
+  if (hasRemovedEndpoints || hasBreakingEndpointChanges) {
+    return true;
+  } else {
+    return hasBreakingSchemaChanges;
+  }
+}
+
+function countChanges(diff) {
+  return ((((diff.addedEndpoints.length + diff.removedEndpoints.length | 0) + diff.modifiedEndpoints.length | 0) + diff.addedSchemas.length | 0) + diff.removedSchemas.length | 0) + diff.modifiedSchemas.length | 0;
+}
+
+export {
+  makeEndpointKey,
+  schemasEqual,
+  compareEndpoints,
+  compareEndpointLists,
+  compareComponentSchemas,
+  generateDiff,
+  hasBreakingChanges,
+  countChanges,
+}
+/* No side effect */