@f3liz/rescript-autogen-openapi 0.1.0

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

@@ -0,0 +1,168 @@
+// 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";
+
+function parseMethod(methodStr) {
+  let match = methodStr.toLowerCase();
+  switch (match) {
+    case "delete" :
+      return "DELETE";
+    case "get" :
+      return "GET";
+    case "head" :
+      return "HEAD";
+    case "options" :
+      return "OPTIONS";
+    case "patch" :
+      return "PATCH";
+    case "post" :
+      return "POST";
+    case "put" :
+      return "PUT";
+    default:
+      return;
+  }
+}
+
+function httpMethodToString(method) {
+  if (method === "GET") {
+    return "get";
+  } else if (method === "PUT") {
+    return "put";
+  } else if (method === "DELETE") {
+    return "delete";
+  } else if (method === "HEAD") {
+    return "head";
+  } else if (method === "POST") {
+    return "post";
+  } else if (method === "PATCH") {
+    return "patch";
+  } else {
+    return "options";
+  }
+}
+
+function tupleToEndpoint(param) {
+  let operation = param[2];
+  return {
+    path: param[0],
+    method: httpMethodToString(param[1]),
+    operationId: operation.operationId,
+    summary: operation.summary,
+    description: operation.description,
+    tags: operation.tags,
+    requestBody: operation.requestBody,
+    responses: operation.responses,
+    parameters: operation.parameters
+  };
+}
+
+function getOperations(path, param) {
+  return Stdlib_Array.filterMap([
+    [
+      "GET",
+      param.get
+    ],
+    [
+      "POST",
+      param.post
+    ],
+    [
+      "PUT",
+      param.put
+    ],
+    [
+      "PATCH",
+      param.patch
+    ],
+    [
+      "DELETE",
+      param.delete
+    ],
+    [
+      "HEAD",
+      param.head
+    ],
+    [
+      "OPTIONS",
+      param.options
+    ]
+  ], param => {
+    let method = param[0];
+    return Stdlib_Option.map(param[1], op => [
+      path,
+      method,
+      op
+    ]);
+  });
+}
+
+function getAllEndpoints(spec) {
+  let pathsArray = Object.entries(spec.paths);
+  return pathsArray.flatMap(param => getOperations(param[0], param[1])).map(tupleToEndpoint);
+}
+
+function groupByTag(endpoints) {
+  let grouped = {};
+  endpoints.forEach(endpoint => {
+    let tags = Stdlib_Option.getOr(endpoint.tags, ["default"]);
+    tags.forEach(tag => {
+      let existing = Stdlib_Option.getOr(grouped[tag], []);
+      existing.push(endpoint);
+      grouped[tag] = existing;
+    });
+  });
+  return grouped;
+}
+
+function getAllSchemas(spec) {
+  return Stdlib_Option.getOr(Stdlib_Option.flatMap(spec.components, c => c.schemas), {});
+}
+
+function getOperationId(path, method, operation) {
+  let methodStr = method === "GET" ? "get" : (
+      method === "PUT" ? "put" : (
+          method === "DELETE" ? "delete" : (
+              method === "HEAD" ? "head" : (
+                  method === "POST" ? "post" : (
+                      method === "PATCH" ? "patch" : "options"
+                    )
+                )
+            )
+        )
+    );
+  let pathParts = path.replaceAll("/", "_").replaceAll("{", "").replaceAll("}", "").replaceAll("-", "_");
+  return Stdlib_Option.getOr(operation.operationId, methodStr + pathParts);
+}
+
+function filterByTags(endpoints, includeTags, excludeTags) {
+  return endpoints.filter(endpoint => {
+    let operationTags = Stdlib_Option.getOr(endpoint.tags, []);
+    let included = operationTags.some(tag => includeTags.includes(tag));
+    let excluded = operationTags.some(tag => excludeTags.includes(tag));
+    if (included) {
+      return !excluded;
+    } else {
+      return false;
+    }
+  });
+}
+
+function getAllTags(endpoints) {
+  return Array.from(new Set(endpoints.flatMap(endpoint => Stdlib_Option.getOr(endpoint.tags, []))));
+}
+
+export {
+  parseMethod,
+  httpMethodToString,
+  tupleToEndpoint,
+  getOperations,
+  getAllEndpoints,
+  groupByTag,
+  getAllSchemas,
+  getOperationId,
+  filterByTags,
+  getAllTags,
+}
+/* No side effect */

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

