aact 2.1.4 → 3.0.0-beta.2

package/dist/index.mjs

@@ -1,92 +1,8 @@
-export { A as AactConfigSchema, B as BOUNDARY_TYPE, C as COMPONENT_TYPE, a as CONTAINER_BOUNDARY_TYPE, b as CONTAINER_DB_TYPE, c as CONTAINER_TYPE, E as EXTERNAL_SYSTEM_TYPE, P as PERSON_TYPE, d as PLANTUML_BOUNDARY, e as PLANTUML_COMPONENT, f as PLANTUML_CONTAINER, g as PLANTUML_CONTAINER_BOUNDARY, h as PLANTUML_CONTAINER_DB, i as PLANTUML_PERSON, j as PLANTUML_SYSTEM, k as PLANTUML_SYSTEM_BOUNDARY, l as PLANTUML_SYSTEM_EXT, S as STRUCTURIZR_INTERACTION_ASYNC, m as STRUCTURIZR_LOCATION_EXTERNAL, n as STRUCTURIZR_TAG_ASYNC, o as SYSTEM_BOUNDARY_TYPE, p as SYSTEM_TYPE, q as analyzeArchitecture, r as checkAcl, s as checkAcyclic, t as checkApiGateway, u as checkCohesion, v as checkCommonReuse, w as checkCrud, x as checkDbPerService, y as checkStableDependencies, z as defineConfig, D as generateKubernetes, F as generatePlantumlFromModel, G as loadPlantumlElements, H as loadStructurizrElements, I as loadStructurizrWorkspace, J as mapContainersFromPlantumlElements, K as mapContainersFromStructurizr, L as structurizrDslSyntax } from './shared/aact.BzhD7c9t.mjs';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import YAML from 'yaml';
+export { A as AactConfigSchema, a as aclRule, b as acyclicRule, c as allBoundaries, d as allContainers, e as analyzeArchitecture, f as apiGatewayRule, g as applyEdits, h as canFix, i as canGenerate, j as canLoad, k as cohesionRule, l as commonReuseRule, m as crudRule, n as dbPerServiceRule, o as defineConfig, p as getBoundary, q as getContainer, r as knownFormatNames, s as loadFormat, t as ruleRegistry, u as stableDependenciesRule, v as targetOf, w as walkBoundaries } from './shared/aact.CxegP3pU.mjs';
+export { b as buildModel, i as isDuplicateContainer, v as validateModel } from './shared/aact.CfImn7en.mjs';
 import 'valibot';
-import 'plantuml-parser';
+import 'consola';
 
-const DEFAULT_DEPLOYS_PATH = path.join("resources/kubernetes", "microservices");
-const DEFAULT_EXCLUDE = ["migrator", "platform", "citest", "tests"];
-const getMicroserviceFilepaths = async (options) => {
-  const exclude = options?.exclude ?? DEFAULT_EXCLUDE;
-  const resolvedPath = path.resolve(
-    process.cwd(),
-    options?.path ?? DEFAULT_DEPLOYS_PATH
-  );
-  const filenames = (await fs.readdir(resolvedPath, "utf8")).filter(
-    (filename) => (/* @__PURE__ */ new Set([".yml", ".yaml"])).has(path.extname(filename))
-  ).filter(
-    (filename) => exclude.every((toExclude) => !filename.includes(toExclude))
-  );
-  return filenames.map((filename) => path.join(resolvedPath, filename));
-};
-const loadMicroserviceDeployConfigs = async (options) => {
-  const filepaths = await getMicroserviceFilepaths(options);
-  return Promise.all(
-    filepaths.map(async (filePath) => {
-      const content = await fs.readFile(filePath, "utf8");
-      let parsed = YAML.parse(
-        content.replaceAll("env:", "environment:")
-      );
-      if (parsed.microservice) parsed = parsed.microservice;
-      parsed.fileName = path.parse(filePath).name;
-      return parsed;
-    })
-  );
-};
+const defineRule = (rule) => rule;
 
-const DEFAULT_ENV_WHITELIST = [
-  "BASE_URL",
-  "PROTOCOL",
-  "_TOPIC",
-  "__BaseAddress",
-  "__Endpoint",
-  "__SmtpServer",
-  "QueueName"
-];
-const DEFAULT_ENV_CLEANUP = [
-  "_BASE_URL",
-  "_API",
-  "_CLIENT",
-  "_PROTOCOL",
-  /_KAFKA_(?:[A-Z]+_)+TOPIC/
-];
-const mapFromConfig = (deployConfig, options) => {
-  const envWhitelist = options?.envWhitelist ?? DEFAULT_ENV_WHITELIST;
-  const envNamePartsToCleanup = options?.envNamePartsToCleanup ?? DEFAULT_ENV_CLEANUP;
-  const synonymes = /* @__PURE__ */ new Map([]);
-  const environment = deployConfig?.environment ?? {};
-  const envKeys = Object.keys(environment);
-  const filteredEnvKeys = envKeys.filter(
-    (envName) => envWhitelist.some(
-      (white) => typeof white === "string" ? envName.includes(white) : white.exec(envName) !== null
-    )
-  );
-  const sections = filteredEnvKeys.map((envName) => {
-    const value = environment[envName];
-    return {
-      prod_value: value?.prod ?? value?.default ?? "",
-      name: envNamePartsToCleanup.reduce(
-        (acc, partToCleanup) => acc.replace(partToCleanup, ""),
-        envName
-      )
-    };
-  }).map((relation) => {
-    relation.name = relation.name.toLowerCase();
-    for (const entry of synonymes.entries()) {
-      if (entry[1].includes(relation.name)) relation.name = entry[0];
-    }
-    return relation;
-  });
-  deployConfig.name = (deployConfig.name ?? deployConfig.fileName).replaceAll(
-    /[\s\-()]/g,
-    "_"
-  );
-  deployConfig.sections = sections;
-  return deployConfig;
-};
-const mapFromConfigs = (deployConfigs, options) => {
-  return deployConfigs.map((c) => mapFromConfig(c, options)).sort((a, b) => a.name.localeCompare(b.name));
-};
-
-export { loadMicroserviceDeployConfigs, mapFromConfigs };
+export { defineRule };

