@eventcatalog/generator-openapi 7.7.1 → 7.7.2

package/dist/index.js

@@ -1533,6 +1533,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 var import_sdk2 = __toESM(require("@eventcatalog/sdk"));
 var import_promises = require("fs/promises");
+var import_promises2 = __toESM(require("fs/promises"));
 var import_chalk4 = __toESM(require("chalk"));
 var import_swagger_parser2 = __toESM(require("@apidevtools/swagger-parser"));
 
@@ -1579,9 +1580,7 @@ var buildService = (serviceOptions, document2, generateMarkdown) => {
     name: document2.info.title,
     summary: getSummary(document2),
     schemaPath,
-    specifications: {
-      openapiPath: schemaPath
-    },
+    specifications: [{ type: "openapi", path: schemaPath }],
     markdown: generateMarkdown ? generateMarkdown({ service: serviceOptions, document: document2, markdown: generatedMarkdownForService }) : generatedMarkdownForService,
     badges: documentTags.map((tag2) => ({ content: tag2.name, textColor: "blue", backgroundColor: "blue" })),
     owners: serviceOptions.owners || [],
@@ -4073,7 +4072,7 @@ var import_node_path = require("path");
 // package.json
 var package_default = {
   name: "@eventcatalog/generator-openapi",
-  version: "7.7.1",
+  version: "7.7.2",
   description: "OpenAPI generator for EventCatalog",
   scripts: {
     build: "tsup",
@@ -4182,6 +4181,74 @@ var isVersionLessThan = (version, givenVersion) => {
   return (0, import_semver.satisfies)(version, `<${givenVersion}`);
 };
 
+// src/utils/specifications.ts
+var toArray = (specifications) => {
+  if (!specifications) return [];
+  if (Array.isArray(specifications)) {
+    return specifications.filter((spec) => spec?.type && spec?.path).map((spec) => ({
+      type: spec.type,
+      path: spec.path,
+      ...spec.name ? { name: spec.name } : {},
+      ...spec.headers ? { headers: spec.headers } : {}
+    }));
+  }
+  const output = [];
+  if (specifications.openapiPath) {
+    output.push({ type: "openapi", path: specifications.openapiPath });
+  }
+  if (specifications.asyncapiPath) {
+    output.push({ type: "asyncapi", path: specifications.asyncapiPath });
+  }
+  if (specifications.graphqlPath) {
+    output.push({ type: "graphql", path: specifications.graphqlPath });
+  }
+  return output;
+};
+var dedupe = (specifications) => {
+  const unique = /* @__PURE__ */ new Map();
+  for (const spec of specifications) {
+    const key = `${spec.type}:${spec.path}`;
+    if (!unique.has(key)) {
+      unique.set(key, spec);
+    }
+  }
+  return [...unique.values()];
+};
+var canUseLegacyFormat = (specifications) => {
+  const countByType = {
+    openapi: 0,
+    asyncapi: 0,
+    graphql: 0
+  };
+  for (const spec of specifications) {
+    countByType[spec.type] += 1;
+    if (spec.name || spec.headers) {
+      return false;
+    }
+  }
+  return Object.values(countByType).every((count) => count <= 1);
+};
+var toLegacy = (specifications) => {
+  const legacy = {};
+  for (const spec of specifications) {
+    if (spec.type === "openapi") legacy.openapiPath = spec.path;
+    if (spec.type === "asyncapi") legacy.asyncapiPath = spec.path;
+    if (spec.type === "graphql") legacy.graphqlPath = spec.path;
+  }
+  return legacy;
+};
+var mergeSpecifications = (existing, incoming, options) => {
+  const merged = dedupe([...toArray(existing), ...toArray(incoming)]);
+  if (merged.length === 0) return void 0;
+  if (options?.preferArray) {
+    return merged;
+  }
+  if (canUseLegacyFormat(merged)) {
+    return toLegacy(merged);
+  }
+  return merged;
+};
+
 // src/index.ts
 var toUniqueArray = (array) => {
   return array.filter((item, index, self) => index === self.findIndex((t) => t.id === item.id && t.version === item.version));
@@ -4205,13 +4272,6 @@ var fetchAuthenticatedSpec = async (specUrl, headers) => {
     return import_js_yaml.default.load(content);
   }
 };
-var mergeOpenApiIntoSpecifications = (existingSpecs, openapiFileName) => {
-  if (Array.isArray(existingSpecs)) {
-    return [...existingSpecs.filter((spec) => spec.type !== "openapi"), { type: "openapi", path: openapiFileName }];
-  }
-  const { openapiPath: _, ...rest } = existingSpecs || {};
-  return { openapiPath: openapiFileName, ...rest };
-};
 var index_default = async (_, options) => {
   if (!process.env.PROJECT_DIR) {
     process.env.PROJECT_DIR = process.cwd();
@@ -4230,8 +4290,7 @@ var index_default = async (_, options) => {
     getService,
     versionService,
     writeService,
-    addFileToService,
-    getSpecificationFilesForService
+    addFileToService
   } = (0, import_sdk2.default)(process.env.PROJECT_DIR);
   const { services = [], saveParsedSpecFile = false } = options;
   for (const serviceSpec of services) {
@@ -4320,11 +4379,6 @@ Processing domain: ${domainName} (v${domainVersion})`));
         await addServiceToDomain(domainId, { id: service.id, version: service.version }, domainVersion);
       }
       const latestServiceInCatalog = await getService(service.id, "latest");
-      let latestVersionSpecificationFiles = [];
-      try {
-        latestVersionSpecificationFiles = await getSpecificationFilesForService(service.id, "latest");
-      } catch (error) {
-      }
       const versionTheService = latestServiceInCatalog && isVersionGreaterThan(version, latestServiceInCatalog.version);
       console.log(import_chalk4.default.blue(`Processing service: ${document2.info.title} (v${version})`));
       if (latestServiceInCatalog && isVersionLessThan(version, latestServiceInCatalog.version)) {
@@ -4351,7 +4405,7 @@ Processing domain: ${domainName} (v${domainVersion})`));
       const persistPreviousSpecificationFiles = Array.isArray(serviceSpec.path) === false;
       if (latestServiceInCatalog) {
         serviceMarkdown = latestServiceInCatalog.markdown;
-        serviceSpecificationsFiles = latestVersionSpecificationFiles;
+        serviceSpecificationsFiles = await getExistingSpecificationFiles(service.id, latestServiceInCatalog.specifications);
         sends = latestServiceInCatalog.sends || [];
         owners = latestServiceInCatalog.owners || [];
         repository = latestServiceInCatalog.repository || null;
@@ -4361,8 +4415,10 @@ Processing domain: ${domainName} (v${domainVersion})`));
         serviceDiagrams = latestServiceInCatalog.diagrams || null;
         serviceWritesTo = latestServiceInCatalog.writesTo || [];
         serviceReadsFrom = latestServiceInCatalog.readsFrom || [];
-        if (persistPreviousSpecificationFiles && latestServiceInCatalog.specifications) {
-          serviceSpecifications = mergeOpenApiIntoSpecifications(latestServiceInCatalog.specifications, service.schemaPath);
+        if (persistPreviousSpecificationFiles) {
+          serviceSpecifications = mergeSpecifications(latestServiceInCatalog.specifications, serviceSpecifications, {
+            preferArray: true
+          });
         }
         if (latestServiceInCatalog.version === version) {
           receives = latestServiceInCatalog.receives ? (
@@ -4416,6 +4472,35 @@ Processing domain: ${domainName} (v${domainVersion})`));
     }
   }
 };
