@agilewallaby/c4-model 2.0.0 → 2.2.0

package/package.json

@@ -1,10 +1,6 @@
 {
   "name": "@agilewallaby/c4-model",
-  "version": "2.0.0",
-  "files": [
-    "src",
-    "README.md"
-  ],
+  "version": "2.2.0",
   "publishConfig": {
     "access": "public"
   },
@@ -15,8 +11,7 @@
   "dependencies": {
     "change-case": "^5.4.4",
     "glob": "^10.3.10",
-    "testcontainers": "^10.28.0",
-    "tslib": "^2.3.0"
+    "testcontainers": "^10.28.0"
   },
   "type": "module",
   "main": "./src/index.js",
@@ -26,6 +21,5 @@
       "import": "./src/index.js",
       "types": "./src/index.d.ts"
     }
-  },
-  "module": "./src/index.js"
+  }
 }

package/src/archetype.d.ts

@@ -0,0 +1,30 @@
+import { TechnologyDefinition } from './core';
+export type ElementKind = 'person' | 'softwareSystem' | 'container' | 'component';
+export declare class ElementArchetype {
+    readonly name: string;
+    readonly elementKind: ElementKind;
+    readonly parent?: ElementArchetype | undefined;
+    readonly ownDescription?: string;
+    readonly ownTechnology?: string;
+    readonly ownTags: ReadonlyArray<string>;
+    readonly description?: string;
+    readonly technology?: string;
+    readonly tags: ReadonlyArray<string>;
+    constructor(name: string, elementKind: ElementKind, definition?: TechnologyDefinition, parent?: ElementArchetype | undefined);
+}
+export declare class RelationshipArchetype {
+    readonly name: string;
+    readonly parent?: RelationshipArchetype | undefined;
+    readonly ownDescription?: string;
+    readonly ownTechnology?: string;
+    readonly ownTags: ReadonlyArray<string>;
+    readonly description?: string;
+    readonly technology?: string;
+    readonly tags: ReadonlyArray<string>;
+    constructor(name: string, definition?: TechnologyDefinition, parent?: RelationshipArchetype | undefined);
+}
+export declare function mergeArchetypeWithOverride(archetype: {
+    description?: string;
+    technology?: string;
+    tags: ReadonlyArray<string>;
+}, override?: TechnologyDefinition): TechnologyDefinition;

package/src/buildModel.d.ts

@@ -0,0 +1,20 @@
+import { Model } from './model';
+type Catalog = Record<string, unknown>;
+type RootCatalog = Record<string, Catalog>;
+export interface AnyC4Module {
+    readonly key: string;
+    registerDefinitions(model: Model): Catalog;
+    buildRelationships(local: Catalog, dependencies: RootCatalog): void;
+}
+export interface BuildModelOptions {
+    modelName?: string;
+    modules?: ReadonlyArray<AnyC4Module>;
+    globPath?: string;
+    searchRoot?: string;
+}
+export declare function buildModelWithCatalog<TRoot>(options?: BuildModelOptions): Promise<{
+    model: Model;
+    catalog: TRoot;
+}>;
+export declare function buildModel(options?: BuildModelOptions): Promise<Model>;
+export {};

package/src/component.d.ts

@@ -1,7 +1,8 @@
 import { Element, TechnicalElement, TechnologyDefinition } from './core';
+import { ElementArchetype } from './archetype';
 export type ComponentDefinition = TechnologyDefinition;
 export declare class Component extends TechnicalElement {
     readonly name: string;
-    constructor(name: string, definition?: ComponentDefinition);
+    constructor(name: string, definition?: ComponentDefinition, archetype?: ElementArchetype, overrideDefinition?: TechnologyDefinition);
     getChildElements(): ReadonlyArray<Element>;
 }

package/src/container.d.ts

@@ -1,23 +1,24 @@
 import { Element, Group, TechnicalElement, TechnologyDefinition } from './core';
 import { Component, ComponentDefinition } from './component';
