aact 2.0.1 → 2.1.0

package/dist/shared/{aact.Dqryafrg.mjs → aact.mCX-x14V.mjs}

@@ -4,20 +4,27 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { Comment, Stdlib_C4_Dynamic_Rel, Relationship, parse, Stdlib_C4_Container_Component, Stdlib_C4_Context, Stdlib_C4_Boundary } from 'plantuml-parser';
 
-const apiTechnologies = ["http", "grpc", "tcp"];
+const EXTERNAL_SYSTEM_TYPE = "System_Ext";
+const SYSTEM_TYPE = "System";
+const CONTAINER_TYPE = "Container";
+const CONTAINER_DB_TYPE = "ContainerDb";
+const COMPONENT_TYPE = "Component";
+const BOUNDARY_TYPE = "Boundary";
+const SYSTEM_BOUNDARY_TYPE = "System_Boundary";
+const CONTAINER_BOUNDARY_TYPE = "Container_Boundary";
+const PERSON_TYPE = "Person";
+
+const DEFAULT_API_TECHNOLOGIES = ["http", "grpc", "tcp"];
 const allRelations = (model) => model.allContainers.flatMap(
   (container) => container.relations.map((relation) => ({ from: container, relation }))
 );
-const boundaryContainsName = (boundary, name) => boundary.containers.some((c) => c.name === name);
-const classifyRelation = (boundary, parentBoundary, from, relation, result, parentResult) => {
-  if (!boundaryContainsName(boundary, from.name)) return;
-  if (boundaryContainsName(boundary, relation.to.name)) {
+const classifyRelation = (names, childNames, parentBoundary, from, relation, result, parentResult) => {
+  if (!names.has(from.name)) return;
+  if (names.has(relation.to.name)) {
     result.cohesion++;
     return;
   }
-  const isInParentSibling = parentBoundary?.boundaries.some(
-    (b) => b.containers.some((c) => c.name === relation.to.name)
-  ) ?? false;
+  const isInParentSibling = childNames?.has(relation.to.name) ?? false;
   if (!parentBoundary || isInParentSibling) {
     result.coupling++;
     result.couplingRelations.push({ from: from.name, to: relation.to.name });
@@ -30,18 +37,51 @@ const classifyRelation = (boundary, parentBoundary, from, relation, result, pare
     });
   }
 };
-const analyzeModel = (model) => {
+const buildBoundaryLookups = (boundaries) => {
+  const nameSets = new Map(
+    boundaries.map((b) => [b.name, new Set(b.containers.map((c) => c.name))])
+  );
+  const parentMap = /* @__PURE__ */ new Map();
+  for (const b of boundaries) {
+    for (const child of b.boundaries) parentMap.set(child.name, b);
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (const b of boundaries) {
+    const parentBoundary = parentMap.get(b.name);
+    let childNames;
+    if (parentBoundary) {
+      childNames = /* @__PURE__ */ new Set();
+      for (const sibling of parentBoundary.boundaries) {
+        for (const c of sibling.containers) childNames.add(c.name);
+      }
+    }
+    result.set(b.name, {
+      nameSet: nameSets.get(b.name),
+      childNames,
+      parentBoundary
+    });
+  }
+  return result;
+};
+const isSyncApiCall = (it, externalType, apiTechnologies) => {
+  if (it.relation.tags?.includes("async")) return false;
+  if (it.relation.to.type === externalType) return true;
+  return apiTechnologies.some(
+    (t) => (it.relation.technology ?? "").toLowerCase().includes(t)
+  );
+};
+const analyzeModel = (model, options) => {
+  const apiTechnologies = options?.apiTechnologies ?? DEFAULT_API_TECHNOLOGIES;
+  const externalType = options?.externalType ?? EXTERNAL_SYSTEM_TYPE;
+  const dbType = options?.dbType ?? CONTAINER_DB_TYPE;
   const relations = allRelations(model);
   const asyncApiCalls = relations.filter(
     (it) => it.relation.tags?.includes("async")
   );
-  const syncApiCalls = relations.filter((it) => {
-    const isExternalApi = it.relation.to.type === "System_Ext";
-    const isApiTechnology = apiTechnologies.some(
-      (apiTechn) => (it.relation.technology ?? "").toLowerCase().includes(apiTechn)
-    );
-    return !it.relation.tags?.includes("async") && (isExternalApi || isApiTechnology);
-  });
+  const syncApiCalls = relations.filter(
+    (it) => isSyncApiCall(it, externalType, apiTechnologies)
+  );
+  const lookups = buildBoundaryLookups(model.boundaries);
   const boundaryResults = /* @__PURE__ */ new Map();
   for (const boundary of model.boundaries) {
     boundaryResults.set(boundary.name, {
@@ -53,14 +93,13 @@ const analyzeModel = (model) => {
     });
   }
   for (const boundary of model.boundaries) {
-    const parentBoundary = model.boundaries.find(
-      (b) => b.boundaries.some((child) => child.name === boundary.name)
-    );
+    const { nameSet, childNames, parentBoundary } = lookups.get(boundary.name);
     const result = boundaryResults.get(boundary.name);
     const parentResult = parentBoundary ? boundaryResults.get(parentBoundary.name) : void 0;
     for (const { from, relation } of relations) {
       classifyRelation(
-        boundary,
+        nameSet,
+        childNames,
         parentBoundary,
         from,
         relation,
@@ -73,28 +112,29 @@ const analyzeModel = (model) => {
     elementsCount: model.allContainers.length,
     syncApiCalls: syncApiCalls.length,
     asyncApiCalls: asyncApiCalls.length,
-    databases: analyzeDatabases(model),
+    databases: analyzeDatabases(model, dbType),
     boundaries: [...boundaryResults.values()]
   };
 };
-const analyzeDatabases = (model) => {
-  const dbContainers = model.allContainers.filter(
-    (it) => it.type === "ContainerDb"
-  );
-  const dbRelations = model.allContainers.flatMap(
-    (container) => container.relations.filter(
-      (r) => dbContainers.some((db) => db.name === r.to.name)
-    )
+const analyzeDatabases = (model, dbType) => {
+  const dbNames = new Set(
+    model.allContainers.filter((it) => it.type === dbType).map((it) => it.name)
   );
+  let consumes = 0;
+  for (const container of model.allContainers) {
+    for (const r of container.relations) {
+      if (dbNames.has(r.to.name)) consumes++;
+    }
+  }
   return {
-    count: dbContainers.length,
-    consumes: dbRelations.length
+    count: dbNames.size,
+    consumes
   };
 };
-const analyzeArchitecture = (model) => {
+const analyzeArchitecture = (model, options) => {
   return {
     model,
-    report: analyzeModel(model)
+    report: analyzeModel(model, options)
   };
 };
 
@@ -102,7 +142,8 @@ const ruleOption = (entries) => v.optional(v.union([v.boolean(), v.strictObject(
 const AactConfigSchema = v.strictObject({
   source: v.strictObject({
     type: v.picklist(["plantuml", "structurizr"]),
-    path: v.string()
+    path: v.string(),
+    writePath: v.optional(v.string())
   }),
   rules: v.optional(
     v.strictObject({
@@ -121,7 +162,8 @@ const AactConfigSchema = v.strictObject({
         dbType: v.optional(v.string())
       }),
       dbPerService: ruleOption({
-        dbType: v.optional(v.string())
+        dbType: v.optional(v.string()),
+        ownerTags: v.optional(v.array(v.string()))
       }),
       cohesion: ruleOption({
         externalType: v.optional(v.string()),
@@ -129,7 +171,8 @@ const AactConfigSchema = v.strictObject({
       }),
       stableDependencies: ruleOption({
         externalType: v.optional(v.string())
-      })
+      }),
+      commonReuse: v.optional(v.boolean())
     })
   ),
   generate: v.optional(
@@ -152,7 +195,7 @@ const buildEnvVar = (relation, sourceKebab, options) => {
   const targetType = relation.to.type;
   const targetKebab = toKebab(relation.to.name);
   const targetUpper = toEnvKey(targetKebab);
-  if (targetType === "ContainerDb") {
+  if (targetType === CONTAINER_DB_TYPE) {
     const value = options.dbConnectionTemplate.replaceAll(
       "{name}",
       sourceKebab
@@ -163,11 +206,11 @@ const buildEnvVar = (relation, sourceKebab, options) => {
     const value = relation.technology ?? targetKebab;
     return { key: `KAFKA_${targetUpper}_TOPIC`, value };
   }
-  if (targetType === "System_Ext") {
+  if (targetType === EXTERNAL_SYSTEM_TYPE) {
     const value = relation.technology ?? `https://${targetKebab}`;
     return { key: `${targetUpper}_BASE_URL`, value };
   }
-  if (targetType === "Container") {
+  if (targetType === CONTAINER_TYPE) {
     const value = relation.technology ?? `http://${targetKebab}:${options.defaultPort}`;
     return { key: `${targetUpper}_BASE_URL`, value };
   }
@@ -178,7 +221,7 @@ const generateKubernetes = (model, options) => {
   const dbConnectionTemplate = options?.dbConnectionTemplate ?? "postgresql://{name}:pass-{name}@postgresql:5432/{name}";
   const resolvedOptions = { defaultPort, dbConnectionTemplate };
   const containers = model.allContainers.filter(
-    (c) => c.type !== "ContainerDb" && c.type !== "System_Ext"
+    (c) => c.type !== CONTAINER_DB_TYPE && c.type !== EXTERNAL_SYSTEM_TYPE
   );
   return containers.map((container) => {
     const kebabName = toKebab(container.name);
@@ -205,14 +248,24 @@ const generateKubernetes = (model, options) => {
   });
 };
 
+const PLANTUML_CONTAINER = "Container";
+const PLANTUML_CONTAINER_DB = "ContainerDb";
+const PLANTUML_SYSTEM_EXT = "System_Ext";
+const PLANTUML_SYSTEM = "System";
+const PLANTUML_PERSON = "Person";
+const PLANTUML_COMPONENT = "Component";
+const PLANTUML_SYSTEM_BOUNDARY = "System_Boundary";
+const PLANTUML_CONTAINER_BOUNDARY = "Container_Boundary";
+const PLANTUML_BOUNDARY = "Boundary";
+
 const containerTypeMap = {
-  Container: "Container",
-  ContainerDb: "ContainerDb",
-  System_Ext: "System_Ext",
-  Person: "Person"
+  [CONTAINER_TYPE]: PLANTUML_CONTAINER,
+  [CONTAINER_DB_TYPE]: PLANTUML_CONTAINER_DB,
+  [EXTERNAL_SYSTEM_TYPE]: PLANTUML_SYSTEM_EXT,
+  [PERSON_TYPE]: PLANTUML_PERSON
 };
 const renderContainer = (container) => {
-  const type = containerTypeMap[container.type ?? "Container"] ?? "Container";
+  const type = containerTypeMap[container.type ?? CONTAINER_TYPE] ?? PLANTUML_CONTAINER;
   const tags = container.tags && container.tags.length > 0 ? `, $tags="${container.tags.join("+")}"` : "";
   const desc = container.description ? `, "${container.description}"` : "";
   return `${type}(${container.name}, "${container.label}"${desc}${tags})`;
@@ -284,13 +337,15 @@ const filterElements = (elements) => {
   const result = [];
   for (const element of elements) {
     if (element instanceof Comment) continue;
-    if (element.type_.name === "Container" || element.type_.name === "ContainerDb" || element.type_.name === "Component" || element.type_.name === "System_Ext" || element.type_.name === "System" || element.type_.name === "Person" || element instanceof Stdlib_C4_Dynamic_Rel || element instanceof Relationship) {
+    if (element.type_.name === PLANTUML_CONTAINER || element.type_.name === PLANTUML_CONTAINER_DB || element.type_.name === PLANTUML_COMPONENT || element.type_.name === PLANTUML_SYSTEM_EXT || element.type_.name === PLANTUML_SYSTEM || element.type_.name === PLANTUML_PERSON || element instanceof Stdlib_C4_Dynamic_Rel || element instanceof Relationship) {
       result.push(element);
     }
     const elementAsBoundary = element;
-    if (["System_Boundary", "Container_Boundary", "Boundary"].includes(
-      elementAsBoundary.type_.name
-    )) {
+    if ([
+      PLANTUML_SYSTEM_BOUNDARY,
+      PLANTUML_CONTAINER_BOUNDARY,
+      PLANTUML_BOUNDARY
+    ].includes(elementAsBoundary.type_.name)) {
       result.push(elementAsBoundary);
       const resultFromBoundary = filterElements(elementAsBoundary.elements);
       result.push(...resultFromBoundary);
@@ -381,6 +436,11 @@ const mapContainersFromPlantumlElements = (elements) => {
   };
 };
 
+const STRUCTURIZR_LOCATION_EXTERNAL = "External";
+const STRUCTURIZR_INTERACTION_ASYNC = "Asynchronous";
+const STRUCTURIZR_TAG_ASYNC = "async";
+
+const dslId = (id, properties) => properties?.["structurizr.dsl.identifier"] ?? id;
 const DATABASE_TECHNOLOGIES = [
   "postgresql",
   "postgres",
@@ -428,9 +488,9 @@ const loadStructurizrWorkspace = async (filePath) => {
 };
 const processExternalSystem = (system, registry) => {
   const container = {
-    name: system.id,
+    name: dslId(system.id, system.properties),
     label: system.name,
-    type: "System_Ext",
+    type: EXTERNAL_SYSTEM_TYPE,
     tags: system.tags?.split(",").map((t) => t.trim()).filter(Boolean),
     description: system.description ?? "",
     relations: []
@@ -442,9 +502,9 @@ const processInternalSystem = (system, registry) => {
   const systemContainers = [];
   for (const cont of system.containers ?? []) {
     const container = {
-      name: cont.id,
+      name: dslId(cont.id, cont.properties),
       label: cont.name,
-      type: isDatabase(cont.technology, cont.name) ? "ContainerDb" : "Container",
+      type: isDatabase(cont.technology, cont.name) ? CONTAINER_DB_TYPE : CONTAINER_TYPE,
       tags: enrichTags(cont.tags, cont.name),
       description: cont.description ?? "",
       relations: []
@@ -454,9 +514,9 @@ const processInternalSystem = (system, registry) => {
     registry.allElements.set(cont.id, container);
   }
   registry.boundaries.push({
-    name: system.id,
+    name: dslId(system.id, system.properties),
     label: system.name,
-    type: "Boundary",
+    type: BOUNDARY_TYPE,
     boundaries: [],
     containers: systemContainers
   });
@@ -468,12 +528,12 @@ const addRelations = (allElements, sourceId, relationships) => {
     const targetContainer = allElements.get(rel.destinationId);
     if (!targetContainer) continue;
     let tags = rel.tags?.split(",").map((t) => t.trim());
-    if (rel.interactionStyle === "Asynchronous") {
-      tags = [...tags ?? [], "async"];
+    if (rel.interactionStyle === STRUCTURIZR_INTERACTION_ASYNC) {
+      tags = [...tags ?? [], STRUCTURIZR_TAG_ASYNC];
     }
     const relation = {
       to: targetContainer,
-      technology: rel.technology,
+      technology: rel.technology ?? (rel.description?.includes(" ") ? void 0 : rel.description),
       tags
     };
     sourceContainer.relations.push(relation);
@@ -486,7 +546,7 @@ const mapContainersFromStructurizr = (workspace) => {
     boundaries: []
   };
   for (const system of workspace.model.softwareSystems ?? []) {
-    if (system.location === "External") {
+    if (system.location === STRUCTURIZR_LOCATION_EXTERNAL || system.tags?.includes(STRUCTURIZR_LOCATION_EXTERNAL)) {
       processExternalSystem(system, registry);
     } else {
       processInternalSystem(system, registry);
@@ -494,9 +554,9 @@ const mapContainersFromStructurizr = (workspace) => {
   }
   for (const person of workspace.model.people ?? []) {
     const container = {
-      name: person.id,
+      name: dslId(person.id, person.properties),
       label: person.name,
-      type: "Person",
+      type: PERSON_TYPE,
       tags: person.tags?.split(",").map((t) => t.trim()).filter(Boolean),
       description: person.description ?? "",
       relations: []
@@ -528,18 +588,42 @@ const loadStructurizrElements = async (filePath) => {
   return mapContainersFromStructurizr(workspace);
 };
 
+const structurizrDslSyntax = {
+  containerPattern: (name) => `${name} = container`,
+  containerDecl: (name, label, tags) => {
+    if (tags) {
+      return `${name} = container "${label}" {
+    tags "${tags}"
+}`;
+    }
+    return `${name} = container "${label}"`;
+  },
+  relationPattern: (from, to) => `${from} -> ${to}`,
+  relationDecl: (from, to, tech, tags) => {
+    const techPart = tech ? ` "${tech}"` : "";
+    if (tags) {
+      return `${from} -> ${to}${techPart} {
+    tags "${tags}"
+}`;
+    }
+    return `${from} -> ${to}${techPart}`;
+  }
+};
+
 const checkAcl = (containers, options) => {
   const tag = options?.tag ?? "acl";
-  const externalType = options?.externalType ?? "System_Ext";
+  const externalType = options?.externalType ?? EXTERNAL_SYSTEM_TYPE;
   const violations = [];
   for (const container of containers) {
     const externalRelations = container.relations.filter(
       (r) => r.to.type === externalType
     );
     if (!container.tags?.includes(tag) && externalRelations.length > 0) {
+      const names = externalRelations.map((r) => r.to.name).join(", ");
+      const label = externalRelations.length === 1 ? "system" : "systems";
       violations.push({
         container: container.name,
-        message: `depends on external systems: ${externalRelations.map((r) => r.to.name).join(", ")}`
+        message: `calls external ${label} ${names} without an ACL layer`
       });
     }
   }
@@ -574,7 +658,7 @@ const checkAcyclic = (containers) => {
 
 const checkApiGateway = (containers, options) => {
   const aclTag = options?.aclTag ?? "acl";
-  const externalType = options?.externalType ?? "System_Ext";
+  const externalType = options?.externalType ?? EXTERNAL_SYSTEM_TYPE;
   const gatewayPattern = options?.gatewayPattern ?? /gateway/i;
   const violations = [];
   for (const container of containers) {
@@ -585,7 +669,7 @@ const checkApiGateway = (containers, options) => {
       if (!techs.some((t) => gatewayPattern.test(t))) {
         violations.push({
           container: container.name,
-          message: `external relation to ${rel.to.name} does not go through API Gateway`
+          message: `calls external "${rel.to.name}" without going through an API Gateway`
         });
       }
     }
@@ -594,22 +678,22 @@ const checkApiGateway = (containers, options) => {
 };
 
 const getBoundaryCohesion = (boundary) => {
+  const names = new Set(boundary.containers.map((c) => c.name));
   let result = 0;
   for (const container of boundary.containers) {
-    result += container.relations.filter(
-      (r) => boundary.containers.some((c) => c.name === r.to.name)
-    ).length;
+    result += container.relations.filter((r) => names.has(r.to.name)).length;
   }
   for (const innerBoundary of boundary.boundaries) {
     result += getBoundaryCoupling(innerBoundary);
   }
   return result;
 };
-const getBoundaryCoupling = (boundary, externalType = "System_Ext", internalType = "Container") => {
+const getBoundaryCoupling = (boundary, externalType = EXTERNAL_SYSTEM_TYPE, internalType = CONTAINER_TYPE) => {
+  const names = new Set(boundary.containers.map((c) => c.name));
   let result = 0;
   for (const container of boundary.containers) {
     result += container.relations.filter(
-      (r) => r.to.type === internalType && !boundary.containers.some((c) => c.name === r.to.name)
+      (r) => r.to.type === internalType && !names.has(r.to.name)
     ).length;
   }
   for (const innerBoundary of boundary.boundaries) {
@@ -622,8 +706,8 @@ const getBoundaryCoupling = (boundary, externalType = "System_Ext", internalType
   return result;
 };
 const checkCohesion = (model, options) => {
-  const externalType = options?.externalType ?? "System_Ext";
-  const internalType = options?.internalType ?? "Container";
+  const externalType = options?.externalType ?? EXTERNAL_SYSTEM_TYPE;
+  const internalType = options?.internalType ?? CONTAINER_TYPE;
   const violations = [];
   for (const boundary of model.boundaries) {
     const cohesion = getBoundaryCohesion(boundary);
@@ -631,7 +715,7 @@ const checkCohesion = (model, options) => {
     if (cohesion <= coupling) {
       violations.push({
         container: boundary.name,
-        message: `cohesion (${cohesion}) is not greater than coupling (${coupling})`
+        message: `coupling (${coupling}) \u2265 cohesion (${cohesion}) \u2014 more cross-boundary dependencies than internal connections`
       });
     }
     if (boundary.boundaries.length > 0) {
@@ -642,7 +726,7 @@ const checkCohesion = (model, options) => {
       if (cohesion >= innerCohesionSum) {
         violations.push({
           container: boundary.name,
-          message: `cohesion (${cohesion}) is not less than sum of inner boundary cohesions (${innerCohesionSum})`
+          message: `parent cohesion (${cohesion}) \u2265 sum of inner cohesions (${innerCohesionSum}) \u2014 parent boundary should be less cohesive than its sub-boundaries`
         });
       }
     }
@@ -650,9 +734,57 @@ const checkCohesion = (model, options) => {
   return violations;
 };
 
+const checkCommonReuse = (model) => {
+  const boundaryOf = /* @__PURE__ */ new Map();
+  for (const boundary of model.boundaries) {
+    for (const c of boundary.containers) {
+      boundaryOf.set(c.name, boundary);
+    }
+  }
+  const publicOf = /* @__PURE__ */ new Map();
+  const used = /* @__PURE__ */ new Map();
+  for (const source of model.allContainers) {
+    const srcBoundary = boundaryOf.get(source.name);
+    if (!srcBoundary) continue;
+    for (const rel of source.relations) {
+      const tgtBoundary = boundaryOf.get(rel.to.name);
+      if (!tgtBoundary || tgtBoundary === srcBoundary) continue;
+      let pub = publicOf.get(tgtBoundary);
+      if (!pub) {
+        pub = /* @__PURE__ */ new Set();
+        publicOf.set(tgtBoundary, pub);
+      }
+      pub.add(rel.to.name);
+      const key = `${srcBoundary.name}\0${tgtBoundary.name}`;
+      let u = used.get(key);
+      if (!u) {
+        u = /* @__PURE__ */ new Set();
+        used.set(key, u);
+      }
+      u.add(rel.to.name);
+    }
+  }
+  const violations = [];
+  for (const [provider, pubNames] of publicOf) {
+    if (pubNames.size < 2) continue;
+    for (const consumer of model.boundaries) {
+      if (consumer === provider) continue;
+      const key = `${consumer.name}\0${provider.name}`;
+      const usedNames = used.get(key);
+      if (!usedNames || usedNames.size >= pubNames.size) continue;
+      const missing = [...pubNames].filter((n) => !usedNames.has(n));
+      violations.push({
+        container: consumer.name,
+        message: `uses ${[...usedNames].join(", ")} of "${provider.name}" but not ${missing.join(", ")} \u2014 all public services of a context should be used together`
+      });
+    }
+  }
+  return violations;
+};
+
 const checkCrud = (containers, options) => {
   const repoTags = options?.repoTags ?? ["repo", "relay"];
-  const dbType = options?.dbType ?? "ContainerDb";
+  const dbType = options?.dbType ?? CONTAINER_DB_TYPE;
   const violations = [];
   for (const container of containers) {
     const dbRelations = container.relations.filter((r) => r.to.type === dbType);
@@ -660,13 +792,13 @@ const checkCrud = (containers, options) => {
     if (!isRepo && dbRelations.length > 0) {
       violations.push({
         container: container.name,
-        message: `accesses database without repo/relay tag: ${dbRelations.map((r) => r.to.name).join(", ")}`
+        message: `directly accesses database ${dbRelations.map((r) => r.to.name).join(", ")} \u2014 add a repo or relay`
       });
     }
     if (container.tags?.includes("repo") && container.relations.some((r) => r.to.type !== dbType)) {
       violations.push({
         container: container.name,
-        message: `repo has non-database dependencies: ${container.relations.filter((r) => r.to.type !== dbType).map((r) => r.to.name).join(", ")}`
+        message: `repo has non-database dependencies: ${container.relations.filter((r) => r.to.type !== dbType).map((r) => r.to.name).join(", ")} \u2014 repos should only access databases`
       });
     }
   }
@@ -674,7 +806,7 @@ const checkCrud = (containers, options) => {
 };
 
 const checkDbPerService = (containers, options) => {
-  const dbType = options?.dbType ?? "ContainerDb";
+  const dbType = options?.dbType ?? CONTAINER_DB_TYPE;
   const violations = [];
   const dbAccessMap = /* @__PURE__ */ new Map();
   for (const container of containers) {
@@ -690,7 +822,7 @@ const checkDbPerService = (containers, options) => {
     if (accessors.length > 1) {
       violations.push({
         container: db,
-        message: `accessed by multiple services: ${accessors.join(", ")}`
+        message: `shared between ${accessors.join(", ")} \u2014 each database should have a single owner`
       });
     }
   }
@@ -714,7 +846,7 @@ const computeCoupling = (internal, internalNames) => {
   return { ca, ce };
 };
 const checkStableDependencies = (containers, options) => {
-  const externalType = options?.externalType ?? "System_Ext";
+  const externalType = options?.externalType ?? EXTERNAL_SYSTEM_TYPE;
   const violations = [];
   const internal = containers.filter((c) => c.type !== externalType);
   const internalNames = new Set(internal.map((c) => c.name));
@@ -733,7 +865,7 @@ const checkStableDependencies = (containers, options) => {
       if (iSource < iTarget) {
         violations.push({
           container: c.name,
-          message: `depends on less stable ${rel.to.name} (I=${iSource.toFixed(2)} \u2192 I=${iTarget.toFixed(2)})`
+          message: `stable module (I=${iSource.toFixed(2)}) depends on less stable "${rel.to.name}" (I=${iTarget.toFixed(2)}) \u2014 dependencies should point toward stability`
         });
       }
     }
@@ -741,4 +873,4 @@ const checkStableDependencies = (containers, options) => {
   return violations;
 };
 
-export { AactConfigSchema as A, analyzeArchitecture as a, checkAcyclic as b, checkAcl as c, checkApiGateway as d, checkCohesion as e, checkCrud as f, checkDbPerService as g, checkStableDependencies as h, defineConfig as i, generateKubernetes as j, generatePlantumlFromModel as k, loadPlantumlElements as l, loadStructurizrElements as m, loadStructurizrWorkspace as n, mapContainersFromPlantumlElements as o, mapContainersFromStructurizr as p };
+export { AactConfigSchema as A, BOUNDARY_TYPE as B, COMPONENT_TYPE as C, generateKubernetes as D, EXTERNAL_SYSTEM_TYPE as E, generatePlantumlFromModel as F, loadPlantumlElements as G, loadStructurizrElements as H, loadStructurizrWorkspace as I, mapContainersFromPlantumlElements as J, mapContainersFromStructurizr as K, structurizrDslSyntax as L, PERSON_TYPE as P, STRUCTURIZR_INTERACTION_ASYNC as S, CONTAINER_BOUNDARY_TYPE as a, CONTAINER_DB_TYPE as b, CONTAINER_TYPE as c, PLANTUML_BOUNDARY as d, PLANTUML_COMPONENT as e, PLANTUML_CONTAINER as f, PLANTUML_CONTAINER_BOUNDARY as g, PLANTUML_CONTAINER_DB as h, PLANTUML_PERSON as i, PLANTUML_SYSTEM as j, PLANTUML_SYSTEM_BOUNDARY as k, PLANTUML_SYSTEM_EXT as l, STRUCTURIZR_LOCATION_EXTERNAL as m, STRUCTURIZR_TAG_ASYNC as n, SYSTEM_BOUNDARY_TYPE as o, SYSTEM_TYPE as p, analyzeArchitecture as q, checkAcl as r, checkAcyclic as s, checkApiGateway as t, checkCohesion as u, checkCommonReuse as v, checkCrud as w, checkDbPerService as x, checkStableDependencies as y, defineConfig as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aact",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "type": "module",
   "description": "Architecture analysis and compliance tool",
   "keywords": [
@@ -80,6 +80,7 @@
     "c12": "4.0.0-beta.2",
     "citty": "^0.2.0",
     "consola": "^3.4.2",
+    "picocolors": "^1.1.1",
     "plantuml-parser": "0.4.0",
     "valibot": "^1.2.0",
     "yaml": "2.8.2"