@fairfox/polly 0.3.8 → 0.4.1

package/dist/vendor/visualize/src/cli.js

@@ -2001,6 +2001,7 @@ class ArchitectureAnalyzer {
     const adrs = extractADRs(this.options.projectRoot);
     const repository = this.extractRepositoryInfo();
     return {
+      projectRoot: this.options.projectRoot,
       system: systemInfo,
       manifest,
       projectConfig,
@@ -2056,6 +2057,93 @@ async function analyzeArchitecture(options) {
   return analyzer.analyze();
 }
 
+// vendor/visualize/src/types/structurizr.ts
+var DEFAULT_COLORS = {
+  messageHandler: "#1168bd",
+  queryHandler: "#51cf66",
+  commandHandler: "#ff922b",
+  authHandler: "#ff6b6b",
+  subscribeHandler: "#845ef7",
+  service: "#95a5a6",
+  repository: "#74b9ff",
+  database: "#0984e3",
+  externalSystem: "#e17055",
+  container: "#6c5ce7",
+  deployment: "#00b894",
+  textLight: "#ffffff",
+  textDark: "#2d3436",
+  relationship: "#707070"
+};
+var DEFAULT_ELEMENT_STYLES = {
+  "Message Handler": {
+    shape: "Hexagon",
+    background: DEFAULT_COLORS.messageHandler,
+    color: DEFAULT_COLORS.textLight,
+    fontSize: 14
+  },
+  Query: {
+    background: DEFAULT_COLORS.queryHandler,
+    color: DEFAULT_COLORS.textDark
+  },
+  Command: {
+    background: DEFAULT_COLORS.commandHandler,
+    color: DEFAULT_COLORS.textDark
+  },
+  Authentication: {
+    background: DEFAULT_COLORS.authHandler,
+    color: DEFAULT_COLORS.textLight
+  },
+  Subscribe: {
+    background: DEFAULT_COLORS.subscribeHandler,
+    color: DEFAULT_COLORS.textLight
+  },
+  Service: {
+    shape: "RoundedBox",
+    background: DEFAULT_COLORS.service,
+    color: DEFAULT_COLORS.textLight
+  },
+  Repository: {
+    shape: "Cylinder",
+    background: DEFAULT_COLORS.repository,
+    color: DEFAULT_COLORS.textDark
+  },
+  Database: {
+    shape: "Cylinder",
+    background: DEFAULT_COLORS.database,
+    color: DEFAULT_COLORS.textLight
+  },
+  "External System": {
+    background: DEFAULT_COLORS.externalSystem,
+    color: DEFAULT_COLORS.textLight
+  },
+  Container: {
+    background: DEFAULT_COLORS.container,
+    color: DEFAULT_COLORS.textLight
+  }
+};
+var DEFAULT_RELATIONSHIP_STYLES = {
+  Relationship: {
+    routing: "Orthogonal",
+    thickness: 2,
+    color: DEFAULT_COLORS.relationship,
+    fontSize: 12
+  },
+  Sync: {
+    style: "Solid",
+    thickness: 2
+  },
+  Async: {
+    style: "Dashed",
+    thickness: 2
+  },
+  Database: {
+    style: "Solid",
+    thickness: 3,
+    color: DEFAULT_COLORS.database
+  }
+};
+var DEFAULT_THEME = "https://static.structurizr.com/themes/default/theme.json";
+
 // vendor/visualize/src/codegen/structurizr.ts
 class StructurizrDSLGenerator {
   analysis;
@@ -2066,8 +2154,25 @@ class StructurizrDSLGenerator {
       includeDynamicDiagrams: true,
       includeComponentDiagrams: true,
       componentDiagramContexts: ["background"],
-      theme: "https://static.structurizr.com/themes/default",
-      ...options
+      includeDefaultStyles: true,
+      relationships: [],
+      properties: {},
+      groups: [],
+      dynamicDiagrams: [],
+      perspectives: {},
+      deploymentNodes: [],
+      ...options,
+      styles: {
+        theme: options.styles?.theme || DEFAULT_THEME,
+        elements: {
+          ...DEFAULT_ELEMENT_STYLES,
+          ...options.styles?.elements
+        },
+        relationships: {
+          ...DEFAULT_RELATIONSHIP_STYLES,
+          ...options.styles?.relationships
+        }
+      }
     };
   }
   generate() {
@@ -2100,6 +2205,9 @@ class StructurizrDSLGenerator {
     parts.push(this.generatePeople());
     parts.push(this.generateExternalSystems());
     parts.push(this.generateMainSystem());
+    if (this.options.deploymentNodes && this.options.deploymentNodes.length > 0) {
+      parts.push(this.generateDeploymentEnvironments());
+    }
     parts.push("  }");
     return parts.join(`
 
@@ -2155,6 +2263,7 @@ class StructurizrDSLGenerator {
   }
   generateComponents(contextType, contextInfo) {
     const parts = [];
+    const componentDefs = [];
     const handlersByType = new Map;
     for (const handler of contextInfo.handlers) {
       if (!handlersByType.has(handler.messageType)) {
@@ -2166,11 +2275,22 @@ class StructurizrDSLGenerator {
       const componentName = this.toComponentName(messageType);
       const description = this.generateComponentDescription(messageType, handlers[0]);
       const tags = this.getComponentTags(messageType, handlers[0]);
-      parts.push(`        ${this.toId(componentName)} = component "${componentName}" "${description}" {`);
-      if (tags.length > 0) {
-        parts.push(`          tags "${tags.join('" "')}"`);
+      const properties = this.getComponentProperties(messageType, handlers[0], contextType);
+      componentDefs.push({
+        id: this.toId(componentName),
+        name: componentName,
+        description,
+        tags,
+        properties,
+        messageType
+      });
+    }
+    if (this.options.groups && this.options.groups.length > 0) {
+      parts.push(...this.generateGroupedComponents(componentDefs, this.options.groups));
+    } else {
+      for (const comp of componentDefs) {
+        parts.push(this.generateComponentDefinition(comp, "        "));
       }
-      parts.push(`        }`);
     }
     if (contextInfo.components) {
       for (const comp of contextInfo.components) {
@@ -2241,6 +2361,44 @@ class StructurizrDSLGenerator {
     }
     return tags;
   }
+  getComponentProperties(messageType, handler, contextType) {
+    const properties = {};
+    if (handler.location) {
+      const relativePath = handler.location.file.replace(this.analysis.projectRoot + "/", "");
+      properties["Source"] = `${relativePath}:${handler.location.line}`;
+    }
+    const technologies = ["TypeScript"];
+    if (handler.location?.file.includes("ws") || contextType === "server") {
+      technologies.push("WebSocket");
+    }
+    if (handler.location?.file.includes("socket.io")) {
+      technologies.push("Socket.IO");
+    }
+    if (handler.location?.file.includes("elysia")) {
+      technologies.push("Elysia");
+    }
+    properties["Technology"] = technologies.join(", ");
+    const type = messageType.toLowerCase();
+    let pattern = "Message Handler";
+    if (type.includes("query") || type.includes("get") || type.includes("fetch") || type.includes("load")) {
+      pattern = "Query Handler";
+      properties["Message Type"] = "Query";
+    } else if (type.includes("command") || type.includes("add") || type.includes("create") || type.includes("update") || type.includes("delete") || type.includes("remove")) {
+      pattern = "Command Handler";
+      properties["Message Type"] = "Command";
+    } else if (type.includes("auth") || type.includes("login") || type.includes("logout")) {
+      pattern = "Authentication Handler";
+      properties["Message Type"] = "Authentication";
+    } else if (type.includes("subscribe") || type.includes("watch") || type.includes("listen")) {
+      pattern = "Subscription Handler";
+      properties["Message Type"] = "Subscription";
+    }
+    properties["Pattern"] = pattern;
+    if (this.options.properties && this.options.properties[messageType]) {
+      Object.assign(properties, this.options.properties[messageType]);
+    }
+    return properties;
+  }
   generateComponentRelationships(contextType, contextInfo) {
     const parts = [];
     const handlersByType = new Map;
@@ -2271,6 +2429,21 @@ class StructurizrDSLGenerator {
         }
       }
     }
+    if (this.options.relationships && this.options.relationships.length > 0) {
+      for (const rel of this.options.relationships) {
+        const fromId = this.toId(rel.from);
+        const toId = this.toId(rel.to);
+        const description = this.escape(rel.description);
+        parts.push(`        ${fromId} -> ${toId} "${description}" {`);
+        if (rel.technology) {
+          parts.push(`          technology "${this.escape(rel.technology)}"`);
+        }
+        if (rel.tags && rel.tags.length > 0) {
+          parts.push(`          tags "${rel.tags.join('" "')}"`);
+        }
+        parts.push(`        }`);
+      }
+    }
     const stateHandlers = [];
     const queryHandlers = [];
     for (const [messageType, handlers] of handlersByType) {
@@ -2339,6 +2512,9 @@ class StructurizrDSLGenerator {
     if (this.options.includeDynamicDiagrams) {
       parts.push(this.generateDynamicViews());
     }
+    if (this.options.deploymentNodes && this.options.deploymentNodes.length > 0) {
+      parts.push(this.generateDeploymentViews());
+    }
     parts.push(this.generateStyles());
     parts.push("  }");
     if (this.analysis.adrs && this.analysis.adrs.adrs.length > 0) {
@@ -2387,6 +2563,11 @@ class StructurizrDSLGenerator {
   }
   generateDynamicViews() {
     const parts = [];
+    if (this.options.dynamicDiagrams && this.options.dynamicDiagrams.length > 0) {
+      for (const diagram of this.options.dynamicDiagrams) {
+        parts.push(this.generateUserDynamicDiagram(diagram));
+      }
+    }
     const flowsByDomain = new Map;
     for (const flow of this.analysis.messageFlows) {
       const messageType = flow.messageType.toLowerCase();
@@ -2413,6 +2594,20 @@ class StructurizrDSLGenerator {
     }
     return parts.join(`
 
+`);
+  }
+  generateUserDynamicDiagram(diagram) {
+    const parts = [];
+    parts.push(`    dynamic ${diagram.scope || "extension"} "${this.escape(diagram.title)}" "${this.escape(diagram.description || "")}" {`);
+    for (const step of diagram.steps) {
+      const from = step.from;
+      const to = step.to;
+      const description = this.escape(step.description);
+      parts.push(`      ${from} -> ${to} "${description}"`);
+    }
+    parts.push("      autoLayout lr");
+    parts.push("    }");
+    return parts.join(`
 `);
   }
   generateDynamicView(flowName, flows, domain) {
@@ -2475,27 +2670,176 @@ class StructurizrDSLGenerator {
       return "Clear items";
     return messageType;
   }
+  generateDeploymentEnvironments() {
+    const parts = [];
+    const nodesByEnvironment = new Map;
+    for (const node of this.options.deploymentNodes || []) {
+      const env = node.tags?.find((tag) => tag.toLowerCase().includes("environment:"))?.split(":")[1] || "Production";
+      if (!nodesByEnvironment.has(env)) {
+        nodesByEnvironment.set(env, []);
+      }
+      nodesByEnvironment.get(env).push(node);
+    }
+    for (const [envName, nodes] of nodesByEnvironment) {
+      parts.push(`    deploymentEnvironment "${envName}" {`);
+      for (const node of nodes) {
+        parts.push(this.generateDeploymentNode(node, "      "));
+      }
+      parts.push("    }");
+    }
+    return parts.join(`
+`);
+  }
+  generateDeploymentNode(node, indent) {
+    const parts = [];
+    const description = node.description ? ` "${this.escape(node.description)}"` : "";
+    const technology = node.technology ? ` "${this.escape(node.technology)}"` : "";
+    parts.push(`${indent}deploymentNode "${this.escape(node.name)}"${description}${technology} {`);
+    if (node.tags && node.tags.length > 0) {
+      const filteredTags = node.tags.filter((tag) => !tag.toLowerCase().includes("environment:"));
+      if (filteredTags.length > 0) {
+        parts.push(`${indent}  tags "${filteredTags.join('" "')}"`);
+      }
+    }
+    if (node.properties && Object.keys(node.properties).length > 0) {
+      parts.push(`${indent}  properties {`);
+      for (const [key, value] of Object.entries(node.properties)) {
+        parts.push(`${indent}    "${this.escape(key)}" "${this.escape(value)}"`);
+      }
+      parts.push(`${indent}  }`);
+    }
+    if (node.children && node.children.length > 0) {
+      for (const child of node.children) {
+        parts.push(this.generateDeploymentNode(child, indent + "  "));
+      }
+    }
+    if (node.containerInstances && node.containerInstances.length > 0) {
+      for (const containerInstance of node.containerInstances) {
+        const instancesStr = containerInstance.instances && containerInstance.instances > 1 ? ` ${containerInstance.instances}` : "";
+        parts.push(`${indent}  containerInstance extension.${containerInstance.container}${instancesStr}`);
+      }
+    } else if (!node.children || node.children.length === 0) {
+      const contexts = Object.keys(this.analysis.contexts);
+      if (contexts.length > 0) {
+        for (const contextType of contexts) {
+          parts.push(`${indent}  containerInstance extension.${contextType}`);
+        }
+      }
+    }
+    parts.push(`${indent}}`);
+    return parts.join(`
+`);
+  }
+  generateDeploymentViews() {
+    const parts = [];
+    const nodesByEnvironment = new Map;
+    for (const node of this.options.deploymentNodes || []) {
+      const env = node.tags?.find((tag) => tag.toLowerCase().includes("environment:"))?.split(":")[1] || "Production";
+      if (!nodesByEnvironment.has(env)) {
+        nodesByEnvironment.set(env, []);
+      }
+      nodesByEnvironment.get(env).push(node);
+    }
+    for (const [envName] of nodesByEnvironment) {
+      const description = `${envName} environment deployment architecture`;
+      parts.push(`    deployment extension "${envName}" "${description}" {`);
+      parts.push("      include *");
+      parts.push("      autoLayout lr");
+      parts.push("    }");
+    }
+    return parts.join(`
+
+`);
+  }
   generateStyles() {
     const parts = [];
     parts.push("    styles {");
-    const contextStyles = {
-      background: "#2E7D32",
-      content: "#F57C00",
-      popup: "#1976D2",
-      devtools: "#7B1FA2",
-      options: "#0288D1",
-      ...this.options.styles
-    };
-    for (const [context, color] of Object.entries(contextStyles)) {
-      if (this.analysis.contexts[context]) {
-        parts.push(`      element "extension.${context}" {`);
-        parts.push(`        background ${color}`);
-        parts.push(`        color #ffffff`);
-        parts.push("      }");
+    if (this.options.includeDefaultStyles && this.options.styles?.elements) {
+      for (const [tag, style] of Object.entries(this.options.styles.elements)) {
+        parts.push(this.generateElementStyle(tag, style));
       }
     }
+    if (this.options.includeDefaultStyles && this.options.styles?.relationships) {
+      for (const [tag, style] of Object.entries(this.options.styles.relationships)) {
+        parts.push(this.generateRelationshipStyle(tag, style));
+      }
+    }
+    if (this.options.styles?.theme) {
+      parts.push(`      theme ${this.options.styles.theme}`);
+    }
     parts.push("    }");
     return parts.join(`
+`);
+  }
+  generateElementStyle(tag, style) {
+    const parts = [];
+    parts.push(`      element "${tag}" {`);
+    if (style.shape) {
+      parts.push(`        shape ${style.shape}`);
+    }
+    if (style.icon) {
+      parts.push(`        icon ${style.icon}`);
+    }
+    if (style.width) {
+      parts.push(`        width ${style.width}`);
+    }
+    if (style.height) {
+      parts.push(`        height ${style.height}`);
+    }
+    if (style.background) {
+      parts.push(`        background ${style.background}`);
+    }
+    if (style.color) {
+      parts.push(`        color ${style.color}`);
+    }
+    if (style.fontSize) {
+      parts.push(`        fontSize ${style.fontSize}`);
+    }
+    if (style.border) {
+      parts.push(`        border ${style.border}`);
+    }
+    if (style.opacity !== undefined) {
+      parts.push(`        opacity ${style.opacity}`);
+    }
+    if (style.metadata !== undefined) {
+      parts.push(`        metadata ${style.metadata}`);
+    }
+    if (style.description !== undefined) {
+      parts.push(`        description ${style.description}`);
+    }
+    parts.push("      }");
+    return parts.join(`
+`);
+  }
+  generateRelationshipStyle(tag, style) {
+    const parts = [];
+    parts.push(`      relationship "${tag}" {`);
+    if (style.thickness) {
+      parts.push(`        thickness ${style.thickness}`);
+    }
+    if (style.color) {
+      parts.push(`        color ${style.color}`);
+    }
+    if (style.style) {
+      parts.push(`        style ${style.style}`);
+    }
+    if (style.routing) {
+      parts.push(`        routing ${style.routing}`);
+    }
+    if (style.fontSize) {
+      parts.push(`        fontSize ${style.fontSize}`);
+    }
+    if (style.width) {
+      parts.push(`        width ${style.width}`);
+    }
+    if (style.position) {
+      parts.push(`        position ${style.position}`);
+    }
+    if (style.opacity !== undefined) {
+      parts.push(`        opacity ${style.opacity}`);
+    }
+    parts.push("      }");
+    return parts.join(`
 `);
   }
   getContextTechnology(contextType) {
@@ -2521,6 +2865,54 @@ class StructurizrDSLGenerator {
   capitalize(str) {
     return str.charAt(0).toUpperCase() + str.slice(1);
   }
+  generateComponentDefinition(comp, indent) {
+    const parts = [];
+    parts.push(`${indent}${comp.id} = component "${comp.name}" "${this.escape(comp.description)}" {`);
+    if (comp.tags.length > 0) {
+      parts.push(`${indent}  tags "${comp.tags.join('" "')}"`);
+    }
+    if (comp.properties && Object.keys(comp.properties).length > 0) {
+      parts.push(`${indent}  properties {`);
+      for (const [key, value] of Object.entries(comp.properties)) {
+        if (value) {
+          parts.push(`${indent}    "${key}" "${this.escape(value)}"`);
+        }
+      }
+      parts.push(`${indent}  }`);
+    }
+    if (this.options.perspectives && this.options.perspectives[comp.id]) {
+      const perspectives = this.options.perspectives[comp.id];
+      parts.push(`${indent}  perspectives {`);
+      for (const perspective of perspectives) {
+        parts.push(`${indent}    "${this.escape(perspective.name)}" "${this.escape(perspective.description)}"`);
+      }
+      parts.push(`${indent}  }`);
+    }
+    parts.push(`${indent}}`);
+    return parts.join(`
+`);
+  }
+  generateGroupedComponents(componentDefs, groups) {
+    const parts = [];
+    const assignedComponents = new Set;
+    for (const group of groups) {
+      const groupComponents = componentDefs.filter((comp) => group.components.includes(comp.id));
+      if (groupComponents.length === 0)
+        continue;
+      parts.push(`        group "${this.escape(group.name)}" {`);
+      for (const comp of groupComponents) {
+        parts.push(this.generateComponentDefinition(comp, "          "));
+        assignedComponents.add(comp.id);
+      }
+      parts.push(`        }`);
+      parts.push("");
+    }
+    const ungroupedComponents = componentDefs.filter((comp) => !assignedComponents.has(comp.id));
+    for (const comp of ungroupedComponents) {
+      parts.push(this.generateComponentDefinition(comp, "        "));
+    }
+    return parts;
+  }
   escape(str) {
     return str.replace(/"/g, "\\\"");
   }
@@ -3007,4 +3399,4 @@ Stack trace:`, COLORS.gray));
   process.exit(1);
 });
 
-//# debugId=78733C0D94700D7D64756E2164756E21
+//# debugId=85D3947587AAAF0E64756E2164756E21