@f3liz/rescript-autogen-openapi 0.1.0

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.difference(baseKeys)), key => forkMap[key]);
+  let removed = Stdlib_Array.filterMap(Array.from(baseKeys.difference(forkKeys)), key => baseMap[key]);
+  let modified = Stdlib_Array.filterMap(Array.from(baseKeys.intersection(forkKeys)), 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.difference(baseKeys));
+  let removed = Array.from(baseKeys.difference(forkKeys));
+  let modified = Stdlib_Array.filterMap(Array.from(baseKeys.intersection(forkKeys)), 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 */

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

@@ -0,0 +1,237 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as SpecDiffer from "./SpecDiffer.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+function makeEndpointKey(endpoint) {
+  return endpoint.method + `:` + endpoint.path;
+}
+
+function extractSharedEndpoints(baseEndpoints, _forkEndpoints) {
+  return baseEndpoints;
+}
+
+function extractForkExtensions(baseEndpoints, forkEndpoints) {
+  let baseMap = {};
+  baseEndpoints.forEach(ep => {
+    let key = makeEndpointKey(ep);
+    baseMap[key] = ep;
+  });
+  return forkEndpoints.filter(forkEp => {
+    let key = makeEndpointKey(forkEp);
+    let baseEp = baseMap[key];
+    if (baseEp !== undefined) {
+      return SpecDiffer.compareEndpoints(baseEp, forkEp) !== undefined;
+    } else {
+      return true;
+    }
+  });
+}
+
+function extractSharedSchemas(baseSchemas, _forkSchemas) {
+  return baseSchemas;
+}
+
+function extractForkSchemas(baseSchemas, forkSchemas) {
+  if (forkSchemas === undefined) {
+    return;
+  }
+  if (baseSchemas === undefined) {
+    return forkSchemas;
+  }
+  let extensions = {};
+  Object.keys(forkSchemas).forEach(name => {
+    let match = baseSchemas[name];
+    let match$1 = forkSchemas[name];
+    if (match !== undefined) {
+      if (match$1 !== undefined && !SpecDiffer.schemasEqual(match, match$1)) {
+        extensions[name] = match$1;
+        return;
+      } else {
+        return;
+      }
+    } else if (match$1 !== undefined) {
+      extensions[name] = match$1;
+      return;
+    } else {
+      return;
+    }
+  });
+  if (Object.keys(extensions).length !== 0) {
+    return extensions;
+  }
+}
+
+function createSpecWithEndpoints(baseSpec, endpoints, schemas) {
+  let pathsDict = {};
+  endpoints.forEach(ep => {
+    let existing = pathsDict[ep.path];
+    let pathItem = existing !== undefined ? existing : ({
+        get: undefined,
+        post: undefined,
+        put: undefined,
+        patch: undefined,
+        delete: undefined,
+        head: undefined,
+        options: undefined,
+        parameters: undefined
+      });
+    let operation_operationId = ep.operationId;
+    let operation_summary = ep.summary;
+    let operation_description = ep.description;
+    let operation_tags = ep.tags;
+    let operation_requestBody = ep.requestBody;
+    let operation_responses = ep.responses;
+    let operation_parameters = ep.parameters;
+    let operation = {
+      operationId: operation_operationId,
+      summary: operation_summary,
+      description: operation_description,
+      tags: operation_tags,
+      requestBody: operation_requestBody,
+      responses: operation_responses,
+      parameters: operation_parameters
+    };
+    let match = ep.method.toLowerCase();
+    let updatedPathItem;
+    switch (match) {
+      case "delete" :
+        updatedPathItem = {
+          get: pathItem.get,
+          post: pathItem.post,
+          put: pathItem.put,
+          patch: pathItem.patch,
+          delete: operation,
+          head: pathItem.head,
+          options: pathItem.options,
+          parameters: pathItem.parameters
+        };
+        break;
+      case "get" :
+        updatedPathItem = {
+          get: operation,
+          post: pathItem.post,
+          put: pathItem.put,
+          patch: pathItem.patch,
+          delete: pathItem.delete,
+          head: pathItem.head,
+          options: pathItem.options,
+          parameters: pathItem.parameters
+        };
+        break;
+      case "patch" :
+        updatedPathItem = {
+          get: pathItem.get,
+          post: pathItem.post,
+          put: pathItem.put,
+          patch: operation,
+          delete: pathItem.delete,
+          head: pathItem.head,
+          options: pathItem.options,
+          parameters: pathItem.parameters
+        };
+        break;
+      case "post" :
+        updatedPathItem = {
+          get: pathItem.get,
+          post: operation,
+          put: pathItem.put,
+          patch: pathItem.patch,
+          delete: pathItem.delete,
+          head: pathItem.head,
+          options: pathItem.options,
+          parameters: pathItem.parameters
+        };
+        break;
+      case "put" :
+        updatedPathItem = {
+          get: pathItem.get,
+          post: pathItem.post,
+          put: operation,
+          patch: pathItem.patch,
+          delete: pathItem.delete,
+          head: pathItem.head,
+          options: pathItem.options,
+          parameters: pathItem.parameters
+        };
+        break;
+      default:
+        updatedPathItem = pathItem;
+    }
+    pathsDict[ep.path] = updatedPathItem;
+  });
+  let match = baseSpec.components;
+  let components = match !== undefined ? (
+      schemas !== undefined ? ({
+          schemas: schemas
+        }) : ({
+          schemas: undefined
+        })
+    ) : (
+      schemas !== undefined ? ({
+          schemas: schemas
+        }) : undefined
+    );
+  return {
+    openapi: baseSpec.openapi,
+    info: baseSpec.info,
+    paths: pathsDict,
+    components: components
+  };
+}
+
+function mergeWithSharedBase(baseSpec, forkSpec, baseEndpoints, forkEndpoints) {
+  let forkExtensions = extractForkExtensions(baseEndpoints, forkEndpoints);
+  let baseSchemas = Stdlib_Option.flatMap(baseSpec.components, c => c.schemas);
+  let forkSchemas = Stdlib_Option.flatMap(forkSpec.components, c => c.schemas);
+  let extensionSchemas = extractForkSchemas(baseSchemas, forkSchemas);
+  let sharedSpec = createSpecWithEndpoints(baseSpec, baseEndpoints, baseSchemas);
+  let extensionsSpec = createSpecWithEndpoints(forkSpec, forkExtensions, extensionSchemas);
+  return [
+    sharedSpec,
+    extensionsSpec
+  ];
+}
+
+function mergeWithSeparate(baseSpec, forkSpec) {
+  return [
+    baseSpec,
+    forkSpec
+  ];
+}
+
+function mergeSpecs(baseSpec, forkSpec, baseEndpoints, forkEndpoints, strategy) {
+  if (strategy === "Separate") {
+    return [
+      baseSpec,
+      forkSpec
+    ];
+  } else {
+    return mergeWithSharedBase(baseSpec, forkSpec, baseEndpoints, forkEndpoints);
+  }
+}
+
+function getMergeStats(baseEndpoints, forkEndpoints, baseSchemas, forkSchemas) {
+  let extensions = extractForkExtensions(baseEndpoints, forkEndpoints);
+  let extensionSchemas = extractForkSchemas(baseSchemas, forkSchemas);
+  return {
+    sharedEndpointCount: baseEndpoints.length,
+    forkExtensionCount: extensions.length,
+    sharedSchemaCount: Stdlib_Option.mapOr(baseSchemas, 0, s => Object.keys(s).length),
+    forkSchemaCount: Stdlib_Option.mapOr(extensionSchemas, 0, s => Object.keys(s).length)
+  };
+}
+
+export {
+  makeEndpointKey,
+  extractSharedEndpoints,
+  extractForkExtensions,
+  extractSharedSchemas,
+  extractForkSchemas,
+  createSpecWithEndpoints,
+  mergeWithSharedBase,
+  mergeWithSeparate,
+  mergeSpecs,
+  getMergeStats,
+}
+/* No side effect */

