@eventcatalog/generator-openapi 7.10.0 → 7.11.1

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2024-2026 EventCatalog Ltd
+
+This software is dual-licensed:
+
+* For open-source projects: licensed under the GNU Affero General Public
+  License v3.0 (AGPL-3.0). See LICENSE-OPENSOURCE.md for the full terms.
+
+* For proprietary, internal, or commercial use: licensed under the EventCatalog
+  Commercial License. See LICENSE-COMMERCIAL.md for the full terms.
+
+If you are using these plugins for internal business purposes and do not wish
+to release your source code under AGPL-3.0, you must obtain a Commercial
+License.
+
+To obtain a Commercial License:
+  - Purchase a subscription at https://www.eventcatalog.dev/pricing
+  - Purchase individual plugins at https://eventcatalog.cloud/
+  - Free 14-day trial at https://eventcatalog.cloud/
+  - Contact us at hello@eventcatalog.dev

package/dist/index.js

@@ -4213,7 +4213,7 @@ var import_node_path = require("path");
 // package.json
 var package_default = {
   name: "@eventcatalog/generator-openapi",
-  version: "7.10.0",
+  version: "7.11.1",
   description: "OpenAPI generator for EventCatalog",
   scripts: {
     build: "tsup",
@@ -4390,6 +4390,65 @@ var mergeSpecifications = (existing, incoming, options) => {
   return merged;
 };
 
+// src/utils/consumers.ts
+var toArray2 = (value) => Array.isArray(value) ? value : [value];
+var matchesWildcard = (operationPath, pattern) => {
+  const regexStr = "^" + pattern.replace(/\*/g, "[^/]+(/[^/]+)*") + "$";
+  return new RegExp(regexStr).test(operationPath);
+};
+var matchesSingleFilter = (operationPath, filter) => {
+  const checks = [];
+  if (filter.path !== void 0) {
+    const paths = toArray2(filter.path);
+    checks.push(paths.some((p) => operationPath === p));
+  }
+  if (filter.prefix !== void 0) {
+    const prefixes = toArray2(filter.prefix);
+    checks.push(prefixes.some((p) => operationPath.startsWith(p)));
+  }
+  if (filter.suffix !== void 0) {
+    const suffixes = toArray2(filter.suffix);
+    checks.push(suffixes.some((s) => operationPath.endsWith(s)));
+  }
+  if (filter.match !== void 0) {
+    const patterns = toArray2(filter.match);
+    checks.push(patterns.some((p) => matchesWildcard(operationPath, p)));
+  }
+  return checks.length > 0 && checks.every(Boolean);
+};
+var filterMessagesByRoutes = (allMessages, routes) => {
+  if (!routes || routes.length === 0) {
+    return allMessages.map(({ id, version }) => ({ id, version }));
+  }
+  const matched = /* @__PURE__ */ new Map();
+  for (const message2 of allMessages) {
+    for (const route of routes) {
+      if (matchesSingleFilter(message2.path, route)) {
+        matched.set(message2.id, { id: message2.id, version: message2.version });
+        break;
+      }
+    }
+  }
+  return Array.from(matched.values());
+};
+var mergeSends = (existing, incoming) => {
+  const merged = /* @__PURE__ */ new Map();
+  for (const entry of existing) {
+    merged.set(entry.id, { ...entry });
+  }
+  for (const entry of incoming) {
+    const current = merged.get(entry.id);
+    if (current) {
+      if (current.version !== void 0) {
+        current.version = entry.version;
+      }
+    } else {
+      merged.set(entry.id, { ...entry });
+    }
+  }
+  return Array.from(merged.values());
+};
+
 // src/index.ts
 var toUniqueArray = (array) => {
   return array.filter((item, index, self) => index === self.findIndex((t) => t.id === item.id && t.version === item.version));
@@ -4542,7 +4601,7 @@ Processing domain: ${domainName} (v${domainVersion})`));
         await versionService(service.id);
         console.log(import_chalk4.default.cyan(` - Versioned previous service (v${latestServiceInCatalog.version})`));
       }
-      let { sends, receives } = await processMessagesForOpenAPISpec(specPath, document2, servicePath, {
+      let { sends, receives, allGeneratedMessages } = await processMessagesForOpenAPISpec(specPath, document2, servicePath, {
         ...options,
         owners: service.setMessageOwnersToServiceOwners ? service.owners : [],
         serviceHasMultipleSpecFiles: Array.isArray(serviceSpec.path),
@@ -4623,6 +4682,52 @@ Processing domain: ${domainName} (v${domainVersion})`));
         );
       }
       console.log(import_chalk4.default.cyan(` - Service (v${version}) created`));