package/dist/shared/aact.BpV1UCZJ.mjs

@@ -0,0 +1,3 @@
+const parseCsvTags = (raw) => raw?.split(/[,+]/).map((t) => t.trim()).filter(Boolean) ?? [];
+
+export { parseCsvTags as p };

package/dist/shared/aact.CfImn7en.mjs

@@ -0,0 +1,138 @@
+const KNOWN_KINDS = /* @__PURE__ */ new Set([
+  "Person",
+  "System",
+  "Container",
+  "ContainerDb",
+  "ContainerQueue",
+  "Component",
+  "ComponentDb",
+  "ComponentQueue"
+]);
+const validateModel = (model) => {
+  const issues = [];
+  for (const container of Object.values(model.containers)) {
+    if (!KNOWN_KINDS.has(container.kind)) {
+      issues.push({
+        kind: "unknown-kind",
+        container: container.name,
+        raw: container.kind
+      });
+    }
+    for (const rel of container.relations) {
+      if (rel.to === container.name) {
+        issues.push({ kind: "self-relation", container: container.name });
+        continue;
+      }
+      if (!(rel.to in model.containers)) {
+        issues.push({
+          kind: "dangling-relation",
+          from: container.name,
+          to: rel.to
+        });
+      }
+    }
+  }
+  for (const boundary of Object.values(model.boundaries)) {
+    for (const containerName of boundary.containerNames) {
+      if (!(containerName in model.containers)) {
+        issues.push({
+          kind: "container-in-boundary-not-in-model",
+          container: containerName,
+          boundary: boundary.name
+        });
+      }
+    }
+    for (const childName of boundary.boundaryNames) {
+      if (!(childName in model.boundaries)) {
+        issues.push({
+          kind: "boundary-not-in-model",
+          parent: boundary.name,
+          child: childName
+        });
+      }
+    }
+  }
+  detectBoundaryCycles(model, issues);
+  return issues;
+};
+const detectBoundaryCycles = (model, issues) => {
+  const WHITE = 0;
+  const GRAY = 1;
+  const BLACK = 2;
+  const color = /* @__PURE__ */ new Map();
+  const parent = /* @__PURE__ */ new Map();
+  const visit = (name) => {
+    color.set(name, GRAY);
+    const b = model.boundaries[name];
+    if (b) {
+      for (const child of b.boundaryNames) {
+        const c = color.get(child) ?? WHITE;
+        if (c === GRAY) {
+          const path = [child];
+          let cursor = name;
+          while (cursor !== void 0 && cursor !== child) {
+            path.unshift(cursor);
+            cursor = parent.get(cursor);
+          }
+          if (cursor === child) path.unshift(child);
+          return path;
+        }
+        if (c === WHITE) {
+          parent.set(child, name);
+          const cyclePath = visit(child);
+          if (cyclePath) return cyclePath;
+        }
+      }
+    }
+    color.set(name, BLACK);
+    return void 0;
+  };
+  const seenCycles = /* @__PURE__ */ new Set();
+  for (const root of Object.keys(model.boundaries)) {
+    if ((color.get(root) ?? WHITE) !== WHITE) continue;
+    const cyclePath = visit(root);
+    if (cyclePath) {
+      const sig = [...cyclePath].toSorted((a, b) => a.localeCompare(b)).join(",");
+      if (!seenCycles.has(sig)) {
+        seenCycles.add(sig);
+        issues.push({ kind: "boundary-cycle", path: cyclePath });
+      }
+    }
+  }
+};
+const isDuplicateContainer = (containers, name) => name in containers;
+
+const buildModel = (input) => {
+  const issues = [...input.preIssues ?? []];
+  const containerMap = /* @__PURE__ */ Object.create(null);
+  for (const c of [...input.containers].toSorted(
+    (a, b) => a.name.localeCompare(b.name)
+  )) {
+    if (c.name in containerMap) {
+      issues.push({ kind: "duplicate-container-name", name: c.name });
+      continue;
+    }
+    containerMap[c.name] = c;
+  }
+  const boundaryMap = /* @__PURE__ */ Object.create(null);
+  for (const b of [...input.boundaries].toSorted(
+    (x, y) => x.name.localeCompare(y.name)
+  )) {
+    if (b.name in boundaryMap) {
+      issues.push({ kind: "duplicate-boundary-name", name: b.name });
+      continue;
+    }
+    boundaryMap[b.name] = b;
+  }
+  const model = Object.freeze({
+    containers: Object.freeze(containerMap),
+    boundaries: Object.freeze(boundaryMap),
+    rootBoundaryNames: Object.freeze([...input.rootBoundaryNames])
+  });
+  return {
+    model,
+    issues: Object.freeze([...issues, ...validateModel(model)])
+  };
+};
+
+export { buildModel as b, isDuplicateContainer as i, validateModel as v };