package/lib/es6/src/generators/ComponentSchemaGenerator.mjs

@@ -0,0 +1,125 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Pipeline from "../core/Pipeline.mjs";
+import * as Text from "@std/text";
+import * as FileSystem from "../core/FileSystem.mjs";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as CodegenUtils from "../core/CodegenUtils.mjs";
+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 SchemaIRParser from "../core/SchemaIRParser.mjs";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as GenerationContext from "../types/GenerationContext.mjs";
+import * as IRToSuryGenerator from "./IRToSuryGenerator.mjs";
+import * as IRToTypeGenerator from "./IRToTypeGenerator.mjs";
+
+function extractReferencedSchemaNames(_irType) {
+  while (true) {
+    let irType = _irType;
+    if (typeof irType !== "object") {
+      return [];
+    }
+    switch (irType.TAG) {
+      case "Array" :
+        _irType = irType.items;
+        continue;
+      case "Object" :
+        return irType.properties.flatMap(param => extractReferencedSchemaNames(param[1]));
+      case "Union" :
+      case "Intersection" :
+        return irType._0.flatMap(extractReferencedSchemaNames);
+      case "Reference" :
+        let parts = irType._0.split("/");
+        return [Stdlib_Option.getOr(parts[parts.length - 1 | 0], "")];
+      case "Option" :
+        _irType = irType._0;
+        continue;
+      default:
+        return [];
+    }
+  };
+}
+
+function generate(spec, outputDir) {
+  let match = Stdlib_Option.mapOr(Stdlib_Option.flatMap(spec.components, components => components.schemas), [
+    {
+      schemas: {}
+    },
+    []
+  ], SchemaIRParser.parseComponentSchemas);
+  let context = match[0];
+  if (Stdlib_Dict.size(context.schemas) === 0) {
+    return Pipeline.empty;
+  }
+  let schemas = Object.values(context.schemas);
+  let schemaNameMap = Object.fromEntries(schemas.map(s => [
+    s.name,
+    s
+  ]));
+  let dependencyMap = Stdlib_Array.reduce(schemas, {}, (acc, schema) => {
+    let references = extractReferencedSchemaNames(schema.type_).filter(name => {
+      if (name in schemaNameMap) {
+        return name !== schema.name;
+      } else {
+        return false;
+      }
+    });
+    acc[schema.name] = references;
+    return acc;
+  });
+  let sortedSchemas = [];
+  let inDegreeMap = Stdlib_Array.reduce(schemas, {}, (acc, schema) => {
+    let degree = Stdlib_Option.mapOr(dependencyMap[schema.name], 0, prim => prim.length);
+    acc[schema.name] = degree;
+    return acc;
+  });
+  let queue = schemas.filter(schema => Stdlib_Option.getOr(inDegreeMap[schema.name], 0) === 0);
+  while (queue.length !== 0) {
+    let v = queue.shift();
+    let schema = v !== undefined ? v : schemas[0];
+    sortedSchemas.push(schema);
+    schemas.forEach(otherSchema => {
+      let dependsOnCurrent = Stdlib_Option.getOr(dependencyMap[otherSchema.name], []).some(name => name === schema.name);
+      if (!dependsOnCurrent) {
+        return;
+      }
+      let currentDegree = Stdlib_Option.getOr(inDegreeMap[otherSchema.name], 0);
+      let newDegree = currentDegree - 1 | 0;
+      inDegreeMap[otherSchema.name] = newDegree;
+      if (newDegree === 0) {
+        queue.push(otherSchema);
+        return;
+      }
+    });
+  };
+  let sortedNames = sortedSchemas.map(s => s.name);
+  let remainingSchemas = schemas.filter(s => !sortedNames.some(name => name === s.name)).toSorted((a, b) => Primitive_string.compare(a.name, b.name));
+  let finalSortedSchemas = sortedSchemas.concat(remainingSchemas);
+  let availableSchemaNames = finalSortedSchemas.map(s => s.name);
+  let warnings = match[1].slice();
+  let moduleCodes = finalSortedSchemas.map(schema => {
+    let typeCtx = GenerationContext.make(`ComponentSchemas.` + schema.name, true, availableSchemaNames, undefined, undefined);
+    let schemaCtx = GenerationContext.make(`ComponentSchemas.` + schema.name, true, availableSchemaNames, undefined, undefined);
+    let typeCode = IRToTypeGenerator.generateTypeWithContext(typeCtx, 0, schema.type_);
+    let schemaCode = IRToSuryGenerator.generateSchemaWithContext(schemaCtx, 0, schema.type_);
+    warnings.push(...typeCtx.warnings);
+    warnings.push(...schemaCtx.warnings);
+    let docComment = Stdlib_Option.mapOr(schema.description, "", d => CodegenUtils.generateDocString(undefined, d, undefined));
+    return docComment + `module ` + Text.toPascalCase(schema.name) + ` = {
+  type t = ` + typeCode + `
+  let schema = ` + schemaCode + `
+}`;
+  });
+  let fileHeader = CodegenUtils.generateFileHeader("Shared component schemas");
+  let fileContent = fileHeader + `\n\n` + moduleCodes.join("\n\n");
+  return Pipeline.fromFilesAndWarnings([{
+      path: FileSystem.makePath(outputDir, "ComponentSchemas.res"),
+      content: fileContent
+    }], warnings);
+}
+
+export {
+  extractReferencedSchemaNames,
+  generate,
+}
+/* @std/text Not a pure module */