@eventcatalog/generator-openapi 7.7.0 → 7.7.2

package/dist/index.mjs

@@ -1528,6 +1528,7 @@ var require_dist2 = __commonJS({
 // src/index.ts
 import utils2 from "@eventcatalog/sdk";
 import { readFile } from "fs/promises";
+import fs2 from "fs/promises";
 import chalk4 from "chalk";
 import SwaggerParser2 from "@apidevtools/swagger-parser";
 
@@ -1574,9 +1575,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 || [],
@@ -4068,7 +4067,7 @@ import { join } from "path";
 // package.json
 var package_default = {
   name: "@eventcatalog/generator-openapi",
-  version: "7.7.0",
+  version: "7.7.2",
   description: "OpenAPI generator for EventCatalog",
   scripts: {
     build: "tsup",
@@ -4105,7 +4104,7 @@ var package_default = {
   dependencies: {
     "@apidevtools/swagger-parser": "^10.1.0",
     "@changesets/cli": "^2.27.7",
-    "@eventcatalog/sdk": "^2.9.6",
+    "@eventcatalog/sdk": "2.12.1",
     chalk: "4.1.2",
     "js-yaml": "^4.1.0",
     "openapi-types": "^12.1.3",
@@ -4177,6 +4176,74 @@ var isVersionLessThan = (version, givenVersion) => {
   return 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));
@@ -4200,13 +4267,6 @@ var fetchAuthenticatedSpec = async (specUrl, headers) => {
     return yaml.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();
@@ -4225,8 +4285,7 @@ var index_default = async (_, options) => {
     getService,
     versionService,
     writeService,
-    addFileToService,
-    getSpecificationFilesForService
+    addFileToService
   } = utils2(process.env.PROJECT_DIR);
   const { services = [], saveParsedSpecFile = false } = options;
   for (const serviceSpec of services) {
@@ -4315,11 +4374,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(chalk4.blue(`Processing service: ${document2.info.title} (v${version})`));
       if (latestServiceInCatalog && isVersionLessThan(version, latestServiceInCatalog.version)) {
@@ -4340,22 +4394,26 @@ Processing domain: ${domainName} (v${domainVersion})`));
       let owners = service.owners || [];
       let repository = null;
       let styles2 = null;
+      let serviceDiagrams = null;
       let serviceWritesTo = configuredWritesTo;
       let serviceReadsFrom = configuredReadsFrom;
       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;
         styles2 = latestServiceInCatalog.styles || null;
         serviceBadges = latestServiceInCatalog.badges || null;
         serviceAttachments = latestServiceInCatalog.attachments || null;
+        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 ? (
@@ -4379,6 +4437,7 @@ Processing domain: ${domainName} (v${domainVersion})`));
           ...owners ? { owners } : {},
           ...repository ? { repository } : {},
           ...styles2 ? { styles: styles2 } : {},
+          ...serviceDiagrams ? { diagrams: serviceDiagrams } : {},
           ...isServiceMarkedAsDraft ? { draft: true } : {},
           ...serviceAttachments ? { attachments: serviceAttachments } : {},
           ...serviceWritesTo.length > 0 ? { writesTo: serviceWritesTo } : {},
@@ -4408,6 +4467,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 = join(process.env.PROJECT_DIR, "services", serviceId, entry.path);
+      try {
+        const content = await fs2.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";