@eventcatalog/cli 0.5.3 → 0.5.5

package/dist/cli/index.mjs

@@ -1235,7 +1235,10 @@ var snapshotList = async (opts) => {
 // src/cli/governance/rules.ts
 import fs from "fs";
 import path2 from "path";
+import { createHash } from "crypto";
 import yaml from "js-yaml";
+import { satisfies, validRange } from "semver";
+import createSDK6 from "@eventcatalog/sdk";
 var loadGovernanceConfig = (catalogDir) => {
   const yamlPath = path2.join(catalogDir, "governance.yaml");
   const ymlPath = path2.join(catalogDir, "governance.yml");
@@ -1245,7 +1248,15 @@ var loadGovernanceConfig = (catalogDir) => {
   }
   const content = fs.readFileSync(configPath, "utf-8");
   const parsed = yaml.load(content);
-  return { rules: parsed?.rules || [] };
+  const rules = parsed?.rules || [];
+  for (const rule of rules) {
+    for (const action of rule.actions) {
+      if (action.type === "fail" && action.message !== void 0 && typeof action.message !== "string") {
+        throw new Error(`Invalid "message" in fail action for rule "${rule.name}". Must be a string.`);
+      }
+    }
+  }
+  return { rules };
 };
 var TRIGGER_FILTERS = {
   consumer_added: (c2) => c2.direction === "receives" && c2.changeType === "added",
@@ -1293,15 +1304,16 @@ var buildMessageMap = (snapshot2) => {
   for (const msg of snapshot2.resources.messages.queries) map.set(msg.id, msg);
   return map;
 };
-var buildProducerIndex = (snapshot2) => {
+var buildServiceIndex = (snapshot2, direction) => {
   const index = /* @__PURE__ */ new Map();
   for (const service of snapshot2.resources.services) {
-    if (!service.sends) continue;
-    for (const s of service.sends) {
-      let producers = index.get(s.id);
-      if (!producers) {
-        producers = [];
-        index.set(s.id, producers);
+    const pointers = service[direction];
+    if (!pointers) continue;
+    for (const pointer of pointers) {
+      let entries = index.get(pointer.id);
+      if (!entries) {
+        entries = [];
+        index.set(pointer.id, entries);
       }
       const entry = {
         id: service.id,
@@ -1310,17 +1322,85 @@ var buildProducerIndex = (snapshot2) => {
       if (service.owners && Array.isArray(service.owners) && service.owners.length > 0) {
         entry.owners = service.owners;
       }
-      producers.push(entry);
+      entries.push(entry);
     }
   }
   return index;
 };
+var getMessageTypeKey = (resourceId, type) => `${type}:${resourceId}`;
+var buildLatestMessageVersionMap = (snapshot2) => {
+  const versions = /* @__PURE__ */ new Map();
+  for (const event of snapshot2.resources.messages.events) {
+    versions.set(getMessageTypeKey(event.id, "event"), event.version);
+  }
+  for (const command of snapshot2.resources.messages.commands) {
+    versions.set(getMessageTypeKey(command.id, "command"), command.version);
+  }
+  for (const query of snapshot2.resources.messages.queries) {
+    versions.set(getMessageTypeKey(query.id, "query"), query.version);
+  }
+  return versions;
+};
+var getTargetMessageVersion = (resourceChange) => {
+  if (resourceChange.changeType === "versioned") {
+    return resourceChange.newVersion || resourceChange.version;
+  }
+  return resourceChange.version;
+};
+var pointerTargetsChangedVersion = (pointer, resourceChange, latestMessageVersions) => {
+  if (pointer.id !== resourceChange.resourceId) return false;
+  const targetVersion = getTargetMessageVersion(resourceChange);
+  const pointerVersion = pointer.version;
+  if (!pointerVersion || pointerVersion === "latest") {
+    const latestVersion = latestMessageVersions.get(getMessageTypeKey(resourceChange.resourceId, resourceChange.type));
+    if (!latestVersion) return true;
+    return latestVersion === targetVersion;
+  }
+  if (validRange(pointerVersion)) {
+    try {
+      return satisfies(targetVersion, pointerVersion);
+    } catch {
+      return false;
+    }
+  }
+  return pointerVersion === targetVersion;
+};
+var getServicesForSchemaChange = (snapshot2, direction, resourceChange, latestMessageVersions) => {
+  const matches = [];
+  for (const service of snapshot2.resources.services) {
+    const pointers = service[direction];
+    if (!pointers) continue;
+    const hasMatch = pointers.some((pointer) => pointerTargetsChangedVersion(pointer, resourceChange, latestMessageVersions));
+    if (!hasMatch) continue;
+    const entry = {
+      id: service.id,
+      version: service.version
+    };
+    if (service.owners && Array.isArray(service.owners) && service.owners.length > 0) {
+      entry.owners = service.owners;
+    }
+    matches.push(entry);
+  }
+  return matches;
+};
+var matchesSchemaChangeResource = (schemaChange, resources) => {
+  return resources.some((resource) => {
+    if (resource === "*") return true;
+    if (resource.startsWith("message:")) return schemaChange.resourceChange.resourceId === resource.slice(8);
+    if (resource.startsWith("consumes:"))
+      return schemaChange.consumerServices.some((service) => service.id === resource.slice(9));
+    if (resource.startsWith("produces:"))
+      return schemaChange.producerServices.some((service) => service.id === resource.slice(9));
+    if (resource.startsWith("service:")) return schemaChange.producerServices.some((service) => service.id === resource.slice(8));
+    return false;
+  });
+};
 var evaluateDeprecationRules = (diff, config, targetSnapshot, targetMessageSets, baseSnapshot) => {
   const deprecationRules = config.rules.filter((rule) => rule.when.includes("message_deprecated"));
   if (deprecationRules.length === 0) return [];
   const targetMessages = buildMessageMap(targetSnapshot);
   const baseMessages = baseSnapshot ? buildMessageMap(baseSnapshot) : void 0;
-  const producerIndex = buildProducerIndex(targetSnapshot);
+  const producerIndex = buildServiceIndex(targetSnapshot, "sends");
   const deprecatedResources = diff.resources.filter((rc) => {
     if (!MESSAGE_RESOURCE_TYPES.has(rc.type)) return false;
     if (!rc.changedFields?.includes("deprecated")) return false;
@@ -1347,6 +1427,29 @@ var evaluateDeprecationRules = (diff, config, targetSnapshot, targetMessageSets,
   }
   return results;
 };
+var evaluateSchemaChangeRules = (diff, config, targetSnapshot) => {
+  const schemaRules = config.rules.filter((rule) => rule.when.includes("schema_changed"));
+  if (schemaRules.length === 0) return [];
+  const schemaChangedResources = diff.resources.filter((rc) => {
+    if (!MESSAGE_RESOURCE_TYPES.has(rc.type)) return false;
+    return rc.changedFields?.includes("schemaHash");
+  });
+  if (schemaChangedResources.length === 0) return [];
+  const latestMessageVersions = buildLatestMessageVersionMap(targetSnapshot);
+  const schemaChanges = schemaChangedResources.map((resourceChange) => ({
+    resourceChange,
+    producerServices: getServicesForSchemaChange(targetSnapshot, "sends", resourceChange, latestMessageVersions),
+    consumerServices: getServicesForSchemaChange(targetSnapshot, "receives", resourceChange, latestMessageVersions)
+  }));
+  const results = [];
+  for (const rule of schemaRules) {
+    const matched = schemaChanges.filter((schemaChange) => matchesSchemaChangeResource(schemaChange, rule.resources));
+    if (matched.length > 0) {
+      results.push({ rule, trigger: "schema_changed", matchedChanges: [], schemaChanges: matched });
+    }
+  }
+  return results;
+};
 var evaluateGovernanceRules = (diff, config, targetSnapshot, baseSnapshot) => {
   const results = [];
   const targetMessageSets = targetSnapshot ? buildServiceMessageSets(targetSnapshot) : void 0;
@@ -1366,6 +1469,7 @@ var evaluateGovernanceRules = (diff, config, targetSnapshot, baseSnapshot) => {
   }
   if (targetSnapshot && targetMessageSets) {
     results.push(...evaluateDeprecationRules(diff, config, targetSnapshot, targetMessageSets, baseSnapshot));
+    results.push(...evaluateSchemaChangeRules(diff, config, targetSnapshot));
   }
   return results;
 };
@@ -1384,6 +1488,48 @@ var resolveEnvVars = (value) => {
     return envValue;
   });
 };
+var readSchemaDetails = async (sdk, resourceId, version2, type) => {
+  if (!MESSAGE_RESOURCE_TYPES.has(type)) return {};
+  try {
+    const schema = await sdk.getSchemaForMessage(resourceId, version2);
+    if (!schema) return {};
+    return {
+      content: schema.schema,
+      schemaPath: schema.fileName,
+      schemaHash: createHash("sha256").update(schema.schema).digest("hex")
+    };
+  } catch {
+    return {};
+  }
+};
+var enrichSchemaContent = async (results, baseCatalogDir, targetCatalogDir) => {
+  const baseSDK = createSDK6(baseCatalogDir);
+  const targetSDK = createSDK6(targetCatalogDir);
+  const promises = [];
+  for (const result of results) {
+    if (!result.schemaChanges) continue;
+    for (const sc of result.schemaChanges) {
+      const { resourceId, version: version2, type, changeType, previousVersion, newVersion } = sc.resourceChange;
+      const baseVersion = changeType === "versioned" ? previousVersion || version2 : version2;
+      const targetVersion = changeType === "versioned" ? newVersion || version2 : version2;
+      promises.push(
+        (async () => {
+          const [before, after] = await Promise.all([
+            readSchemaDetails(baseSDK, resourceId, baseVersion, type),
+            readSchemaDetails(targetSDK, resourceId, targetVersion, type)
+          ]);
+          sc.before = before.content;
+          sc.after = after.content;
+          sc.beforeSchemaPath = before.schemaPath;
+          sc.afterSchemaPath = after.schemaPath;
+          sc.beforeSchemaHash = before.schemaHash;
+          sc.afterSchemaHash = after.schemaHash;
+        })()
+      );
+    }
+  }
+  await Promise.all(promises);
+};
 
 // src/cli/governance/actions.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -1410,7 +1556,7 @@ var buildServiceOwnersMap = (snapshot2) => {
   return map;
 };
 var executeGovernanceActions = async (results, opts = {}) => {
-  const { messageTypes, status, serviceOwners } = opts;
+  const { messageTypes, status, serviceOwners, baseRef, targetRef } = opts;
   const webhookCalls = [];
   const now = (/* @__PURE__ */ new Date()).toISOString();
   for (const result of results) {
@@ -1423,6 +1569,46 @@ var executeGovernanceActions = async (results, opts = {}) => {
           headers[key] = resolveEnvVars(value);
         }
       }
+      if (result.schemaChanges && result.schemaChanges.length > 0) {
+        for (const sc of result.schemaChanges) {
+          const messageType = messageTypes?.get(sc.resourceChange.resourceId) || "message";
+          const payload = {
+            specversion: "1.0",
+            type: "eventcatalog.governance.schema_changed",
+            source: "eventcatalog/governance",
+            id: randomUUID2(),
+            time: now,
+            datacontenttype: "application/json",
+            data: {
+              schemaVersion: 1,
+              ...status && { status },
+              summary: `Schema changed for ${messageType} ${sc.resourceChange.resourceId}`,
+              message: {
+                id: sc.resourceChange.resourceId,
+                version: sc.resourceChange.version,
+                type: messageType
+              },
+              schema: {
+                beforeHash: sc.beforeSchemaHash ?? null,
+                afterHash: sc.afterSchemaHash ?? null,
+                beforePath: sc.beforeSchemaPath ?? null,
+                afterPath: sc.afterSchemaPath ?? null
+              },
+              refs: {
+                base: baseRef ?? null,
+                target: targetRef ?? null
+              },
+              consumers: sc.consumerServices,
+              producers: sc.producerServices
+            }
+          };
+          webhookCalls.push({
+            urlTemplate: action.url,
+            request: fetch(url, { method: "POST", headers, body: JSON.stringify(payload) })
+          });
+        }
+        continue;
+      }
       if (result.deprecationChanges && result.deprecationChanges.length > 0) {
         for (const dc of result.deprecationChanges) {
           const messageType = messageTypes?.get(dc.resourceChange.resourceId) || "message";
@@ -1515,7 +1701,14 @@ var formatGovernanceOutput = (results) => {
   const lines = ["Governance:", ""];
   for (const result of results) {
     lines.push(`  Rule "${result.rule.name}" triggered (${result.trigger}):`);
-    if (result.deprecationChanges && result.deprecationChanges.length > 0) {
+    if (result.schemaChanges && result.schemaChanges.length > 0) {
+      for (const sc of result.schemaChanges) {
+        const consumers = sc.consumerServices.length > 0 ? sc.consumerServices.map((c2) => c2.id).join(", ") : "no known consumers";
+        lines.push(
+          `    ! Schema changed for ${sc.resourceChange.resourceId} (${sc.resourceChange.type}) \u2014 consumers: ${consumers}`
+        );
+      }
+    } else if (result.deprecationChanges && result.deprecationChanges.length > 0) {
       for (const dc of result.deprecationChanges) {
         const producers = dc.producerServices.length > 0 ? dc.producerServices.map((p) => p.id).join(", ") : "unknown producer";
         lines.push(`    ! ${dc.resourceChange.resourceId} (${dc.resourceChange.type}) deprecated by ${producers}`);
@@ -1531,6 +1724,17 @@ var formatGovernanceOutput = (results) => {
   }
   return lines.join("\n");
 };
+var formatFailureOutput = (failures) => {
+  if (failures.length === 0) return "";
+  const lines = [];
+  for (const f of failures) {
+    lines.push(`FAILED: ${f.ruleName}`);
+    for (const msg of f.messages) {
+      lines.push(`  ${msg}`);
+    }
+  }
+  return lines.join("\n");
+};
 
 // src/cli/governance/check.ts
 import path3 from "path";
@@ -1538,7 +1742,7 @@ import { execSync } from "child_process";
 import { mkdtempSync, rmSync as rmSync2 } from "fs";
 import { tmpdir } from "os";
 import dotenv from "dotenv";
-import createSDK6 from "@eventcatalog/sdk";
+import createSDK7 from "@eventcatalog/sdk";
 import { isEventCatalogScaleEnabled } from "@eventcatalog/license";
 var BRANCH_NAME_RE = /^[a-zA-Z0-9._\-/]+$/;
 var extractBranchToTempDir = (branch, catalogDir, tempDirs) => {
@@ -1572,32 +1776,56 @@ var governanceCheck = async (opts) => {
     const baseTmpDir = extractBranchToTempDir(baseBranch, dir, tempDirs);
     const baseSnapshotDir = trackTempDir("ec-snap-base-");
     const targetSnapshotDir = trackTempDir("ec-snap-target-");
-    const baseSDK = createSDK6(baseTmpDir);
+    const baseSDK = createSDK7(baseTmpDir);
     const baseResult = await baseSDK.createSnapshot({ label: `base-${baseBranch}`, outputDir: baseSnapshotDir });
     let targetResult;
+    let targetCatalogDir;
     if (opts.target) {
-      const targetTmpDir = extractBranchToTempDir(opts.target, dir, tempDirs);
-      const targetSDK = createSDK6(targetTmpDir);
+      targetCatalogDir = extractBranchToTempDir(opts.target, dir, tempDirs);
+      const targetSDK = createSDK7(targetCatalogDir);
       targetResult = await targetSDK.createSnapshot({ label: `target-${opts.target}`, outputDir: targetSnapshotDir });
     } else {
-      const targetSDK = createSDK6(dir);
+      targetCatalogDir = dir;
+      const targetSDK = createSDK7(dir);
       targetResult = await targetSDK.createSnapshot({ label: "current", outputDir: targetSnapshotDir });
     }
     const diff = await baseSDK.diffSnapshots(baseResult.filePath, targetResult.filePath);
     const config = loadGovernanceConfig(dir);
     if (config.rules.length === 0) {
-      return "No governance.yaml (or governance.yml) found or no rules defined.";
+      return { output: "No governance.yaml (or governance.yml) found or no rules defined.", exitCode: 0, failures: [] };
     }
     const results = evaluateGovernanceRules(diff, config, targetResult.snapshot, baseResult.snapshot);
+    for (const result of results) {
+      const failActions = result.rule.actions.filter((a) => a.type === "fail");
+      if (failActions.length > 0) {
+        result.failed = true;
+        result.failMessages = failActions.map((a) => "message" in a && a.message ? resolveEnvVars(a.message) : void 0).filter((m) => m !== void 0);
+      }
+    }
+    await enrichSchemaContent(results, baseTmpDir, targetCatalogDir);
     const messageTypes = buildMessageTypeMap(targetResult.snapshot);
     const serviceOwners = buildServiceOwnersMap(targetResult.snapshot);
     const actionOutput = await executeGovernanceActions(results, {
       messageTypes,
       status: opts.status,
-      serviceOwners
+      serviceOwners,
+      baseRef: baseBranch,
+      targetRef: opts.target || "working-directory"
     });
+    const failures = results.filter((r) => r.failed).map((r) => ({ ruleName: r.rule.name, messages: r.failMessages || [] }));
     if (opts.format === "json") {
-      return JSON.stringify({ baseBranch, target: opts.target || "working directory", results, diff: diff.summary }, null, 2);
+      const jsonOutput = {
+        baseBranch,
+        target: opts.target || "working directory",
+        results,
+        summary: {
+          rulesTriggered: results.length,
+          failures: failures.length,
+          passed: failures.length === 0
+        },
+        diff: diff.summary
+      };
+      return { output: JSON.stringify(jsonOutput, null, 2), exitCode: failures.length > 0 ? 1 : 0, failures };
     }
     const targetLabel = opts.target || "working directory";
     const lines = [`Governance check: comparing ${targetLabel} against ${baseBranch}`, ""];
@@ -1613,7 +1841,12 @@ var governanceCheck = async (opts) => {
       lines.push("");
       lines.push(parts.join(", ") + ".");
     }
-    return lines.join("\n");
+    const failureOutput = formatFailureOutput(failures);
+    if (failureOutput) {
+      lines.push("");
+      lines.push(failureOutput);
+    }
+    return { output: lines.join("\n"), exitCode: failures.length > 0 ? 1 : 0, failures };
   } finally {
     for (const d of tempDirs) {
       rmSync2(d, { recursive: true, force: true });
@@ -1739,7 +1972,8 @@ governance.command("check").description("Compare catalog against a base branch a
       status: opts.status,
       dir
     });
-    console.log(result);
+    console.log(result.output);
+    process.exitCode = result.exitCode;
   } catch (error) {
     console.error(error instanceof Error ? error.message : String(error));
     process.exit(1);