@agilewallaby/c4-model 2.7.0 → 2.8.0

package/src/index.js

@@ -169,9 +169,9 @@ var Element = class {
   getRelationshipsInHierarchy() {
     return this._relationships.concat(this.getChildElements().flatMap((element) => element.getRelationshipsInHierarchy()));
   }
-  getChildElementNames(path2) {
+  getChildElementNames(path4) {
     const result = Array.from(this.getChildElements()).flatMap((reference) => {
-      const currentPath = `${path2 ? path2 : "" + this.name}.${reference.name}`;
+      const currentPath = `${path4 ? path4 : "" + this.name}.${reference.name}`;
       return [currentPath, ...reference.getChildElementNames(currentPath)];
     });
     return result;
@@ -227,21 +227,46 @@ var Component = class extends TechnicalElement {
 };
 
 // libs/c4-model/src/container.ts
-var ContainerGroup = class extends Group {
-  constructor(name, container) {
+var ContainerGroup = class _ContainerGroup extends Group {
+  constructor(name, container, pathSegments = []) {
     super(name);
     this.name = name;
     this.container = container;
+    this.pathSegments = pathSegments;
   }
   _components = /* @__PURE__ */ new Map();
+  _groups = /* @__PURE__ */ new Map();
+  get canonicalName() {
+    return camelCase([...this.pathSegments, this.name].join(" "));
+  }
+  get dslName() {
+    return [...this.pathSegments, this.name].join("/");
+  }
   component(name, archetypeOrDef, override) {
     const component = this.container.component(name, archetypeOrDef, override);
     this._components.set(name, component);
     return component;
   }
+  group(groupName) {
+    let group = this._groups.get(groupName);
+    if (!group) {
+      group = new _ContainerGroup(groupName, this.container, [...this.pathSegments, this.name]);
+      this._groups.set(groupName, group);
+    }
+    return group;
+  }
+  getGroups() {
+    return Array.from(this._groups.values());
+  }
   getComponents() {
     return Array.from(this._components.values());
   }
+  getAllComponents() {
+    return [
+      ...this._components.values(),
+      ...Array.from(this._groups.values()).flatMap((g) => g.getAllComponents())
+    ];
+  }
 };
 var Container = class extends TechnicalElement {
   constructor(name, definition, archetype, overrideDefinition) {
@@ -278,7 +303,7 @@ var Container = class extends TechnicalElement {
     return Array.from(this._groups.values());
   }
   getComponentsNotInGroups() {
-    const componentsInGroups = this.getGroups().flatMap((group) => group.getComponents());
+    const componentsInGroups = this.getGroups().flatMap((group) => group.getAllComponents());
     return Array.from(this._components.values()).filter((component) => !componentsInGroups.includes(component));
   }
   getChildElements() {
@@ -287,21 +312,46 @@ var Container = class extends TechnicalElement {
 };
 
 // libs/c4-model/src/softwareSystem.ts
-var SoftwareSystemGroup = class extends Group {
-  constructor(name, softwareSystem) {
+var SoftwareSystemGroup = class _SoftwareSystemGroup extends Group {
+  constructor(name, softwareSystem, pathSegments = []) {
     super(name);
     this.name = name;
     this.softwareSystem = softwareSystem;
+    this.pathSegments = pathSegments;
   }
   _containers = /* @__PURE__ */ new Map();
+  _groups = /* @__PURE__ */ new Map();
+  get canonicalName() {
+    return camelCase([...this.pathSegments, this.name].join(" "));
+  }
+  get dslName() {
+    return [...this.pathSegments, this.name].join("/");
+  }
   container(name, archetypeOrDef, override) {
     const container = this.softwareSystem.container(name, archetypeOrDef, override);
     this._containers.set(name, container);
     return container;
   }
+  group(groupName) {
+    let group = this._groups.get(groupName);
+    if (!group) {
+      group = new _SoftwareSystemGroup(groupName, this.softwareSystem, [...this.pathSegments, this.name]);
+      this._groups.set(groupName, group);
+    }
+    return group;
+  }
+  getGroups() {
+    return Array.from(this._groups.values());
+  }
   getContainers() {
     return Array.from(this._containers.values());
   }
+  getAllContainers() {
+    return [
+      ...this._containers.values(),
+      ...Array.from(this._groups.values()).flatMap((g) => g.getAllContainers())
+    ];
+  }
 };
 var SoftwareSystem = class extends Element {
   constructor(name, definition, archetype, overrideDefinition) {
@@ -341,7 +391,7 @@ var SoftwareSystem = class extends Element {
     return Array.from(this._containers.values());
   }
   getContainersNotInGroups() {
-    const containersInGroups = Array.from(this._groups.values()).flatMap((group) => group.getContainers());
+    const containersInGroups = Array.from(this._groups.values()).flatMap((group) => group.getAllContainers());
     return Array.from(this._containers.values()).filter((container) => !containersInGroups.includes(container));
   }
 };
@@ -358,14 +408,22 @@ var Person = class extends Element {
 };
 
 // libs/c4-model/src/model.ts
-var ModelGroup = class extends Group {
-  constructor(name, model) {
+var ModelGroup = class _ModelGroup extends Group {
+  constructor(name, model, pathSegments = []) {
     super(name);
     this.name = name;
     this.model = model;
+    this.pathSegments = pathSegments;
   }
   softwareSystems = /* @__PURE__ */ new Map();
   people = /* @__PURE__ */ new Map();
+  _groups = /* @__PURE__ */ new Map();
+  get canonicalName() {
+    return camelCase([...this.pathSegments, this.name].join(" "));
+  }
+  get dslName() {
+    return [...this.pathSegments, this.name].join("/");
+  }
   softwareSystem(name, archetypeOrDef, override) {
     const softwareSystem = this.model.softwareSystem(name, archetypeOrDef, override);
     this.softwareSystems.set(name, softwareSystem);
@@ -376,12 +434,35 @@ var ModelGroup = class extends Group {
     this.people.set(name, person);
     return person;
   }
+  group(groupName) {
+    let group = this._groups.get(groupName);
+    if (!group) {
+      group = new _ModelGroup(groupName, this.model, [...this.pathSegments, this.name]);
+      this._groups.set(groupName, group);
+    }
+    return group;
+  }
+  getGroups() {
+    return Array.from(this._groups.values());
+  }
   getSoftwareSystems() {
     return Array.from(this.softwareSystems.values());
   }
   getPeople() {
     return Array.from(this.people.values());
   }
+  getAllSoftwareSystems() {
+    return [
+      ...this.softwareSystems.values(),
+      ...Array.from(this._groups.values()).flatMap((g) => g.getAllSoftwareSystems())
+    ];
+  }
+  getAllPeople() {
+    return [
+      ...this.people.values(),
+      ...Array.from(this._groups.values()).flatMap((g) => g.getAllPeople())
+    ];
+  }
 };
 var Model = class {
   constructor(name) {
@@ -406,7 +487,6 @@ var Model = class {
     this.softwareSystems.set(name, system);
     return system;
   }
-  // TODO:Should be a Group<SoftwareSystem | Person> if that is added back in
   group(groupName) {
     let group = this.groups.get(groupName);
     if (!group) {
@@ -441,11 +521,11 @@ var Model = class {
     return Array.from(this.softwareSystems.values());
   }
   getPeopleNotInGroups() {
-    const peopleInGroups = Array.from(this.groups.values()).flatMap((group) => group.getPeople());
+    const peopleInGroups = Array.from(this.groups.values()).flatMap((group) => group.getAllPeople());
     return Array.from(this.people.values()).filter((person) => !peopleInGroups.includes(person));
   }
   getSoftwareSystemsNotInGroups() {
-    const systemsInGroups = Array.from(this.groups.values()).flatMap((group) => group.getSoftwareSystems());
+    const systemsInGroups = Array.from(this.groups.values()).flatMap((group) => group.getAllSoftwareSystems());
     return Array.from(this.softwareSystems.values()).filter((system) => !systemsInGroups.includes(system));
   }
   getGroups() {
@@ -465,6 +545,9 @@ var View = class {
   description;
   title;
   _scopes = [];
+  _autoLayout;
+  _isDefault = false;
+  _properties = /* @__PURE__ */ new Map();
   includeAll() {
     this._scopes.push("include *");
   }
@@ -483,15 +566,37 @@ var View = class {
   excludeExpression(expression) {
     this._scopes.push(`exclude ${expression}`);
   }
+  autoLayout(direction, rankSeparation, nodeSeparation) {
+    this._autoLayout = { direction, rankSeparation, nodeSeparation };
+  }
+  setDefault() {
+    this._isDefault = true;
+  }
+  addProperty(name, value) {
+    this._properties.set(name, value);
+  }
   get scopes() {
     return this._scopes;
   }
+  get autoLayoutConfig() {
+    return this._autoLayout;
+  }
+  get isDefault() {
+    return this._isDefault;
+  }
+  get properties() {
+    return this._properties;
+  }
 };
 var Views = class {
   _systemLandscapeViews = /* @__PURE__ */ new Map();
   _systemContextViews = /* @__PURE__ */ new Map();
   _containerViews = /* @__PURE__ */ new Map();
   _componentViews = /* @__PURE__ */ new Map();
+  _elementStyles = [];
+  _relationshipStyles = [];
+  _themes = [];
+  _properties = /* @__PURE__ */ new Map();
   addSystemLandscapeView(key, definition) {
     const view = new View(key, { subject: void 0, description: definition.description, title: definition.title });
     this._systemLandscapeViews.set(key, view);
@@ -512,6 +617,18 @@ var Views = class {
     this._componentViews.set(key, view);
     return view;
   }
+  addElementStyle(tag, definition) {
+    this._elementStyles.push({ tag, definition });
+  }
+  addRelationshipStyle(tag, definition) {
+    this._relationshipStyles.push({ tag, definition });
+  }
+  addTheme(url) {
+    this._themes.push(url);
+  }
+  addProperty(name, value) {
+    this._properties.set(name, value);
+  }
   get systemLandscapeViews() {
     return Array.from(this._systemLandscapeViews.values());
   }
@@ -524,6 +641,18 @@ var Views = class {
   get componentViews() {
     return Array.from(this._componentViews.values());
   }
+  get elementStyles() {
+    return this._elementStyles;
+  }
+  get relationshipStyles() {
+    return this._relationshipStyles;
+  }
+  get themes() {
+    return this._themes;
+  }
+  get properties() {
+    return this._properties;
+  }
 };
 
 // libs/c4-model/src/structurizrDslWriter.ts
@@ -658,11 +787,17 @@ var StructurizrDSLWriter = class {
   }
   writeContainerGroup(group, level) {
     let containerGroupDsl = "";
-    containerGroupDsl += this.writeLine(`${group.canonicalName} = group "${group.name}" {`, level);
-    group.getComponents().forEach((component) => {
-      containerGroupDsl += this.writeComponent(component, level + 1);
+    const hasDirect = group.getComponents().length > 0;
+    if (hasDirect) {
+      containerGroupDsl += this.writeLine(`${group.canonicalName} = group "${group.dslName}" {`, level);
+      group.getComponents().forEach((component) => {
+        containerGroupDsl += this.writeComponent(component, level + 1);
+      });
+      containerGroupDsl += this.writeLine(`}`, level);
+    }
+    group.getGroups().forEach((nested) => {
+      containerGroupDsl += this.writeContainerGroup(nested, level);
     });
-    containerGroupDsl += this.writeLine(`}`, level);
     return containerGroupDsl;
   }
   writeContainer(container, level) {
@@ -682,11 +817,17 @@ var StructurizrDSLWriter = class {
   }
   writeSoftwareSystemGroup(group, level) {
     let softwareSystemGroupDsl = "";
-    softwareSystemGroupDsl += this.writeLine(`${group.canonicalName} = group "${group.name}" {`, level);
-    group.getContainers().forEach((container) => {
-      softwareSystemGroupDsl += this.writeContainer(container, level + 1);
+    const hasDirect = group.getContainers().length > 0;
+    if (hasDirect) {
+      softwareSystemGroupDsl += this.writeLine(`${group.canonicalName} = group "${group.dslName}" {`, level);
+      group.getContainers().forEach((container) => {
+        softwareSystemGroupDsl += this.writeContainer(container, level + 1);
+      });
+      softwareSystemGroupDsl += this.writeLine(`}`, level);
+    }
+    group.getGroups().forEach((nested) => {
+      softwareSystemGroupDsl += this.writeSoftwareSystemGroup(nested, level);
     });
-    softwareSystemGroupDsl += this.writeLine(`}`, level);
     return softwareSystemGroupDsl;
   }
   writeSoftwareSystem(softwareSystem, level) {
@@ -738,21 +879,51 @@ var StructurizrDSLWriter = class {
     });
     return relationshipsDsl;
   }
+  hasNestedModelGroups(groups) {
+    return groups.some((g) => g.getGroups().length > 0 || this.hasNestedModelGroups(g.getGroups()));
+  }
+  hasNestedSoftwareSystemGroups(groups) {
+    return groups.some((g) => g.getGroups().length > 0 || this.hasNestedSoftwareSystemGroups(g.getGroups()));
+  }
+  hasNestedContainerGroups(groups) {
+    return groups.some((g) => g.getGroups().length > 0 || this.hasNestedContainerGroups(g.getGroups()));
+  }
+  hasNestedGroups() {
+    if (this.hasNestedModelGroups(this.model.getGroups())) return true;
+    for (const ss of this.model.getSoftwareSystems()) {
+      if (this.hasNestedSoftwareSystemGroups(ss.getGroups())) return true;
+      for (const c of ss.getGroups().flatMap((g) => g.getAllContainers())) {
+        if (this.hasNestedContainerGroups(c.getGroups())) return true;
+      }
+    }
+    return false;
+  }
   writeModelGroup(group, level) {
     let modelGroupDsl = "";
-    modelGroupDsl += this.writeLine(`${group.canonicalName} = group "${group.name}" {`, level);
-    group.getPeople().forEach((person) => {
-      modelGroupDsl += this.writeElement("person", person, level + 1);
-    });
-    group.getSoftwareSystems().forEach((softwareSystem) => {
-      modelGroupDsl += this.writeSoftwareSystem(softwareSystem, level + 1);
+    const hasDirect = group.getPeople().length > 0 || group.getSoftwareSystems().length > 0;
+    if (hasDirect) {
+      modelGroupDsl += this.writeLine(`${group.canonicalName} = group "${group.dslName}" {`, level);
+      group.getPeople().forEach((person) => {
+        modelGroupDsl += this.writeElement("person", person, level + 1);
+      });
+      group.getSoftwareSystems().forEach((softwareSystem) => {
+        modelGroupDsl += this.writeSoftwareSystem(softwareSystem, level + 1);
+      });
+      modelGroupDsl += this.writeLine(`}`, level);
+    }
+    group.getGroups().forEach((nested) => {
+      modelGroupDsl += this.writeModelGroup(nested, level);
     });
-    modelGroupDsl += this.writeLine(`}`, level);
     return modelGroupDsl;
   }
   writeModel(model, level) {
     let modelDsl = "";
     modelDsl += this.writeLine(`model {`, level);
+    if (this.hasNestedGroups()) {
+      modelDsl += this.writeLine(`properties {`, level + 1);
+      modelDsl += this.writeLine(`"structurizr.groupSeparator" "/"`, level + 2);
+      modelDsl += this.writeLine(`}`, level + 1);
+    }
     modelDsl += this.writeArchetypes(level + 1);
     modelDsl += this.writeLine("// Elements", level + 1);
     model.getPeopleNotInGroups().forEach((person) => {
@@ -775,12 +946,66 @@ var StructurizrDSLWriter = class {
     if (view.title) {
       viewDsl += this.writeLine(`title "${view.title}"`, level + 1);
     }
+    if (view.isDefault) {
+      viewDsl += this.writeLine("default", level + 1);
+    }
     view.scopes.forEach((scope) => {
       viewDsl += this.writeLine(`${scope}`, level + 1);
     });
+    if (view.autoLayoutConfig) {
+      const { direction, rankSeparation, nodeSeparation } = view.autoLayoutConfig;
+      let line = "autoLayout";
+      if (direction) line += ` ${direction}`;
+      if (rankSeparation !== void 0) line += ` ${rankSeparation}`;
+      if (nodeSeparation !== void 0) line += ` ${nodeSeparation}`;
+      viewDsl += this.writeLine(line, level + 1);
+    }
+    if (view.properties.size > 0) {
+      viewDsl += this.writeLine("properties {", level + 1);
+      for (const [name, value] of view.properties) {
+        viewDsl += this.writeLine(`"${name}" "${value}"`, level + 2);
+      }
+      viewDsl += this.writeLine("}", level + 1);
+    }
     viewDsl += this.writeLine(`}`, level);
     return viewDsl;
   }
+  writeStyles(views, level) {
+    const { elementStyles, relationshipStyles } = views;
+    if (elementStyles.length === 0 && relationshipStyles.length === 0) return "";
+    let dsl = this.writeLine("styles {", level);
+    for (const { tag, definition: d } of elementStyles) {
+      dsl += this.writeLine(`element "${tag}" {`, level + 1);
+      if (d.shape) dsl += this.writeLine(`shape ${d.shape}`, level + 2);
+      if (d.icon) dsl += this.writeLine(`icon "${d.icon}"`, level + 2);
+      if (d.width) dsl += this.writeLine(`width ${d.width}`, level + 2);
+      if (d.height) dsl += this.writeLine(`height ${d.height}`, level + 2);
+      if (d.background) dsl += this.writeLine(`background "${d.background}"`, level + 2);
+      if (d.color) dsl += this.writeLine(`color "${d.color}"`, level + 2);
+      if (d.stroke) dsl += this.writeLine(`stroke "${d.stroke}"`, level + 2);
+      if (d.strokeWidth) dsl += this.writeLine(`strokeWidth ${d.strokeWidth}`, level + 2);
+      if (d.fontSize) dsl += this.writeLine(`fontSize ${d.fontSize}`, level + 2);
+      if (d.border) dsl += this.writeLine(`border ${d.border}`, level + 2);
+      if (d.opacity !== void 0) dsl += this.writeLine(`opacity ${d.opacity}`, level + 2);
+      if (d.metadata !== void 0) dsl += this.writeLine(`metadata ${d.metadata}`, level + 2);
+      if (d.description !== void 0) dsl += this.writeLine(`description ${d.description}`, level + 2);
+      dsl += this.writeLine("}", level + 1);
+    }
+    for (const { tag, definition: d } of relationshipStyles) {
+      dsl += this.writeLine(`relationship "${tag}" {`, level + 1);
+      if (d.thickness) dsl += this.writeLine(`thickness ${d.thickness}`, level + 2);
+      if (d.color) dsl += this.writeLine(`color "${d.color}"`, level + 2);
+      if (d.style) dsl += this.writeLine(`style ${d.style}`, level + 2);
+      if (d.routing) dsl += this.writeLine(`routing ${d.routing}`, level + 2);
+      if (d.fontSize) dsl += this.writeLine(`fontSize ${d.fontSize}`, level + 2);
+      if (d.width) dsl += this.writeLine(`width ${d.width}`, level + 2);
+      if (d.position !== void 0) dsl += this.writeLine(`position ${d.position}`, level + 2);
+      if (d.opacity !== void 0) dsl += this.writeLine(`opacity ${d.opacity}`, level + 2);
+      dsl += this.writeLine("}", level + 1);
+    }
+    dsl += this.writeLine("}", level);
+    return dsl;
+  }
   writeViews(views, level) {
     let viewDsl = "";
     viewDsl += this.writeLine(`views {`, level);
@@ -800,6 +1025,19 @@ var StructurizrDSLWriter = class {
     views.componentViews.forEach((view) => {
       viewDsl += this.writeView(view, "component", level + 1);
     });
+    viewDsl += this.writeStyles(views, level + 1);
+    if (views.themes.length === 1) {
+      viewDsl += this.writeLine(`theme ${views.themes[0]}`, level + 1);
+    } else if (views.themes.length > 1) {
+      viewDsl += this.writeLine(`themes ${views.themes.join(" ")}`, level + 1);
+    }
+    if (views.properties.size > 0) {
+      viewDsl += this.writeLine("properties {", level + 1);
+      for (const [name, value] of views.properties) {
+        viewDsl += this.writeLine(`"${name}" "${value}"`, level + 2);
+      }
+      viewDsl += this.writeLine("}", level + 1);
+    }
     viewDsl += this.writeLine(`}`, level);
     return viewDsl;
   }
@@ -824,8 +1062,8 @@ import { glob } from "glob";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 var _dirname = typeof __dirname !== "undefined" ? __dirname : dirname(fileURLToPath(import.meta.url));
-async function buildModelWithCatalog(options = {}) {
-  const { modelName = "model", modules: explicitModules, archetypes = {} } = options;
+async function buildModel(options = {}) {
+  const { modelName = "model", modules: explicitModules, archetypes = {}, addViews } = options;
   const model = new Model(modelName);
   let c4Modules;
   if (explicitModules) {
@@ -849,14 +1087,16 @@ async function buildModelWithCatalog(options = {}) {
     rootCatalog[instance.key] = local;
     registrations.push({ instance, key: instance.key, local });
   }
+  const dependenciesFor = (key) => Object.fromEntries(Object.entries(rootCatalog).filter(([k]) => k !== key));
   for (const { instance, key, local } of registrations) {
-    const dependencies = Object.fromEntries(Object.entries(rootCatalog).filter(([k]) => k !== key));
-    instance.buildRelationships(local, dependencies, archetypes);
+    instance.addRelationships(local, dependenciesFor(key), archetypes);
   }
-  return { model, catalog: rootCatalog };
-}
-async function buildModel(options = {}) {
-  return (await buildModelWithCatalog(options)).model;
+  const views = new Views();
+  addViews?.(views, rootCatalog);
+  for (const { instance, key, local } of registrations) {
+    instance.addViews?.(views, local, dependenciesFor(key));
+  }
+  return { model, catalog: rootCatalog, views };
 }
 
 // libs/c4-model/src/generateDiagrams.ts
@@ -865,9 +1105,8 @@ import * as os from "os";
 import * as path from "path";
 import { GenericContainer, Wait } from "testcontainers";
 async function generateDiagrams(options) {
-  const { views: viewsFactory, outputDir, ...buildOptions } = options;
-  const { model, catalog } = await buildModelWithCatalog(buildOptions);
-  const views = viewsFactory(catalog);
+  const { outputDir, ...buildOptions } = options;
+  const { model, views } = await buildModel(buildOptions);
   const dsl = new StructurizrDSLWriter(model, views).write();
   const tmpDir = await fs.promises.mkdtemp(path.join(fs.realpathSync(os.tmpdir()), "c4-diagrams-"));
   await fs.promises.writeFile(path.join(tmpDir, "workspace.dsl"), dsl, "utf8");
@@ -888,6 +1127,60 @@ async function generateDiagrams(options) {
   }
   return generatedFiles;
 }
+
+// libs/c4-model/src/validateModel.ts
+import * as fs2 from "fs";
+import * as os2 from "os";
+import * as path2 from "path";
+import { GenericContainer as GenericContainer2, Wait as Wait2 } from "testcontainers";
+async function validateModel(model, views) {
+  const dsl = new StructurizrDSLWriter(model, views).write();
+  const tmpDir = await fs2.promises.mkdtemp(path2.join(fs2.realpathSync(os2.tmpdir()), "c4-validate-"));
+  try {
+    await fs2.promises.writeFile(path2.join(tmpDir, "workspace.dsl"), dsl, "utf8");
+    const logs = [];
+    try {
+      await new GenericContainer2("structurizr/structurizr").withBindMounts([{ source: tmpDir, target: "/workspace", mode: "rw" }]).withCommand(["validate", "-workspace", "/workspace/workspace.dsl"]).withWaitStrategy(Wait2.forOneShotStartup()).withLogConsumer((stream) => stream.on("data", (chunk) => logs.push(chunk.toString()))).start();
+    } catch {
+      throw new Error(`Structurizr validation failed:
+${logs.join("")}`);
+    }
+  } finally {
+    await fs2.promises.rm(tmpDir, { recursive: true, force: true });
+  }
+}
+
+// libs/c4-model/src/exportWorkspaceJson.ts
+import * as fs3 from "fs";
+import * as os3 from "os";
+import * as path3 from "path";
+import { GenericContainer as GenericContainer3, Wait as Wait3 } from "testcontainers";
+async function exportWorkspaceJsonFromDsl(dsl) {
+  const tmpDir = await fs3.promises.mkdtemp(path3.join(fs3.realpathSync(os3.tmpdir()), "c4-export-"));
+  try {
+    await fs3.promises.writeFile(path3.join(tmpDir, "workspace.dsl"), dsl, "utf8");
+    const logs = [];
+    try {
+      await new GenericContainer3("structurizr/structurizr").withBindMounts([{ source: tmpDir, target: "/workspace", mode: "rw" }]).withCommand(["export", "-w", "/workspace/workspace.dsl", "-f", "json", "-o", "/workspace"]).withWaitStrategy(Wait3.forOneShotStartup()).withLogConsumer((stream) => stream.on("data", (chunk) => logs.push(chunk.toString()))).start();
+    } catch {
+      throw new Error(`Structurizr JSON export failed:
+${logs.join("")}`);
+    }
+    const files = await fs3.promises.readdir(tmpDir);
+    const jsonFile = files.find((f) => f.endsWith(".json"));
+    if (!jsonFile) {
+      throw new Error(`Structurizr JSON export produced no .json file. Files: ${files.join(", ")}`);
+    }
+    const jsonContent = await fs3.promises.readFile(path3.join(tmpDir, jsonFile), "utf8");
+    return JSON.parse(jsonContent);
+  } finally {
+    await fs3.promises.rm(tmpDir, { recursive: true, force: true });
+  }
+}
+async function exportWorkspaceJson(model, views) {
+  const dsl = new StructurizrDSLWriter(model, views).write();
+  return exportWorkspaceJsonFromDsl(dsl);
+}
 export {
   Component,
   Container,
@@ -903,7 +1196,9 @@ export {
   View,
   Views,
   buildModel,
-  buildModelWithCatalog,
+  exportWorkspaceJson,
+  exportWorkspaceJsonFromDsl,
   generateDiagrams,
-  mergeArchetypeWithOverride
+  mergeArchetypeWithOverride,
+  validateModel
 };

package/src/model.d.ts

@@ -2,6 +2,7 @@ import { Group } from './core';
 import { SoftwareSystem, SoftwareSystemDefinition } from './softwareSystem';
 import { Person, PersonDefinition } from './person';
 import { ElementArchetype, RelationshipArchetype } from './archetype';
+import { Views } from './views';
 export type CatalogKeyOf<TRoot, TModule> = {
     [K in keyof TRoot]: TRoot[K] extends TModule ? K : never;
 }[keyof TRoot];
@@ -9,7 +10,8 @@ export type Dependencies<TRoot, TModule> = Omit<TRoot, CatalogKeyOf<TRoot, TModu
 export interface C4Module<TRoot, TLocal, TArchetypes = Record<string, ElementArchetype | RelationshipArchetype>> {
     readonly key: CatalogKeyOf<TRoot, TLocal>;
     registerDefinitions(model: Model, archetypes: TArchetypes): TLocal;
-    buildRelationships(local: TLocal, dependencies: Dependencies<TRoot, TLocal>, archetypes: TArchetypes): void;
+    addRelationships(local: TLocal, dependencies: Dependencies<TRoot, TLocal>, archetypes: TArchetypes): void;
+    addViews?(views: Views, local: TLocal, dependencies: Dependencies<TRoot, TLocal>): void;
 }
 interface DefineSoftwareSystem {
     softwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
@@ -20,13 +22,21 @@ interface DefinePerson {
 export declare class ModelGroup extends Group<Person | SoftwareSystem> implements DefineSoftwareSystem, DefinePerson {
     readonly name: string;
     private readonly model;
+    private readonly pathSegments;
     private softwareSystems;
     private people;
-    constructor(name: string, model: DefineSoftwareSystem & DefinePerson);
+    private _groups;
+    constructor(name: string, model: DefineSoftwareSystem & DefinePerson, pathSegments?: string[]);
+    get canonicalName(): string;
+    get dslName(): string;
     softwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
     person(name: string, archetypeOrDef?: ElementArchetype | PersonDefinition, override?: PersonDefinition): Person;
+    group(groupName: string): ModelGroup;
+    getGroups(): ReadonlyArray<ModelGroup>;
     getSoftwareSystems(): ReadonlyArray<SoftwareSystem>;
     getPeople(): ReadonlyArray<Person>;
+    getAllSoftwareSystems(): ReadonlyArray<SoftwareSystem>;
+    getAllPeople(): ReadonlyArray<Person>;
 }
 export interface ModelDefinitions {
     softwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
@@ -39,7 +49,7 @@ export declare class Model {
     private people;
     private groups;
     softwareSystem(name: string, archetypeOrDef?: ElementArchetype | SoftwareSystemDefinition, override?: SoftwareSystemDefinition): SoftwareSystem;
-    group(groupName: string): Group & ModelDefinitions;
+    group(groupName: string): ModelGroup;
     person(name: string, archetypeOrDef?: ElementArchetype | PersonDefinition, override?: PersonDefinition): Person;
     validate(): void;
     getPeople(): ReadonlyArray<Person>;

package/src/softwareSystem.d.ts

@@ -11,10 +11,17 @@ export interface SoftwareSystemReference {
 export declare class SoftwareSystemGroup extends Group<Container> implements DefineContainer {
     readonly name: string;
     private readonly softwareSystem;
+    private readonly pathSegments;
     private _containers;
-    constructor(name: string, softwareSystem: DefineContainer);
+    private _groups;
+    constructor(name: string, softwareSystem: DefineContainer, pathSegments?: string[]);
+    get canonicalName(): string;
+    get dslName(): string;
     container(name: string, archetypeOrDef?: ElementArchetype | ContainerDefinition, override?: ContainerDefinition): Container;
+    group(groupName: string): SoftwareSystemGroup;
+    getGroups(): ReadonlyArray<SoftwareSystemGroup>;
     getContainers(): ReadonlyArray<Container>;
+    getAllContainers(): ReadonlyArray<Container>;
 }
 export declare class SoftwareSystem extends Element<Container> implements DefineContainer {
     readonly name: string;

package/src/structurizrDslWriter.d.ts

@@ -14,9 +14,14 @@ export declare class StructurizrDSLWriter {
     private writeSoftwareSystem;
     private writeRelationship;
     private writeRelationships;
+    private hasNestedModelGroups;
+    private hasNestedSoftwareSystemGroups;
+    private hasNestedContainerGroups;
+    private hasNestedGroups;
     private writeModelGroup;
     private writeModel;
     private writeView;
+    private writeStyles;
     private writeViews;
     write(): string;
     private writeLine;