@f3liz/rescript-autogen-openapi 0.3.1

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

@@ -0,0 +1,78 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Fs from "fs";
+import * as Pathe from "pathe";
+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";
+
+function ensureDir(path) {
+  try {
+    Fs.mkdirSync(Pathe.dirname(path), {
+      recursive: true
+    });
+    return;
+  } catch (exn) {
+    return;
+  }
+}
+
+function writeFile(file) {
+  try {
+    ensureDir(file.path);
+    Fs.writeFileSync(file.path, file.content, "utf8");
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    if (exn.RE_EXN_ID !== "JsExn") {
+      return {
+        TAG: "Error",
+        _0: `Failed to write file ` + file.path + `: Unknown error`
+      };
+    }
+    let message = Stdlib_Option.getOr(Stdlib_JsExn.message(exn._1), "Unknown error");
+    return {
+      TAG: "Error",
+      _0: `Failed to write file ` + file.path + `: ` + message
+    };
+  }
+}
+
+function writeFiles(files) {
+  let successes = [];
+  let errors = [];
+  files.forEach(file => {
+    let err = writeFile(file);
+    if (err.TAG === "Ok") {
+      successes.push(file.path);
+      return;
+    }
+    errors.push(err._0);
+  });
+  if (errors.length !== 0) {
+    return {
+      TAG: "Error",
+      _0: errors
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: successes
+    };
+  }
+}
+
+function makePath(baseDir, filename) {
+  return Pathe.join(baseDir, filename);
+}
+
+export {
+  ensureDir,
+  writeFile,
+  writeFiles,
+  makePath,
+}
+/* fs Not a pure module */

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

@@ -0,0 +1,201 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function string(min, max, pattern, param) {
+  return {
+    minLength: min,
+    maxLength: max,
+    pattern: pattern
+  };
+}
+
+function number(min, max, multipleOf, param) {
+  return {
+    minimum: min,
+    maximum: max,
+    multipleOf: multipleOf
+  };
+}
+
+function array(min, max, uniqueOpt, param) {
+  let unique = uniqueOpt !== undefined ? uniqueOpt : false;
+  return {
+    minItems: min,
+    maxItems: max,
+    uniqueItems: unique
+  };
+}
+
+let Constraints = {
+  string: string,
+  number: number,
+  array: array
+};
+
+function string$1(min, max, pattern, param) {
+  return {
+    TAG: "String",
+    constraints: {
+      minLength: min,
+      maxLength: max,
+      pattern: pattern
+    }
+  };
+}
+
+function number$1(min, max, multipleOf, param) {
+  return {
+    TAG: "Number",
+    constraints: {
+      minimum: min,
+      maximum: max,
+      multipleOf: multipleOf
+    }
+  };
+}
+
+function int(min, max, multipleOf, param) {
+  return {
+    TAG: "Integer",
+    constraints: {
+      minimum: min,
+      maximum: max,
+      multipleOf: multipleOf
+    }
+  };
+}
+
+function array$1(items, min, max, uniqueOpt, param) {
+  let unique = uniqueOpt !== undefined ? uniqueOpt : false;
+  return {
+    TAG: "Array",
+    items: items,
+    constraints: array(min, max, unique, undefined)
+  };
+}
+
+function object_(props, additional, param) {
+  return {
+    TAG: "Object",
+    properties: props,
+    additionalProperties: additional
+  };
+}
+
+function union(types) {
+  return {
+    TAG: "Union",
+    _0: types
+  };
+}
+
+function intersection(types) {
+  return {
+    TAG: "Intersection",
+    _0: types
+  };
+}
+
+function ref(refPath) {
+  return {
+    TAG: "Reference",
+    _0: refPath
+  };
+}
+
+function option(type_) {
+  return {
+    TAG: "Option",
+    _0: type_
+  };
+}
+
+function stringLit(s) {
+  return {
+    TAG: "Literal",
+    _0: {
+      TAG: "StringLiteral",
+      _0: s
+    }
+  };
+}
+
+function numberLit(n) {
+  return {
+    TAG: "Literal",
+    _0: {
+      TAG: "NumberLiteral",
+      _0: n
+    }
+  };
+}
+
+function boolLit(b) {
+  return {
+    TAG: "Literal",
+    _0: {
+      TAG: "BooleanLiteral",
+      _0: b
+    }
+  };
+}
+
+function prop(name, type_, requiredOpt, param) {
+  let required = requiredOpt !== undefined ? requiredOpt : true;
+  return [
+    name,
+    type_,
+    required
+  ];
+}
+
+function optProp(name, type_) {
+  return [
+    name,
+    type_,
+    false
+  ];
+}
+
+function named(name, description, type_) {
+  return {
+    name: name,
+    description: description,
+    type_: type_
+  };
+}
+
+let bool = "Boolean";
+
+let $$null = "Null";
+
+let unknown = "Unknown";
+
+let nullLit = {
+  TAG: "Literal",
+  _0: "NullLiteral"
+};
+
+export {
+  Constraints,
+  string$1 as string,
+  number$1 as number,
+  int,
+  bool,
+  $$null,
+  unknown,
+  array$1 as array,
+  object_,
+  union,
+  intersection,
+  ref,
+  option,
+  stringLit,
+  numberLit,
+  boolLit,
+  nullLit,
+  prop,
+  optProp,
+  named,
+}
+/* No side effect */

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.d.ts

@@ -0,0 +1,6 @@
+import type { fileToWrite as FileSystem_fileToWrite } from './FileSystem';
+import type { warning as Types_warning } from '../../src/Types';
+export type t = {
+    readonly files: FileSystem_fileToWrite[];
+    readonly warnings: Types_warning[];
+};

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 JsConvertCase from "js-convert-case";
+
+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 = JsConvertCase.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 = JsConvertCase.toPascalCase(schemaName);
+  if (insideComponentSchemas) {
+    return moduleName + `.schema`;
+  } else {
+    return modulePrefix + `ComponentSchemas.` + moduleName + `.schema`;
+  }
+}
+
+export {
+  refToTypePath,
+  refToSchemaPath,
+}
+/* js-convert-case Not a pure module */