+      const consumers = serviceSpec.consumers || [];
+      for (const consumer of consumers) {
+        const consumerVersion = consumer.version || "1.0.0";
+        const filteredSends = filterMessagesByRoutes(allGeneratedMessages, consumer.routes);
+        const existingConsumer = await getService(consumer.id, consumerVersion);
+        if (existingConsumer) {
+          const mergedSends = mergeSends(existingConsumer.sends || [], filteredSends);
+          const consumerResource = await getResourcePath(process.env.PROJECT_DIR, consumer.id, consumerVersion);
+          const consumerWritePath = consumerResource ? (0, import_node_path.join)("../", consumerResource.directory) : consumer.id;
+          await writeService(
+            {
+              ...existingConsumer,
+              ...mergedSends.length > 0 ? { sends: mergedSends } : {}
+            },
+            { path: consumerWritePath, override: true }
+          );
+        } else {
+          let consumerPath = consumer.id;
+          if (options.domain) {
+            const domainResource = await getResourcePath(
+              process.env.PROJECT_DIR,
+              options.domain.id,
+              options.domain.version
+            );
+            if (domainResource) {
+              consumerPath = (0, import_node_path.join)("../", domainResource.directory, "services", consumer.id);
+            } else {
+              consumerPath = (0, import_node_path.join)("../", "domains", options.domain.id, "services", consumer.id);
+            }
+          }
+          await writeService(
+            {
+              id: consumer.id,
+              version: consumerVersion,
+              name: consumer.id,
+              markdown: "<NodeGraph />",
+              ...filteredSends.length > 0 ? { sends: filteredSends } : {}
+            },
+            { path: consumerPath, override: true }
+          );
+          if (options.domain) {
+            await addServiceToDomain(options.domain.id, { id: consumer.id, version: consumerVersion }, options.domain.version);
+          }
+        }
+        console.log(import_chalk4.default.cyan(` - Consumer service: ${consumer.id} (v${consumerVersion}) processed`));
+      }
     }
   }
 };
@@ -4663,6 +4768,7 @@ var processMessagesForOpenAPISpec = async (pathToSpec, document2, servicePath, o
   const parseExamples = options.parseExamples ?? true;
   const isDraft = options.isDraft ?? null;
   let receives = [], sends = [];
+  let allGeneratedMessages = [];
   for (const operation of operations) {
     const { requestBodiesAndResponses, sidebar, messageName, ...message2 } = await buildMessage(
       pathToSpec,
@@ -4728,6 +4834,11 @@ var processMessagesForOpenAPISpec = async (pathToSpec, document2, servicePath, o
         version: message2.version
       });
     }
+    allGeneratedMessages.push({
+      id: message2.id,
+      version: message2.version,
+      path: operation.path
+    });
     if (requestBodiesAndResponses?.requestBody) {
       await addFileToMessage(
         message2.id,
@@ -4783,7 +4894,7 @@ var processMessagesForOpenAPISpec = async (pathToSpec, document2, servicePath, o
       console.log(import_chalk4.default.yellow(`  - Use operationIds to give better unique names for EventCatalog`));
     }
   }
-  return { receives, sends };
+  return { receives, sends, allGeneratedMessages };
 };
 var getParsedSpecFile = (service, document2) => {
   const specPath = service.path;