+var toSpecificationEntries = (specifications) => {
+  if (!specifications) return [];
+  if (Array.isArray(specifications)) {
+    return specifications.filter((spec) => Boolean(spec?.type && spec?.path));
+  }
+  const entries = [];
+  if (specifications.openapiPath) entries.push({ type: "openapi", path: specifications.openapiPath });
+  if (specifications.asyncapiPath) entries.push({ type: "asyncapi", path: specifications.asyncapiPath });
+  if (specifications.graphqlPath) entries.push({ type: "graphql", path: specifications.graphqlPath });
+  return entries;
+};
+var getExistingSpecificationFiles = async (serviceId, specifications) => {
+  const entries = toSpecificationEntries(specifications);
+  const uniqueEntries = entries.filter(
+    (entry, index, all) => all.findIndex((candidate) => candidate.path === entry.path) === index
+  );
+  const files = await Promise.all(
+    uniqueEntries.map(async (entry) => {
+      const filePath = (0, import_node_path.join)(process.env.PROJECT_DIR, "services", serviceId, entry.path);
+      try {
+        const content = await import_promises2.default.readFile(filePath, "utf8");
+        return { fileName: entry.path, content };
+      } catch (error) {
+        return void 0;
+      }
+    })
+  );
+  return files.filter(Boolean);
+};
 var processMessagesForOpenAPISpec = async (pathToSpec, document2, servicePath, options) => {
   const operations = await getOperationsByType(pathToSpec, options.httpMethodsToMessages, document2);
   const sidebarBadgeType = options.sidebarBadgeType || "HTTP_METHOD";