@eventcatalog/cli 0.5.11 → 0.6.1

package/dist/cli/index.mjs

@@ -1239,6 +1239,7 @@ import { createHash } from "crypto";
 import yaml from "js-yaml";
 import { satisfies, validRange } from "semver";
 import createSDK6 from "@eventcatalog/sdk";
+import { detectBreakingChanges } from "@eventcatalog/breaking-changes";
 var loadGovernanceConfig = (catalogDir) => {
   const yamlPath = path2.join(catalogDir, "governance.yaml");
   const ymlPath = path2.join(catalogDir, "governance.yml");
@@ -1256,7 +1257,18 @@ var loadGovernanceConfig = (catalogDir) => {
       }
     }
   }
-  return { rules };
+  if (parsed?.compatibility?.strategy) {
+    const validStrategies = /* @__PURE__ */ new Set(["BACKWARD", "FORWARD", "FULL", "NONE"]);
+    if (!validStrategies.has(parsed.compatibility.strategy)) {
+      throw new Error(
+        `Invalid compatibility strategy "${parsed.compatibility.strategy}". Must be one of: BACKWARD, FORWARD, FULL, NONE.`
+      );
+    }
+  }
+  return {
+    ...parsed?.compatibility && { compatibility: parsed.compatibility },
+    rules
+  };
 };
 var TRIGGER_FILTERS = {
   consumer_added: (c2) => c2.direction === "receives" && c2.changeType === "added",
@@ -1450,6 +1462,32 @@ var evaluateSchemaChangeRules = (diff, config, targetSnapshot) => {
   }
   return results;
 };
+var evaluateBreakingSchemaChangeRules = (diff, config, targetSnapshot) => {
+  const breakingRules = config.rules.filter((rule) => rule.when.includes("schema_breaking_change"));
+  if (breakingRules.length === 0) return [];
+  const strategy = config.compatibility?.strategy;
+  if (!strategy || strategy === "NONE") 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 breakingSchemaChanges = schemaChangedResources.map((resourceChange) => ({
+    resourceChange,
+    producerServices: getServicesForSchemaChange(targetSnapshot, "sends", resourceChange, latestMessageVersions),
+    consumerServices: getServicesForSchemaChange(targetSnapshot, "receives", resourceChange, latestMessageVersions),
+    breakingChanges: []
+  }));
+  const results = [];
+  for (const rule of breakingRules) {
+    const matched = breakingSchemaChanges.filter((sc) => matchesSchemaChangeResource(sc, rule.resources));
+    if (matched.length > 0) {
+      results.push({ rule, trigger: "schema_breaking_change", matchedChanges: [], breakingSchemaChanges: matched });
+    }
+  }
+  return results;
+};
 var evaluateGovernanceRules = (diff, config, targetSnapshot, baseSnapshot) => {
   const results = [];
   const targetMessageSets = targetSnapshot ? buildServiceMessageSets(targetSnapshot) : void 0;
@@ -1470,6 +1508,7 @@ var evaluateGovernanceRules = (diff, config, targetSnapshot, baseSnapshot) => {
   if (targetSnapshot && targetMessageSets) {
     results.push(...evaluateDeprecationRules(diff, config, targetSnapshot, targetMessageSets, baseSnapshot));
     results.push(...evaluateSchemaChangeRules(diff, config, targetSnapshot));
+    results.push(...evaluateBreakingSchemaChangeRules(diff, config, targetSnapshot));
   }
   return results;
 };
@@ -1502,7 +1541,7 @@ var readSchemaDetails = async (sdk, resourceId, version2, type) => {
     return {};
   }
 };
-var enrichSchemaContent = async (results, baseCatalogDir, targetCatalogDir) => {
+var enrichSchemaContent = async (results, baseCatalogDir, targetCatalogDir, compatibilityStrategy) => {
   const baseSDK = createSDK6(baseCatalogDir);
   const targetSDK = createSDK6(targetCatalogDir);
   const promises = [];
@@ -1528,6 +1567,40 @@ var enrichSchemaContent = async (results, baseCatalogDir, targetCatalogDir) => {
       );
     }
   }
+  for (const result of results) {
+    if (!result.breakingSchemaChanges || !compatibilityStrategy) continue;
+    for (const bsc of result.breakingSchemaChanges) {
+      const { resourceId, version: version2, type, changeType, previousVersion, newVersion } = bsc.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)
+          ]);
+          bsc.before = before.content;
+          bsc.after = after.content;
+          bsc.beforeSchemaPath = before.schemaPath;
+          bsc.afterSchemaPath = after.schemaPath;
+          bsc.beforeSchemaHash = before.schemaHash;
+          bsc.afterSchemaHash = after.schemaHash;
+          if (before.content && after.content) {
+            let beforeSchema;
+            let afterSchema;
+            try {
+              beforeSchema = JSON.parse(before.content);
+              afterSchema = JSON.parse(after.content);
+            } catch {
+            }
+            if (beforeSchema && afterSchema) {
+              bsc.breakingChanges = detectBreakingChanges(beforeSchema, afterSchema, compatibilityStrategy);
+            }
+          }
+        })()
+      );
+    }
+  }
   await Promise.all(promises);
 };
 
