aact 2.1.5 → 3.0.0-beta.3

package/dist/chunks/index2.mjs

@@ -0,0 +1,248 @@
+import fs from 'node:fs/promises';
+import path from 'pathe';
+import { p as parseCsvTags } from '../shared/aact.BpV1UCZJ.mjs';
+import { b as buildModel } from '../shared/aact.CfImn7en.mjs';
+
+const DATABASE_TECHS = Object.freeze([
+  "postgresql",
+  "postgres",
+  "mysql",
+  "mariadb",
+  "mongodb",
+  "mongo",
+  "redis",
+  "elasticsearch",
+  "dynamodb",
+  "cassandra",
+  "sqlite",
+  "oracle",
+  "sqlserver",
+  "mssql",
+  "clickhouse",
+  "snowflake",
+  "bigquery",
+  "database",
+  "db"
+]);
+const QUEUE_TECHS = Object.freeze([
+  "kafka",
+  "rabbitmq",
+  "rabbit",
+  "nats",
+  "sqs",
+  "sns",
+  "amqp",
+  "activemq",
+  "pulsar",
+  "kinesis",
+  "redpanda",
+  "eventbridge",
+  "servicebus"
+]);
+const matchesAny = (text, patterns) => patterns.some((p) => text.includes(p));
+const inferKindFromTechnology = (technology, name) => {
+  const techLower = technology?.toLowerCase() ?? "";
+  const nameLower = name?.toLowerCase() ?? "";
+  if (matchesAny(techLower, DATABASE_TECHS)) return "ContainerDb";
+  if (matchesAny(techLower, QUEUE_TECHS)) return "ContainerQueue";
+  if (nameLower.endsWith(" db") || nameLower.endsWith("_db") || nameLower.endsWith("-db") || nameLower.endsWith("database")) {
+    return "ContainerDb";
+  }
+  if (nameLower.endsWith(" queue") || nameLower.endsWith("_queue") || nameLower.endsWith("-queue") || nameLower.endsWith(" topic") || nameLower.endsWith("_topic")) {
+    return "ContainerQueue";
+  }
+  return "Container";
+};
+
+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 toProperties = (base, group, perspectives) => {
+  const out = {};
+  if (base) {
+    for (const [k, v] of Object.entries(base)) {
+      if (typeof v === "string") out[k] = v;
+    }
+  }
+  if (group !== void 0 && group.length > 0) out.group = group;
+  if (perspectives) {
+    for (const [name, p] of Object.entries(perspectives)) {
+      out[`perspective.${name}`] = p.description;
+      if (p.value !== void 0) out[`perspective.${name}.value`] = p.value;
+    }
+  }
+  if (Object.keys(out).length === 0) return void 0;
+  return Object.freeze(out);
+};
+const isExternal = (system) => system.location === STRUCTURIZR_LOCATION_EXTERNAL || (system.tags?.includes(STRUCTURIZR_LOCATION_EXTERNAL) ?? false);
+const buildPersonContainer = (p) => ({
+  name: dslId(p.id, p.properties),
+  label: p.name,
+  kind: "Person",
+  external: false,
+  description: p.description ?? "",
+  tags: parseCsvTags(p.tags),
+  relations: [],
+  link: p.url,
+  properties: toProperties(p.properties, p.group, p.perspectives)
+});
+const buildExternalSystemContainer = (s) => ({
+  name: dslId(s.id, s.properties),
+  label: s.name,
+  kind: "System",
+  external: true,
+  description: s.description ?? "",
+  tags: parseCsvTags(s.tags),
+  relations: [],
+  link: s.url,
+  properties: toProperties(s.properties, s.group, s.perspectives)
+});
+const buildContainer = (c) => ({
+  name: dslId(c.id, c.properties),
+  label: c.name,
+  kind: inferKindFromTechnology(c.technology, c.name),
+  external: false,
+  description: c.description ?? "",
+  technology: c.technology,
+  tags: parseCsvTags(c.tags),
+  relations: [],
+  link: c.url,
+  properties: toProperties(c.properties, c.group, c.perspectives)
+});
+const buildSystemBoundary = (s) => ({
+  name: dslId(s.id, s.properties),
+  label: s.name,
+  kind: "System",
+  description: s.description,
+  tags: parseCsvTags(s.tags),
+  containerNames: (s.containers ?? []).map((c) => dslId(c.id, c.properties)),
+  boundaryNames: [],
+  link: s.url,
+  properties: toProperties(s.properties, s.group, s.perspectives)
+});
+const buildRelation = (rel, targetName) => {
+  const baseTags = parseCsvTags(rel.tags);
+  const tags = rel.interactionStyle === STRUCTURIZR_INTERACTION_ASYNC ? [...baseTags, STRUCTURIZR_TAG_ASYNC] : baseTags;
+  return {
+    to: targetName,
+    description: rel.description,
+    technology: rel.technology,
+    tags,
+    link: rel.url,
+    properties: toProperties(rel.properties, void 0, rel.perspectives)
+  };
+};
+const load = async (filePath) => {
+  const filepath = path.resolve(filePath);
+  const data = await fs.readFile(filepath, "utf8");
+  const workspace = JSON.parse(data);
+  const containers = [];
+  const boundaries = [];
+  const rootBoundaryNames = [];
+  const idToName = /* @__PURE__ */ new Map();
+  const idToContainerName = /* @__PURE__ */ new Map();
+  for (const person of workspace.model.people ?? []) {
+    const c = buildPersonContainer(person);
+    containers.push(c);
+    idToName.set(person.id, c.name);
+    idToContainerName.set(person.id, c.name);
+  }
+  for (const system of workspace.model.softwareSystems ?? []) {
+    if (isExternal(system)) {
+      const c = buildExternalSystemContainer(system);
+      containers.push(c);
+      idToName.set(system.id, c.name);
+      idToContainerName.set(system.id, c.name);
+    } else {
+      const boundary = buildSystemBoundary(system);
+      boundaries.push(boundary);
+      rootBoundaryNames.push(boundary.name);
+      idToName.set(system.id, boundary.name);
+      for (const cont of system.containers ?? []) {
+        const c = buildContainer(cont);
+        containers.push(c);
+        idToName.set(cont.id, c.name);
+        idToContainerName.set(cont.id, c.name);
+      }
+    }
+  }
+  const elementsWithRelations = [];
+  for (const person of workspace.model.people ?? []) {
+    if (person.relationships) {
+      elementsWithRelations.push({
+        sourceId: person.id,
+        relationships: person.relationships
+      });
+    }
+  }
+  for (const system of workspace.model.softwareSystems ?? []) {
+    if (system.relationships) {
+      elementsWithRelations.push({
+        sourceId: system.id,
+        relationships: system.relationships
+      });
+    }
+    for (const cont of system.containers ?? []) {
+      if (cont.relationships) {
+        elementsWithRelations.push({
+          sourceId: cont.id,
+          relationships: cont.relationships
+        });
+      }
+    }
+  }
+  const containersByName = new Map(
+    containers.map((c) => [c.name, c])
+  );
+  for (const { sourceId, relationships } of elementsWithRelations) {
+    const sourceName = idToContainerName.get(sourceId);
+    if (!sourceName || !relationships) continue;
+    const source = containersByName.get(sourceName);
+    if (!source) continue;
+    const newRelations = [...source.relations];
+    for (const rel of relationships) {
+      const targetName = idToName.get(rel.destinationId);
+      if (!targetName) continue;
+      newRelations.push(buildRelation(rel, targetName));
+    }
+    containersByName.set(sourceName, { ...source, relations: newRelations });
+  }
+  return buildModel({
+    containers: [...containersByName.values()],
+    boundaries,
+    rootBoundaryNames
+  });
+};
+
+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 structurizrFormat = {
+  name: "structurizr",
+  defaultPattern: "workspace.json",
+  load,
+  fix: { syntax: structurizrDslSyntax }
+};
+
+export { structurizrFormat };

