@f3liz/rescript-autogen-openapi 0.3.1

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,207 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Pipeline from "../core/Pipeline.mjs";
+import * as Toposort from "../bindings/Toposort.mjs";
+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 JsConvertCase from "js-convert-case";
+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" :
+        return [irType._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 allNodes = schemas.map(s => s.name);
+  let edges = schemas.flatMap(schema => {
+    let references = extractReferencedSchemaNames(schema.type_).filter(name => {
+      if (name in schemaNameMap) {
+        return name !== schema.name;
+      } else {
+        return false;
+      }
+    });
+    return references.map(dep => [
+      schema.name,
+      dep
+    ]);
+  });
+  let sortedNames;
+  try {
+    sortedNames = Toposort.sortArray(allNodes, edges).toReversed();
+  } catch (exn) {
+    let visited = {};
+    let inStack = {};
+    let cycleEdges = [];
+    let dfs = node => {
+      if (Stdlib_Option.getOr(inStack[node], false) || Stdlib_Option.getOr(visited[node], false)) {
+        return;
+      } else {
+        visited[node] = true;
+        inStack[node] = true;
+        edges.forEach(param => {
+          let from = param[0];
+          if (from !== node) {
+            return;
+          }
+          let to = param[1];
+          if (Stdlib_Option.getOr(inStack[to], false)) {
+            cycleEdges.push([
+              from,
+              to
+            ]);
+            return;
+          } else {
+            return dfs(to);
+          }
+        });
+        inStack[node] = false;
+        return;
+      }
+    };
+    allNodes.forEach(dfs);
+    let nonCycleEdges = edges.filter(param => {
+      let to = param[1];
+      let from = param[0];
+      return !cycleEdges.some(param => {
+        if (param[0] === from) {
+          return param[1] === to;
+        } else {
+          return false;
+        }
+      });
+    });
+    try {
+      sortedNames = Toposort.sortArray(allNodes, nonCycleEdges).toReversed();
+    } catch (exn$1) {
+      sortedNames = allNodes.toSorted(Primitive_string.compare);
+    }
+  }
+  let finalSortedSchemas = Stdlib_Array.filterMap(sortedNames, name => schemaNameMap[name]);
+  let availableSchemaNames = finalSortedSchemas.map(s => s.name);
+  let warnings = match[1].slice();
+  let selfRefSchemas = {};
+  finalSortedSchemas.forEach(schema => {
+    let refs = extractReferencedSchemaNames(schema.type_);
+    if (refs.some(name => name === schema.name)) {
+      selfRefSchemas[schema.name] = true;
+      return;
+    }
+  });
+  let moduleCodes = finalSortedSchemas.map(schema => {
+    let isSelfRef = Stdlib_Option.getOr(selfRefSchemas[schema.name], false);
+    let selfRefName = isSelfRef ? schema.name : undefined;
+    let typeCtx = GenerationContext.make(`ComponentSchemas.` + schema.name, true, availableSchemaNames, undefined, selfRefName, undefined);
+    let typeCode = IRToTypeGenerator.generateTypeWithContext(typeCtx, 0, undefined, schema.type_);
+    let processed = 0;
+    while (processed < typeCtx.extractedTypes.length) {
+      let idx = processed;
+      let match = typeCtx.extractedTypes[idx];
+      let irType = match.irType;
+      if (match.isUnboxed && typeof irType === "object" && irType.TAG === "Union") {
+        irType._0.forEach(memberType => {
+          IRToTypeGenerator.generateTypeWithContext(typeCtx, 0, true, memberType);
+        });
+      } else {
+        IRToTypeGenerator.generateTypeWithContext(typeCtx, 0, false, irType);
+      }
+      processed = idx + 1 | 0;
+    };
+    let allExtracted = typeCtx.extractedTypes.slice().toReversed();
+    let extractedTypeMap = allExtracted.length !== 0 ? allExtracted : undefined;
+    let schemaCtx = GenerationContext.make(`ComponentSchemas.` + schema.name, true, availableSchemaNames, undefined, selfRefName, undefined);
+    let schemaCode = IRToSuryGenerator.generateSchemaWithContext(schemaCtx, 0, extractedTypeMap, schema.type_);
+    warnings.push(...typeCtx.warnings);
+    warnings.push(...schemaCtx.warnings);
+    let extractedTypeDefs = allExtracted.map(param => {
+      let irType = param.irType;
+      let typeName = param.typeName;
+      let auxTypeCode;
+      if (param.isUnboxed) {
+        let exit = 0;
+        if (typeof irType !== "object" || irType.TAG !== "Union") {
+          exit = 1;
+        } else {
+          let body = IRToTypeGenerator.generateUnboxedVariantBody(typeCtx, irType._0);
+          auxTypeCode = `@unboxed type ` + typeName + ` = ` + body;
+        }
+        if (exit === 1) {
+          let auxType = IRToTypeGenerator.generateTypeWithContext(typeCtx, 0, undefined, irType);
+          auxTypeCode = `type ` + typeName + ` = ` + auxType;
+        }
+      } else {
+        let auxType$1 = IRToTypeGenerator.generateTypeWithContext(typeCtx, 0, undefined, irType);
+        auxTypeCode = `type ` + typeName + ` = ` + auxType$1;
+      }
+      let auxSchemaCtx = GenerationContext.make(`ComponentSchemas.` + schema.name + `.` + typeName, true, availableSchemaNames, undefined, undefined, undefined);
+      let filteredMap = allExtracted.filter(param => param.typeName !== typeName);
+      let auxExtractedTypeMap = filteredMap.length !== 0 ? filteredMap : undefined;
+      let auxSchema = IRToSuryGenerator.generateSchemaWithContext(auxSchemaCtx, 0, auxExtractedTypeMap, irType);
+      return `  ` + auxTypeCode + `\n  let ` + typeName + `Schema = ` + auxSchema;
+    });
+    let docComment = Stdlib_Option.mapOr(schema.description, "", d => CodegenUtils.generateDocString(undefined, d, undefined));
+    let extractedBlock = extractedTypeDefs.length !== 0 ? extractedTypeDefs.join("\n") + "\n" : "";
+    let typeKeyword = isSelfRef ? "type rec t" : "type t";
+    let finalSchemaCode = isSelfRef ? `S.recursive("` + schema.name + `", schema => ` + schemaCode + `)` : schemaCode;
+    return docComment + `module ` + JsConvertCase.toPascalCase(schema.name) + ` = {
+` + extractedBlock + `  ` + typeKeyword + ` = ` + typeCode + `
+  let schema = ` + finalSchemaCode + `
+}`;
+  });
+  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,
+}
+/* Toposort Not a pure module */

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