+import { ElementArchetype } from './archetype';
 export type ContainerDefinition = TechnologyDefinition;
 interface DefineComponent {
-    defineComponent(name: string, definition?: ComponentDefinition): Component;
+    defineComponent(name: string, archetypeOrDef?: ElementArchetype | ComponentDefinition, override?: ComponentDefinition): Component;
 }
 export declare class ContainerGroup extends Group implements DefineComponent {
     readonly name: string;
     private readonly container;
     private _components;
     constructor(name: string, container: DefineComponent);
-    defineComponent(name: string, definition?: ComponentDefinition): Component;
+    defineComponent(name: string, archetypeOrDef?: ElementArchetype | ComponentDefinition, override?: ComponentDefinition): Component;
     getComponents(): ReadonlyArray<Component>;
 }
 export declare class Container extends TechnicalElement implements DefineComponent {
     readonly name: string;
     private _components;
     private _groups;
-    constructor(name: string, definition?: ContainerDefinition);
-    defineComponent(name: string, definition?: ComponentDefinition): Component;
+    constructor(name: string, definition?: ContainerDefinition, archetype?: ElementArchetype, overrideDefinition?: TechnologyDefinition);
+    defineComponent(name: string, archetypeOrDef?: ElementArchetype | ComponentDefinition, override?: ComponentDefinition): Component;
     addGroup(groupName: string): ContainerGroup;
     getGroups(): ReadonlyArray<ContainerGroup>;
     getComponentsNotInGroups(): ReadonlyArray<Component>;

package/src/core.d.ts

@@ -1,3 +1,4 @@
+import { ElementArchetype, RelationshipArchetype } from './archetype';
 export interface Definition {
     description?: string;
     tags?: string[];
@@ -9,10 +10,12 @@ export declare abstract class Element {
     readonly name: string;
     readonly description?: string;
     readonly tags: ReadonlyArray<string>;
+    readonly archetype?: ElementArchetype;
+    readonly overrideDefinition?: TechnologyDefinition;
     private _relationships;
-    constructor(name: string, defaultTags?: string[], definition?: Definition);
+    constructor(name: string, defaultTags?: string[], definition?: Definition, archetype?: ElementArchetype, overrideDefinition?: TechnologyDefinition);
     get canonicalName(): string;
-    uses(otherElement: Element, definition?: TechnologyDefinition): void;
+    uses(otherElement: Element, archetypeOrDef?: RelationshipArchetype | TechnologyDefinition, override?: TechnologyDefinition): void;
     get relationships(): ReadonlyArray<Relationship>;
     abstract getChildElements(): ReadonlyArray<Element>;
     getRelationshipsInHierarchy(): ReadonlyArray<Relationship>;
@@ -20,7 +23,7 @@ export declare abstract class Element {
 }
 export declare abstract class TechnicalElement extends Element {
     readonly technology?: string;
-    constructor(name: string, defaultTags?: string[], definition?: TechnologyDefinition);
+    constructor(name: string, defaultTags?: string[], definition?: TechnologyDefinition, archetype?: ElementArchetype, overrideDefinition?: TechnologyDefinition);
 }
 export declare class Relationship {
     readonly source: Element;
@@ -28,7 +31,9 @@ export declare class Relationship {
     readonly description?: string;
     readonly tags: ReadonlyArray<string>;
     readonly technology?: string;
-    constructor(source: Element, destination: Element, definition?: TechnologyDefinition);
+    readonly archetype?: RelationshipArchetype;
+    readonly overrideDefinition?: TechnologyDefinition;
+    constructor(source: Element, destination: Element, definition?: TechnologyDefinition, archetype?: RelationshipArchetype, overrideDefinition?: TechnologyDefinition);
 }
 export declare class Group {
     readonly name: string;

package/src/generateDiagrams.d.ts

@@ -1,4 +1,4 @@
-import { BuildModelOptions } from './model';
+import { BuildModelOptions } from './buildModel';
 import { Views } from './views';
 export interface GenerateDiagramsOptions<TRoot> extends BuildModelOptions {
     views: (catalog: TRoot) => Views;

package/src/index.d.ts

@@ -1,3 +1,4 @@
+export * from './archetype';
 export * from './model';
 export * from './person';
 export * from './softwareSystem';
@@ -5,4 +6,5 @@ export * from './container';
 export * from './component';
 export * from './views';
 export * from './structurizrDslWriter';
+export * from './buildModel';
 export * from './generateDiagrams';