@@ -0,0 +1,150 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let empty_files = [];
+
+let empty_warnings = [];
+
+let empty = {
+  files: empty_files,
+  warnings: empty_warnings
+};
+
+function merge(a, b) {
+  return {
+    files: a.files.concat(b.files),
+    warnings: a.warnings.concat(b.warnings)
+  };
+}
+
+function combine(outputs) {
+  return {
+    files: outputs.flatMap(p => p.files),
+    warnings: outputs.flatMap(p => p.warnings)
+  };
+}
+
+function addFile(file, p) {
+  return {
+    files: p.files.concat([file]),
+    warnings: p.warnings
+  };
+}
+
+function addFiles(files, p) {
+  return {
+    files: p.files.concat(files),
+    warnings: p.warnings
+  };
+}
+
+function addWarning(warning, p) {
+  return {
+    files: p.files,
+    warnings: p.warnings.concat([warning])
+  };
+}
+
+function addWarnings(warnings, p) {
+  return {
+    files: p.files,
+    warnings: p.warnings.concat(warnings)
+  };
+}
+
+function mapFiles(fn, p) {
+  return {
+    files: p.files.map(fn),
+    warnings: p.warnings
+  };
+}
+
+function filterWarnings(pred, p) {
+  return {
+    files: p.files,
+    warnings: p.warnings.filter(pred)
+  };
+}
+
+function make(filesOpt, warningsOpt, param) {
+  let files = filesOpt !== undefined ? filesOpt : [];
+  let warnings = warningsOpt !== undefined ? warningsOpt : [];
+  return {
+    files: files,
+    warnings: warnings
+  };
+}
+
+function fromFile(file) {
+  return make([file], undefined, undefined);
+}
+
+function fromFiles(files) {
+  return make(files, undefined, undefined);
+}
+
+function fromWarning(warning) {
+  return make(undefined, [warning], undefined);
+}
+
+function fromWarnings(warnings) {
+  return make(undefined, warnings, undefined);
+}
+
+function files(p) {
+  return p.files;
+}
+
+function warnings(p) {
+  return p.warnings;
+}
+
+function fileCount(p) {
+  return p.files.length;
+}
+
+function warningCount(p) {
+  return p.warnings.length;
+}
+
+function filePaths(p) {
+  return p.files.map(f => f.path);
+}
+
+function withWarnings(p, w) {
+  return addWarnings(w, p);
+}
+
+function withFiles(p, f) {
+  return addFiles(f, p);
+}
+
+function fromFilesAndWarnings(files, warnings) {
+  return make(files, warnings, undefined);
+}
+
+export {
+  empty,
+  merge,
+  combine,
+  addFile,
+  addFiles,
+  addWarning,
+  addWarnings,
+  mapFiles,
+  filterWarnings,
+  make,
+  fromFile,
+  fromFiles,
+  fromWarning,
+  fromWarnings,
+  files,
+  warnings,
+  fileCount,
+  warningCount,
+  filePaths,
+  withWarnings,
+  withFiles,
+  fromFilesAndWarnings,
+}
+/* No side effect */

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

@@ -0,0 +1,41 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Text from "@std/text";
+
+function refToTypePath(insideComponentSchemasOpt, modulePrefixOpt, ref) {
+  let insideComponentSchemas = insideComponentSchemasOpt !== undefined ? insideComponentSchemasOpt : false;
+  let modulePrefix = modulePrefixOpt !== undefined ? modulePrefixOpt : "";
+  let parts = ref.split("/");
+  let schemaName = parts[parts.length - 1 | 0];
+  if (schemaName === undefined) {
+    return;
+  }
+  let moduleName = Text.toPascalCase(schemaName);
+  if (insideComponentSchemas) {
+    return moduleName + `.t`;
+  } else {
+    return modulePrefix + `ComponentSchemas.` + moduleName + `.t`;
+  }
+}
+
+function refToSchemaPath(insideComponentSchemasOpt, modulePrefixOpt, ref) {
+  let insideComponentSchemas = insideComponentSchemasOpt !== undefined ? insideComponentSchemasOpt : false;
+  let modulePrefix = modulePrefixOpt !== undefined ? modulePrefixOpt : "";
+  let parts = ref.split("/");
+  let schemaName = parts[parts.length - 1 | 0];
+  if (schemaName === undefined) {
+    return;
+  }
+  let moduleName = Text.toPascalCase(schemaName);
+  if (insideComponentSchemas) {
+    return moduleName + `.schema`;
+  } else {
+    return modulePrefix + `ComponentSchemas.` + moduleName + `.schema`;
+  }
+}
+
+export {
+  refToTypePath,
+  refToSchemaPath,
+}
+/* @std/text Not a pure module */

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