package/dist/chunks/index3.mjs

@@ -0,0 +1,72 @@
+import YAML from 'yaml';
+
+const toKebab = (name) => name.replaceAll("_", "-");
+const toEnvKey = (name) => name.replaceAll("-", "_").toUpperCase();
+const buildEnvVar = (relation, targetKind, targetExternal, sourceKebab, options) => {
+  const targetKebab = toKebab(relation.to);
+  const targetUpper = toEnvKey(targetKebab);
+  if (targetKind === "ContainerDb") {
+    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 (targetExternal === true) {
+    const value = relation.technology ?? `https://${targetKebab}`;
+    return { key: `${targetUpper}_BASE_URL`, value };
+  }
+  if (targetKind === "Container") {
+    const value = relation.technology ?? `http://${targetKebab}:${options.defaultPort}`;
+    return { key: `${targetUpper}_BASE_URL`, value };
+  }
+  return void 0;
+};
+const generate = (model, options) => {
+  const defaultPort = options?.defaultPort ?? 8080;
+  const dbConnectionTemplate = options?.dbConnectionTemplate ?? "postgresql://{name}:pass-{name}@postgresql:5432/{name}";
+  const resolvedOptions = { defaultPort, dbConnectionTemplate };
+  const containers = Object.values(model.containers).filter(
+    (c) => c.kind === "Container"
+  );
+  const files = containers.map((container) => {
+    const kebabName = toKebab(container.name);
+    const envEntries = [];
+    for (const relation of container.relations) {
+      const target = model.containers[relation.to];
+      const entry = buildEnvVar(
+        relation,
+        target?.kind,
+        target?.external,
+        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 {
+      path: `${kebabName}.yml`,
+      content: YAML.stringify(doc)
+    };
+  });
+  return { files };
+};
+
+const kubernetesFormat = {
+  name: "kubernetes",
+  generate
+};
+
+export { kubernetesFormat };