aact 2.1.4 → 3.0.0-beta.2

package/dist/shared/aact.BzhD7c9t.mjs

@@ -1,884 +0,0 @@
-import * as v from 'valibot';
-import YAML from 'yaml';
-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 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 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 = childNames?.has(relation.to.name) ?? false;
-  if (!parentBoundary || isInParentSibling) {
-    result.coupling++;
-    result.couplingRelations.push({ from: from.name, to: relation.to.name });
-    if (parentResult) parentResult.cohesion++;
-  } else if (parentResult) {
-    parentResult.coupling++;
-    parentResult.couplingRelations.push({
-      from: from.name,
-      to: relation.to.name
-    });
-  }
-};
-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) => isSyncApiCall(it, externalType, apiTechnologies)
-  );
-  const lookups = buildBoundaryLookups(model.boundaries);
-  const boundaryResults = /* @__PURE__ */ new Map();
-  for (const boundary of model.boundaries) {
-    boundaryResults.set(boundary.name, {
-      name: boundary.name,
-      label: boundary.label,
-      cohesion: 0,
-      coupling: 0,
-      couplingRelations: []
-    });
-  }
-  for (const boundary of model.boundaries) {
-    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(
-        nameSet,
-        childNames,
-        parentBoundary,
-        from,
-        relation,
-        result,
-        parentResult
-      );
-    }
-  }
-  return {
-    elementsCount: model.allContainers.length,
-    syncApiCalls: syncApiCalls.length,
-    asyncApiCalls: asyncApiCalls.length,
-    databases: analyzeDatabases(model, dbType),
-    boundaries: [...boundaryResults.values()]
-  };
-};
-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: dbNames.size,
-    consumes
-  };
-};
-const analyzeArchitecture = (model, options) => {
-  return {
-    model,
-    report: analyzeModel(model, options)
-  };
-};
-
-const ruleOption = (entries) => v.optional(v.union([v.boolean(), v.strictObject(entries)]));
-const AactConfigSchema = v.strictObject({
-  source: v.strictObject({
-    type: v.picklist(["plantuml", "structurizr"]),
-    path: v.string(),
-    writePath: v.optional(v.string())
-  }),
-  rules: v.optional(
-    v.strictObject({
-      acl: ruleOption({
-        tag: v.optional(v.string()),
-        externalType: v.optional(v.string())
-      }),
-      acyclic: v.optional(v.boolean()),
-      apiGateway: ruleOption({
-        aclTag: v.optional(v.string()),
-        externalType: v.optional(v.string()),
-        gatewayPattern: v.optional(v.instance(RegExp))
-      }),
-      crud: ruleOption({
-        repoTags: v.optional(v.array(v.string())),
-        dbType: v.optional(v.string())
-      }),
-      dbPerService: ruleOption({
-        dbType: v.optional(v.string()),
-        ownerTags: v.optional(v.array(v.string()))
-      }),
-      cohesion: ruleOption({
-        externalType: v.optional(v.string()),
-        internalType: v.optional(v.string())
-      }),
-      stableDependencies: ruleOption({
-        externalType: v.optional(v.string())
-      }),
-      commonReuse: v.optional(v.boolean())
-    })
-  ),
-  generate: v.optional(
-    v.strictObject({
-      kubernetes: v.optional(
-        v.strictObject({
-          path: v.optional(v.string()),
-          exclude: v.optional(v.array(v.string()))
-        })
-      ),
-      boundaryLabel: v.optional(v.string())
-    })
-  )
-});
-const defineConfig = (config) => config;
-
-const toKebab = (name) => name.replaceAll("_", "-");
-const toEnvKey = (name) => name.replaceAll("-", "_").toUpperCase();
-const buildEnvVar = (relation, sourceKebab, options) => {
-  const targetType = relation.to.type;
-  const targetKebab = toKebab(relation.to.name);
-  const targetUpper = toEnvKey(targetKebab);
-  if (targetType === CONTAINER_DB_TYPE) {
-    const value = options.dbConnectionTemplate.replaceAll(
-      "{name}",
-      sourceKebab
-    );
-    return { key: "PG_CONNECTION_STRING", value };
-  }
-  if (relation.tags?.includes("async")) {
-    const value = relation.technology ?? targetKebab;
-    return { key: `KAFKA_${targetUpper}_TOPIC`, value };
-  }
-  if (targetType === EXTERNAL_SYSTEM_TYPE) {
-    const value = relation.technology ?? `https://${targetKebab}`;
-    return { key: `${targetUpper}_BASE_URL`, value };
-  }
-  if (targetType === CONTAINER_TYPE) {
-    const value = relation.technology ?? `http://${targetKebab}:${options.defaultPort}`;
-    return { key: `${targetUpper}_BASE_URL`, value };
-  }
-  return void 0;
-};
-const generateKubernetes = (model, options) => {
-  const defaultPort = options?.defaultPort ?? 8080;
-  const dbConnectionTemplate = options?.dbConnectionTemplate ?? "postgresql://{name}:pass-{name}@postgresql:5432/{name}";
-  const resolvedOptions = { defaultPort, dbConnectionTemplate };
-  const containers = model.allContainers.filter(
-    (c) => c.type !== CONTAINER_DB_TYPE && c.type !== EXTERNAL_SYSTEM_TYPE && c.type !== PERSON_TYPE
-  );
-  return containers.map((container) => {
-    const kebabName = toKebab(container.name);
-    const envEntries = [];
-    for (const relation of container.relations) {
-      const entry = buildEnvVar(relation, kebabName, resolvedOptions);
-      if (entry) {
-        envEntries.push(entry);
-      }
-    }
-    envEntries.sort((a, b) => a.key.localeCompare(b.key));
-    const doc = { name: kebabName };
-    if (envEntries.length > 0) {
-      const environment = {};
-      for (const { key, value } of envEntries) {
-        environment[key] = { default: value };
-      }
-      doc.environment = environment;
-    }
-    return {
-      fileName: `${kebabName}.yml`,
-      content: YAML.stringify(doc)
-    };
-  });
-};
-
-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_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_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})`;
-};
-const renderBoundary = (boundary, indent) => {
-  const inner = indent + "  ";
-  const children = [
-    ...boundary.boundaries.map((child) => renderBoundary(child, inner)),
-    ...boundary.containers.map(
-      (container) => `${inner}${renderContainer(container)}`
-    )
-  ];
-  return [
-    `${indent}Boundary(${boundary.name}, "${boundary.label}") {`,
-    ...children,
-    `${indent}}`
-  ].join("\n");
-};
-const renderRelation = (container, relation) => {
-  const tech = relation.technology ? `, "${relation.technology}"` : "";
-  const tags = relation.tags && relation.tags.length > 0 ? `, $tags="${relation.tags.join("+")}"` : "";
-  return `Rel(${container.name}, ${relation.to.name}, ""${tech}${tags})`;
-};
-const collectBoundaryContainerNames = (boundaries) => {
-  const names = /* @__PURE__ */ new Set();
-  const collect = (boundary) => {
-    for (const c of boundary.containers) names.add(c.name);
-    for (const b of boundary.boundaries) collect(b);
-  };
-  for (const boundary of boundaries) collect(boundary);
-  return names;
-};
-const renderBody = (model, standaloneContainers, boundaryLabel) => {
-  if (boundaryLabel) {
-    return [
-      `Boundary(project, "${boundaryLabel}") {`,
-      ...model.boundaries.map((b) => renderBoundary(b, "  ")),
-      ...standaloneContainers.map((c) => `  ${renderContainer(c)}`),
-      `}`
-    ];
-  }
-  return [
-    ...model.boundaries.map((b) => renderBoundary(b, "")),
-    ...standaloneContainers.map((c) => renderContainer(c))
-  ];
-};
-const generatePlantumlFromModel = (model, options) => {
-  const boundaryNames = collectBoundaryContainerNames(model.boundaries);
-  const standaloneContainers = model.allContainers.filter(
-    (c) => !boundaryNames.has(c.name)
-  );
-  const relations = model.allContainers.flatMap(
-    (container) => container.relations.map((rel) => renderRelation(container, rel))
-  );
-  return [
-    `@startuml`,
-    `!include https://raw.githubusercontent.com/plantuml-stdlib/C4-PlantUML/master/C4_Container.puml`,
-    `LAYOUT_WITH_LEGEND()`,
-    `AddRelTag("async", $lineStyle = DottedLine())`,
-    "",
-    ...renderBody(model, standaloneContainers, options?.boundaryLabel),
-    "",
-    ...relations,
-    "@enduml"
-  ].join("\n");
-};
-
-const filterElements = (elements) => {
-  const result = [];
-  for (const element of elements) {
-    if (element instanceof Comment) continue;
-    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 ([
-      PLANTUML_SYSTEM_BOUNDARY,
-      PLANTUML_CONTAINER_BOUNDARY,
-      PLANTUML_BOUNDARY
-    ].includes(elementAsBoundary.type_.name)) {
-      result.push(elementAsBoundary);
-      const resultFromBoundary = filterElements(elementAsBoundary.elements);
-      result.push(...resultFromBoundary);
-    }
-    if (Array.isArray(element)) {
-      const resultFromArray = filterElements(element);
-      result.push(...resultFromArray);
-    }
-  }
-  return result;
-};
-
-const loadPlantumlElements = async (filePath) => {
-  const filepath = path.resolve(filePath);
-  let data = await fs.readFile(filepath, "utf8");
-  data = data.replaceAll(/, \$tags=(".+?")/g, ", $1").replaceAll('""', '" "');
-  const [{ elements }] = parse(data);
-  for (const element of elements) {
-    if (element instanceof Comment) continue;
-    const relation = element;
-    if (relation.type_.name.startsWith("Rel_Back")) {
-      const from = relation.from;
-      relation.from = relation.to;
-      relation.to = from;
-    }
-  }
-  return filterElements(elements);
-};
-
-const addDependency = (containers, relation) => {
-  const containerFrom = containers.find((x) => x.name === relation.from);
-  if (!containerFrom) return;
-  const containerTo = containers.find((x) => x.name === relation.to);
-  if (!containerTo) return;
-  containerFrom.relations.push({
-    to: containerTo,
-    technology: relation.techn,
-    tags: relation.descr?.split(",").map((t) => t.trim())
-  });
-};
-const mapContainersFromPlantumlElements = (elements) => {
-  const containers = elements.filter(
-    (element) => element instanceof Stdlib_C4_Container_Component || element instanceof Stdlib_C4_Context
-  ).map((element) => {
-    const component = element;
-    return {
-      name: component.alias,
-      label: component.label,
-      type: component.type_.name,
-      relations: [],
-      tags: component.sprite ? [component.sprite] : void 0,
-      description: component.descr
-    };
-  });
-  for (const element of elements) {
-    if (element instanceof Stdlib_C4_Container_Component) {
-      continue;
-    }
-    if (element instanceof Stdlib_C4_Dynamic_Rel) {
-      addDependency(containers, element);
-    }
-  }
-  const boundaries = elements.filter((element) => element instanceof Stdlib_C4_Boundary).map((element) => {
-    const component = element;
-    return {
-      name: component.alias,
-      label: component.label,
-      type: component.type_.name,
-      boundaries: [],
-      containers: containers.filter(
-        (container) => component.elements.filter(
-          (element2) => element2 instanceof Stdlib_C4_Container_Component
-        ).some((e) => e.alias == container.name)
-      )
-    };
-  });
-  for (const boundary of boundaries) {
-    const component = elements.find(
-      (element) => element instanceof Stdlib_C4_Boundary && element.alias == boundary.name
-    );
-    boundary.boundaries = boundaries.filter(
-      (b) => component.elements.filter((element) => element instanceof Stdlib_C4_Boundary).some((e) => e.alias == b.name)
-    );
-  }
-  return {
-    allContainers: containers.toSorted((a, b) => a.name.localeCompare(b.name)),
-    boundaries
-  };
-};
-
-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",
-  "mysql",
-  "mariadb",
-  "mongodb",
-  "mongo",
-  "redis",
-  "elasticsearch",
-  "dynamodb",
-  "cassandra",
-  "sqlite",
-  "oracle",
-  "sqlserver",
-  "mssql",
-  "database",
-  "db"
-];
-const isDatabase = (technology, name) => {
-  const techLower = technology?.toLowerCase() ?? "";
-  const nameLower = name?.toLowerCase() ?? "";
-  if (DATABASE_TECHNOLOGIES.some((db) => techLower.includes(db))) {
-    return true;
-  }
-  if (nameLower.endsWith(" db") || nameLower.endsWith("_db") || nameLower.endsWith("database")) {
-    return true;
-  }
-  return false;
-};
-const enrichTags = (existingTags, name) => {
-  const tags = existingTags?.split(",").map((t) => t.trim()).filter(Boolean) ?? [];
-  const nameLower = name?.toLowerCase() ?? "";
-  if (nameLower.includes("crud") && !tags.includes("repo")) {
-    tags.push("repo");
-  }
-  if (nameLower.includes("acl") && !tags.includes("acl")) {
-    tags.push("acl");
-  }
-  return tags;
-};
-const loadStructurizrWorkspace = async (filePath) => {
-  const filepath = path.resolve(filePath);
-  const data = await fs.readFile(filepath, "utf8");
-  return JSON.parse(data);
-};
-const processExternalSystem = (system, registry) => {
-  const container = {
-    name: dslId(system.id, system.properties),
-    label: system.name,
-    type: EXTERNAL_SYSTEM_TYPE,
-    tags: system.tags?.split(",").map((t) => t.trim()).filter(Boolean),
-    description: system.description ?? "",
-    relations: []
-  };
-  registry.containers.push(container);
-  registry.allElements.set(system.id, container);
-};
-const processInternalSystem = (system, registry) => {
-  const systemContainers = [];
-  for (const cont of system.containers ?? []) {
-    const container = {
-      name: dslId(cont.id, cont.properties),
-      label: cont.name,
-      type: isDatabase(cont.technology, cont.name) ? CONTAINER_DB_TYPE : CONTAINER_TYPE,
-      tags: enrichTags(cont.tags, cont.name),
-      description: cont.description ?? "",
-      relations: []
-    };
-    systemContainers.push(container);
-    registry.containers.push(container);
-    registry.allElements.set(cont.id, container);
-  }
-  registry.boundaries.push({
-    name: dslId(system.id, system.properties),
-    label: system.name,
-    type: BOUNDARY_TYPE,
-    boundaries: [],
-    containers: systemContainers
-  });
-};
-const addRelations = (allElements, sourceId, relationships) => {
-  const sourceContainer = allElements.get(sourceId);
-  if (!sourceContainer || !relationships) return;
-  for (const rel of relationships) {
-    const targetContainer = allElements.get(rel.destinationId);
-    if (!targetContainer) continue;
-    let tags = rel.tags?.split(",").map((t) => t.trim());
-    if (rel.interactionStyle === STRUCTURIZR_INTERACTION_ASYNC) {
-      tags = [...tags ?? [], STRUCTURIZR_TAG_ASYNC];
-    }
-    const relation = {
-      to: targetContainer,
-      technology: rel.technology ?? (rel.description?.includes(" ") ? void 0 : rel.description),
-      tags
-    };
-    sourceContainer.relations.push(relation);
-  }
-};
-const mapContainersFromStructurizr = (workspace) => {
-  const registry = {
-    allElements: /* @__PURE__ */ new Map(),
-    containers: [],
-    boundaries: []
-  };
-  for (const system of workspace.model.softwareSystems ?? []) {
-    if (system.location === STRUCTURIZR_LOCATION_EXTERNAL || system.tags?.includes(STRUCTURIZR_LOCATION_EXTERNAL)) {
-      processExternalSystem(system, registry);
-    } else {
-      processInternalSystem(system, registry);
-    }
-  }
-  for (const person of workspace.model.people ?? []) {
-    const container = {
-      name: dslId(person.id, person.properties),
-      label: person.name,
-      type: PERSON_TYPE,
-      tags: person.tags?.split(",").map((t) => t.trim()).filter(Boolean),
-      description: person.description ?? "",
-      relations: []
-    };
-    registry.containers.push(container);
-    registry.allElements.set(person.id, container);
-  }
-  for (const system of workspace.model.softwareSystems ?? []) {
-    addRelations(registry.allElements, system.id, system.relationships);
-    for (const cont of system.containers ?? []) {
-      addRelations(registry.allElements, cont.id, cont.relationships);
-      for (const comp of cont.components ?? []) {
-        addRelations(registry.allElements, comp.id, comp.relationships);
-      }
-    }
-  }
-  for (const person of workspace.model.people ?? []) {
-    addRelations(registry.allElements, person.id, person.relationships);
-  }
-  return {
-    allContainers: registry.containers.toSorted(
-      (a, b) => a.name.localeCompare(b.name)
-    ),
-    boundaries: registry.boundaries
-  };
-};
-const loadStructurizrElements = async (filePath) => {
-  const workspace = await loadStructurizrWorkspace(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 ?? 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: `calls external ${label} ${names} without an ACL layer`
-      });
-    }
-  }
-  return violations;
-};
-
-const checkAcyclic = (containers) => {
-  const violations = [];
-  const findCycle = (relations, sourceContainerName, visited = /* @__PURE__ */ new Set()) => {
-    for (const rel of relations) {
-      if (rel.to.name === sourceContainerName) {
-        return true;
-      }
-      if (visited.has(rel.to.name)) continue;
-      visited.add(rel.to.name);
-      if (findCycle(rel.to.relations, sourceContainerName, visited)) {
-        return true;
-      }
-    }
-    return false;
-  };
-  for (const container of containers) {
-    if (findCycle(container.relations, container.name)) {
-      violations.push({
-        container: container.name,
-        message: "participates in a dependency cycle"
-      });
-    }
-  }
-  return violations;
-};
-
-const checkApiGateway = (containers, options) => {
-  const aclTag = options?.aclTag ?? "acl";
-  const externalType = options?.externalType ?? EXTERNAL_SYSTEM_TYPE;
-  const gatewayPattern = options?.gatewayPattern ?? /gateway/i;
-  const violations = [];
-  for (const container of containers) {
-    if (!container.tags?.includes(aclTag)) continue;
-    for (const rel of container.relations) {
-      if (rel.to.type !== externalType) continue;
-      const techs = rel.technology?.split(", ") ?? [];
-      if (!techs.some((t) => gatewayPattern.test(t))) {
-        violations.push({
-          container: container.name,
-          message: `calls external "${rel.to.name}" without going through an API Gateway`
-        });
-      }
-    }
-  }
-  return violations;
-};
-
-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) => names.has(r.to.name)).length;
-  }
-  for (const innerBoundary of boundary.boundaries) {
-    result += getBoundaryCoupling(innerBoundary);
-  }
-  return result;
-};
-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 && !names.has(r.to.name)
-    ).length;
-  }
-  for (const innerBoundary of boundary.boundaries) {
-    for (const container of innerBoundary.containers) {
-      result += container.relations.filter(
-        (r) => r.to.type === externalType
-      ).length;
-    }
-  }
-  return result;
-};
-const checkCohesion = (model, options) => {
-  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);
-    const coupling = getBoundaryCoupling(boundary, externalType, internalType);
-    if (cohesion <= coupling) {
-      violations.push({
-        container: boundary.name,
-        message: `coupling (${coupling}) \u2265 cohesion (${cohesion}) \u2014 more cross-boundary dependencies than internal connections`
-      });
-    }
-    if (boundary.boundaries.length > 0) {
-      const innerCohesionSum = boundary.boundaries.reduce(
-        (sum, current) => sum + getBoundaryCohesion(current),
-        0
-      );
-      if (cohesion >= innerCohesionSum) {
-        violations.push({
-          container: boundary.name,
-          message: `parent cohesion (${cohesion}) \u2265 sum of inner cohesions (${innerCohesionSum}) \u2014 parent boundary should be less cohesive than its sub-boundaries`
-        });
-      }
-    }
-  }
-  return violations;
-};
-
-const buildBoundaryLookup = (model) => {
-  const map = /* @__PURE__ */ new Map();
-  for (const boundary of model.boundaries) {
-    for (const c of boundary.containers) {
-      map.set(c.name, boundary);
-    }
-  }
-  return map;
-};
-const collectPublicAndUsage = (model, boundaryOf) => {
-  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);
-    }
-  }
-  return { publicOf, used };
-};
-const checkCommonReuse = (model) => {
-  const boundaryOf = buildBoundaryLookup(model);
-  const { publicOf, used } = collectPublicAndUsage(model, boundaryOf);
-  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 ?? CONTAINER_DB_TYPE;
-  const violations = [];
-  for (const container of containers) {
-    const dbRelations = container.relations.filter((r) => r.to.type === dbType);
-    const isRepo = repoTags.some((tag) => container.tags?.includes(tag));
-    if (!isRepo && dbRelations.length > 0) {
-      violations.push({
-        container: container.name,
-        message: `directly accesses database ${dbRelations.map((r) => r.to.name).join(", ")} \u2014 add a repo or relay`
-      });
-    }
-    if (isRepo && 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(", ")} \u2014 repos should only access databases`
-      });
-    }
-  }
-  return violations;
-};
-
-const checkDbPerService = (containers, options) => {
-  const dbType = options?.dbType ?? CONTAINER_DB_TYPE;
-  const violations = [];
-  const dbAccessMap = /* @__PURE__ */ new Map();
-  for (const container of containers) {
-    for (const rel of container.relations) {
-      if (rel.to.type === dbType) {
-        const accessors = dbAccessMap.get(rel.to.name) ?? [];
-        accessors.push(container.name);
-        dbAccessMap.set(rel.to.name, accessors);
-      }
-    }
-  }
-  for (const [db, accessors] of dbAccessMap) {
-    if (accessors.length > 1) {
-      violations.push({
-        container: db,
-        message: `shared between ${accessors.join(", ")} \u2014 each database should have a single owner`
-      });
-    }
-  }
-  return violations;
-};
-
-const computeCoupling = (internal, internalNames) => {
-  const ca = /* @__PURE__ */ new Map();
-  const ce = /* @__PURE__ */ new Map();
-  for (const c of internal) {
-    ca.set(c.name, 0);
-    ce.set(c.name, 0);
-  }
-  for (const c of internal) {
-    for (const rel of c.relations) {
-      if (!internalNames.has(rel.to.name)) continue;
-      ce.set(c.name, ce.get(c.name) + 1);
-      ca.set(rel.to.name, ca.get(rel.to.name) + 1);
-    }
-  }
-  return { ca, ce };
-};
-const checkStableDependencies = (containers, options) => {
-  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));
-  const { ca, ce } = computeCoupling(internal, internalNames);
-  const instability = (name) => {
-    const afferent = ca.get(name);
-    const efferent = ce.get(name);
-    if (afferent + efferent === 0) return 1;
-    return efferent / (afferent + efferent);
-  };
-  for (const c of internal) {
-    for (const rel of c.relations) {
-      if (!internalNames.has(rel.to.name)) continue;
-      const iSource = instability(c.name);
-      const iTarget = instability(rel.to.name);
-      if (iSource < iTarget) {
-        violations.push({
-          container: c.name,
-          message: `stable module (I=${iSource.toFixed(2)}) depends on less stable "${rel.to.name}" (I=${iTarget.toFixed(2)}) \u2014 dependencies should point toward stability`
-        });
-      }
-    }
-  }
-  return violations;
-};
-
-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 };