@@ -0,0 +1,378 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib from "@rescript/runtime/lib/es6/Stdlib.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+
+function map2(ra, rb, f) {
+  if (ra.TAG === "Ok") {
+    if (rb.TAG === "Ok") {
+      return {
+        TAG: "Ok",
+        _0: f(ra._0, rb._0)
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: rb._0
+      };
+    }
+  } else {
+    return {
+      TAG: "Error",
+      _0: ra._0
+    };
+  }
+}
+
+function map3(ra, rb, rc, f) {
+  if (ra.TAG === "Ok") {
+    if (rb.TAG === "Ok") {
+      if (rc.TAG === "Ok") {
+        return {
+          TAG: "Ok",
+          _0: f(ra._0, rb._0, rc._0)
+        };
+      } else {
+        return {
+          TAG: "Error",
+          _0: rc._0
+        };
+      }
+    } else {
+      return {
+        TAG: "Error",
+        _0: rb._0
+      };
+    }
+  } else {
+    return {
+      TAG: "Error",
+      _0: ra._0
+    };
+  }
+}
+
+function map4(ra, rb, rc, rd, f) {
+  if (ra.TAG === "Ok") {
+    if (rb.TAG === "Ok") {
+      if (rc.TAG === "Ok") {
+        if (rd.TAG === "Ok") {
+          return {
+            TAG: "Ok",
+            _0: f(ra._0, rb._0, rc._0, rd._0)
+          };
+        } else {
+          return {
+            TAG: "Error",
+            _0: rd._0
+          };
+        }
+      } else {
+        return {
+          TAG: "Error",
+          _0: rc._0
+        };
+      }
+    } else {
+      return {
+        TAG: "Error",
+        _0: rb._0
+      };
+    }
+  } else {
+    return {
+      TAG: "Error",
+      _0: ra._0
+    };
+  }
+}
+
+function all(results) {
+  let acc = [];
+  let error = {
+    contents: undefined
+  };
+  let len = results.length;
+  let loop = _idx => {
+    while (true) {
+      let idx = _idx;
+      if (!(idx < len && Stdlib_Option.isNone(error.contents))) {
+        return;
+      }
+      let v = results[idx];
+      if (v.TAG !== "Ok") {
+        error.contents = Primitive_option.some(v._0);
+        return;
+      }
+      acc.push(v._0);
+      _idx = idx + 1 | 0;
+      continue;
+    };
+  };
+  loop(0);
+  let e = error.contents;
+  if (e !== undefined) {
+    return {
+      TAG: "Error",
+      _0: Primitive_option.valFromOption(e)
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: acc
+    };
+  }
+}
+
+function allUnit(results) {
+  let error = {
+    contents: undefined
+  };
+  let len = results.length;
+  let loop = _idx => {
+    while (true) {
+      let idx = _idx;
+      if (!(idx < len && Stdlib_Option.isNone(error.contents))) {
+        return;
+      }
+      let e = results[idx];
+      if (e.TAG !== "Ok") {
+        error.contents = Primitive_option.some(e._0);
+        return;
+      }
+      _idx = idx + 1 | 0;
+      continue;
+    };
+  };
+  loop(0);
+  let e = error.contents;
+  if (e !== undefined) {
+    return {
+      TAG: "Error",
+      _0: Primitive_option.valFromOption(e)
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  }
+}
+
+function partition(results) {
+  let successes = [];
+  let errors = [];
+  results.forEach(r => {
+    if (r.TAG === "Ok") {
+      successes.push(r._0);
+      return;
+    }
+    errors.push(r._0);
+  });
+  return [
+    successes,
+    errors
+  ];
+}
+
+function firstSuccess(results) {
+  let errors = [];
+  let success = {
+    contents: undefined
+  };
+  let len = results.length;
+  let loop = _idx => {
+    while (true) {
+      let idx = _idx;
+      if (!(idx < len && Stdlib_Option.isNone(success.contents))) {
+        return;
+      }
+      let v = results[idx];
+      if (v.TAG === "Ok") {
+        success.contents = Primitive_option.some(v._0);
+        return;
+      }
+      errors.push(v._0);
+      _idx = idx + 1 | 0;
+      continue;
+    };
+  };
+  loop(0);
+  let v = success.contents;
+  if (v !== undefined) {
+    return {
+      TAG: "Ok",
+      _0: Primitive_option.valFromOption(v)
+    };
+  } else {
+    return {
+      TAG: "Error",
+      _0: errors
+    };
+  }
+}
+
+function foldM(arr, init, f) {
+  let loop = (acc, idx) => {
+    if (idx >= arr.length) {
+      return {
+        TAG: "Ok",
+        _0: acc
+      };
+    } else {
+      return Stdlib_Result.flatMap(f(acc, arr[idx]), newAcc => loop(newAcc, idx + 1 | 0));
+    }
+  };
+  return loop(init, 0);
+}
+
+function tap(result, f) {
+  if (result.TAG === "Ok") {
+    f(result._0);
+  }
+  return result;
+}
+
+function tapError(result, f) {
+  if (result.TAG !== "Ok") {
+    f(result._0);
+  }
+  return result;
+}
+
+function fromOption(opt, error) {
+  if (opt !== undefined) {
+    return {
+      TAG: "Ok",
+      _0: Primitive_option.valFromOption(opt)
+    };
+  } else {
+    return {
+      TAG: "Error",
+      _0: error
+    };
+  }
+}
+
+function toOption(result) {
+  if (result.TAG === "Ok") {
+    return Primitive_option.some(result._0);
+  }
+}
+
+function recover(result, f) {
+  if (result.TAG === "Ok") {
+    return result;
+  } else {
+    return f(result._0);
+  }
+}
+
+function getOr(result, $$default) {
+  if (result.TAG === "Ok") {
+    return result._0;
+  } else {
+    return $$default;
+  }
+}
+
+function getExn(result) {
+  if (result.TAG === "Ok") {
+    return result._0;
+  } else {
+    return Stdlib.panic("Result.getExn called on Error");
+  }
+}
+
+function getError(result) {
+  if (result.TAG === "Ok") {
+    return;
+  } else {
+    return Primitive_option.some(result._0);
+  }
+}
+
+let getOrThrow = Stdlib_Result.getOrThrow;
+
+let mapOr = Stdlib_Result.mapOr;
+
+let mapWithDefault = Stdlib_Result.mapWithDefault;
+
+let map = Stdlib_Result.map;
+
+let flatMap = Stdlib_Result.flatMap;
+
+let getWithDefault = Stdlib_Result.getWithDefault;
+
+let isOk = Stdlib_Result.isOk;
+
+let isError = Stdlib_Result.isError;
+
+let equal = Stdlib_Result.equal;
+
+let compare = Stdlib_Result.compare;
+
+let forEach = Stdlib_Result.forEach;
+
+let mapError = Stdlib_Result.mapError;
+
+let all2 = Stdlib_Result.all2;
+
+let all3 = Stdlib_Result.all3;
+
+let all4 = Stdlib_Result.all4;
+
+let all5 = Stdlib_Result.all5;
+
+let all6 = Stdlib_Result.all6;
+
+let mapOkAsync = Stdlib_Result.mapOkAsync;
+
+let mapErrorAsync = Stdlib_Result.mapErrorAsync;
+
+let flatMapOkAsync = Stdlib_Result.flatMapOkAsync;
+
+let flatMapErrorAsync = Stdlib_Result.flatMapErrorAsync;
+
+export {
+  getOrThrow,
+  mapOr,
+  mapWithDefault,
+  map,
+  flatMap,
+  getWithDefault,
+  isOk,
+  isError,
+  equal,
+  compare,
+  forEach,
+  mapError,
+  all2,
+  all3,
+  all4,
+  all5,
+  all6,
+  mapOkAsync,
+  mapErrorAsync,
+  flatMapOkAsync,
+  flatMapErrorAsync,
+  map2,
+  map3,
+  map4,
+  all,
+  allUnit,
+  partition,
+  firstSuccess,
+  foldM,
+  tap,
+  tapError,
+  fromOption,
+  toOption,
+  recover,
+  getOr,
+  getExn,
+  getError,
+}
+/* No side effect */