@@ -0,0 +1,155 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as SpecDiffer from "../core/SpecDiffer.mjs";
+import * as CodegenUtils from "../core/CodegenUtils.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+
+function formatEndpointName(endpoint) {
+  let methodPart = endpoint.method.toUpperCase();
+  let operationIdPart = Stdlib_Option.mapOr(endpoint.operationId, "", id => ` (` + id + `)`);
+  return methodPart + ` ` + endpoint.path + operationIdPart;
+}
+
+function formatTags(tags) {
+  return Stdlib_Option.mapOr(tags, "", tagList => {
+    if (tagList.length === 0) {
+      return "";
+    } else {
+      return ` [` + tagList.join(", ") + `]`;
+    }
+  });
+}
+
+function generateMarkdownReport(diff, baseName, forkName) {
+  let generateSection = (title, items, formatter) => {
+    if (items.length === 0) {
+      return "";
+    } else {
+      return `\n### ` + title + `\n\n` + items.map(formatter).join("\n") + `\n`;
+    }
+  };
+  let totalChanges = SpecDiffer.countChanges(diff);
+  let breakingChangesText = SpecDiffer.hasBreakingChanges(diff) ? "⚠️ Yes" : "✓ No";
+  let summaryLines = [
+    `- **Total Changes**: ` + totalChanges.toString(),
+    `- **Added Endpoints**: ` + diff.addedEndpoints.length.toString(),
+    `- **Removed Endpoints**: ` + diff.removedEndpoints.length.toString(),
+    `- **Modified Endpoints**: ` + diff.modifiedEndpoints.length.toString(),
+    `- **Added Schemas**: ` + diff.addedSchemas.length.toString(),
+    `- **Removed Schemas**: ` + diff.removedSchemas.length.toString(),
+    `- **Modified Schemas**: ` + diff.modifiedSchemas.length.toString(),
+    `- **Breaking Changes**: ` + breakingChangesText
+  ].join("\n");
+  let reportParts = [
+    `# API Diff Report: ` + baseName + ` → ` + forkName + `\n\n## Summary\n\n` + summaryLines,
+    generateSection("Added Endpoints", diff.addedEndpoints, endpoint => {
+      let endpointName = formatEndpointName(endpoint);
+      let tags = formatTags(endpoint.tags);
+      let summary = Stdlib_Option.mapOr(endpoint.summary, "", summary => `\n  ` + summary);
+      return `- **` + endpointName + `**` + tags + summary;
+    }),
+    generateSection("Removed Endpoints", diff.removedEndpoints, endpoint => {
+      let endpointName = formatEndpointName(endpoint);
+      let tags = formatTags(endpoint.tags);
+      return `- **` + endpointName + `**` + tags;
+    }),
+    generateSection("Modified Endpoints", diff.modifiedEndpoints, endpointDiff => {
+      let methodPart = endpointDiff.method.toUpperCase();
+      let breakingText = endpointDiff.breakingChange ? " **⚠️ BREAKING**" : "";
+      let changes = [
+        endpointDiff.requestBodyChanged ? "body" : "",
+        endpointDiff.responseChanged ? "response" : ""
+      ].filter(x => x !== "").join(", ");
+      return `- **` + methodPart + ` ` + endpointDiff.path + `**` + breakingText + `: Changed ` + changes;
+    }),
+    generateSection("Added Schemas", diff.addedSchemas, schemaName => `- \`` + schemaName + `\``),
+    generateSection("Removed Schemas", diff.removedSchemas, schemaName => `- \`` + schemaName + `\``),
+    generateSection("Modified Schemas", diff.modifiedSchemas, schemaDiff => {
+      let breakingText = schemaDiff.breakingChange ? " **⚠️ BREAKING**" : "";
+      return `- \`` + schemaDiff.name + `\`` + breakingText;
+    }),
+    `\n---\n*Generated on ` + new Date().toISOString() + `*`
+  ];
+  return reportParts.filter(part => part !== "").join("\n");
+}
+
+function generateCompactSummary(diff) {
+  let totalChanges = SpecDiffer.countChanges(diff);
+  let addedCount = diff.addedEndpoints.length;
+  let removedCount = diff.removedEndpoints.length;
+  let modifiedCount = diff.modifiedEndpoints.length;
+  let breakingText = SpecDiffer.hasBreakingChanges(diff) ? " (BREAKING)" : "";
+  return `Found ` + totalChanges.toString() + ` changes: +` + addedCount.toString() + ` -` + removedCount.toString() + ` ~` + modifiedCount.toString() + ` endpoints` + breakingText;
+}
+
+function generateMergeReport(stats, baseName, forkName) {
+  let sharedEndpoints = stats.sharedEndpointCount.toString();
+  let sharedSchemas = stats.sharedSchemaCount.toString();
+  let extensionEndpoints = stats.forkExtensionCount.toString();
+  let extensionSchemas = stats.forkSchemaCount.toString();
+  return CodegenUtils.trimMargin(`
+    |# Merge Report: ` + baseName + ` + ` + forkName + `
+    |
+    |## Shared Code
+    |
+    |- **Shared Endpoints**: ` + sharedEndpoints + `
+    |- **Shared Schemas**: ` + sharedSchemas + `
+    |
+    |## ` + forkName + ` Extensions
+    |
+    |- **Extension Endpoints**: ` + extensionEndpoints + `
+    |- **Extension Schemas**: ` + extensionSchemas + `
+    |
+    |## Summary
+    |
+    |The shared base contains ` + sharedEndpoints + ` endpoints and ` + sharedSchemas + ` schemas.
+    |
+    |` + forkName + ` adds ` + extensionEndpoints + ` endpoints and ` + extensionSchemas + ` schemas.
+    |
+    |---
+    |*Generated on ` + new Date().toISOString() + `*
+    |`, undefined);
+}
+
+function generateEndpointsByTagReport(endpoints) {
+  let endpointsByTag = {};
+  let untaggedEndpoints = [];
+  endpoints.forEach(endpoint => {
+    let tags = endpoint.tags;
+    if (tags !== undefined && tags.length !== 0) {
+      tags.forEach(tag => {
+        let existing = Stdlib_Option.getOr(endpointsByTag[tag], []);
+        existing.push(endpoint);
+        endpointsByTag[tag] = existing;
+      });
+    } else {
+      untaggedEndpoints.push(endpoint);
+    }
+  });
+  let tagSections = Object.keys(endpointsByTag).toSorted(Primitive_string.compare).map(tag => {
+    let tagEndpoints = Stdlib_Option.getOr(endpointsByTag[tag], []);
+    let count = tagEndpoints.length.toString();
+    let endpointList = tagEndpoints.map(endpoint => `- ` + formatEndpointName(endpoint)).join("\n");
+    return `### ` + tag + ` (` + count + `)\n\n` + endpointList;
+  }).join("\n\n");
+  let untaggedSection;
+  if (untaggedEndpoints.length !== 0) {
+    let count = untaggedEndpoints.length.toString();
+    let endpointList = untaggedEndpoints.map(endpoint => `- ` + formatEndpointName(endpoint)).join("\n");
+    untaggedSection = `\n\n### Untagged (` + count + `)\n\n` + endpointList;
+  } else {
+    untaggedSection = "";
+  }
+  return `## Endpoints by Tag\n\n` + tagSections + untaggedSection;
+}
+
+export {
+  formatEndpointName,
+  formatTags,
+  generateMarkdownReport,
+  generateCompactSummary,
+  generateMergeReport,
+  generateEndpointsByTagReport,
+}
+/* CodegenUtils Not a pure module */