@@ -1556,7 +1629,7 @@ var buildServiceOwnersMap = (snapshot2) => {
   return map;
 };
 var executeGovernanceActions = async (results, opts = {}) => {
-  const { messageTypes, status, serviceOwners, baseRef, targetRef } = opts;
+  const { messageTypes, status, serviceOwners, baseRef, targetRef, compatibilityStrategy } = opts;
   const webhookCalls = [];
   const now = (/* @__PURE__ */ new Date()).toISOString();
   for (const result of results) {
@@ -1609,6 +1682,48 @@ var executeGovernanceActions = async (results, opts = {}) => {
         }
         continue;
       }
+      if (result.breakingSchemaChanges && result.breakingSchemaChanges.length > 0) {
+        for (const bsc of result.breakingSchemaChanges) {
+          const messageType = messageTypes?.get(bsc.resourceChange.resourceId) || "message";
+          const payload = {
+            specversion: "1.0",
+            type: "eventcatalog.governance.schema_breaking_change",
+            source: "eventcatalog/governance",
+            id: randomUUID2(),
+            time: now,
+            datacontenttype: "application/json",
+            data: {
+              schemaVersion: 1,
+              ...status && { status },
+              ...compatibilityStrategy && { compatibilityStrategy },
+              summary: `Breaking schema change detected for ${messageType} ${bsc.resourceChange.resourceId}`,
+              message: {
+                id: bsc.resourceChange.resourceId,
+                version: bsc.resourceChange.version,
+                type: messageType
+              },
+              schema: {
+                beforeHash: bsc.beforeSchemaHash ?? null,
+                afterHash: bsc.afterSchemaHash ?? null,
+                beforePath: bsc.beforeSchemaPath ?? null,
+                afterPath: bsc.afterSchemaPath ?? null
+              },
+              breakingChanges: bsc.breakingChanges,
+              refs: {
+                base: baseRef ?? null,
+                target: targetRef ?? null
+              },
+              consumers: bsc.consumerServices,
+              producers: bsc.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";
@@ -1795,31 +1910,38 @@ var governanceCheck = async (opts) => {
       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) {
+    await enrichSchemaContent(results, baseTmpDir, targetCatalogDir, config.compatibility?.strategy);
+    const filteredResults = results.filter((r) => {
+      if (r.trigger !== "schema_breaking_change") return true;
+      if (!r.breakingSchemaChanges) return false;
+      r.breakingSchemaChanges = r.breakingSchemaChanges.filter((bsc) => bsc.breakingChanges.length > 0);
+      return r.breakingSchemaChanges.length > 0;
+    });
+    for (const result of filteredResults) {
       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, {
+    const actionOutput = await executeGovernanceActions(filteredResults, {
       messageTypes,
       status: opts.status,
       serviceOwners,
       baseRef: baseBranch,
-      targetRef: opts.target || "working-directory"
+      targetRef: opts.target || "working-directory",
+      compatibilityStrategy: config.compatibility?.strategy
     });
-    const failures = results.filter((r) => r.failed).map((r) => ({ ruleName: r.rule.name, messages: r.failMessages || [] }));
+    const failures = filteredResults.filter((r) => r.failed).map((r) => ({ ruleName: r.rule.name, messages: r.failMessages || [] }));
     if (opts.format === "json") {
       const jsonOutput = {
         baseBranch,
         target: opts.target || "working directory",
-        results,
+        results: filteredResults,
         summary: {
-          rulesTriggered: results.length,
+          rulesTriggered: filteredResults.length,
           failures: failures.length,
           passed: failures.length === 0
         },
@@ -1829,14 +1951,14 @@ var governanceCheck = async (opts) => {
     }
     const targetLabel = opts.target || "working directory";
     const lines = [`Governance check: comparing ${targetLabel} against ${baseBranch}`, ""];
-    lines.push(formatGovernanceOutput(results));
+    lines.push(formatGovernanceOutput(filteredResults));
     if (actionOutput.length > 0) {
       lines.push("");
       lines.push(...actionOutput);
     }
-    if (results.length > 0) {
+    if (filteredResults.length > 0) {
       const webhookCount = actionOutput.filter((l) => l.includes("Webhook sent")).length;
-      const parts = [`${results.length} rule${results.length === 1 ? "" : "s"} triggered`];
+      const parts = [`${filteredResults.length} rule${filteredResults.length === 1 ? "" : "s"} triggered`];
       if (webhookCount > 0) parts.push(`${webhookCount} webhook${webhookCount === 1 ? "" : "s"} sent`);
       lines.push("");
       lines.push(parts.join(", ") + ".");