@likec4/core 1.17.1 → 1.18.0

package/src/builder/Builder.test-d.ts

@@ -1,4 +1,5 @@
 import { expectTypeOf, test } from 'vitest'
+import type { LikeC4Model } from '../model/LikeC4Model'
 import type { ParsedLikeC4Model } from '../types'
 import { Builder } from './Builder'
 
@@ -11,10 +12,18 @@ test('should have types', () => {
       component,
       relTo
     },
+    deployment: {
+      deployment,
+      instanceOf,
+      env,
+      vm
+    },
     views: {
+      deploymentView,
       views,
       view,
       viewOf,
+      $rules,
       $include
     },
     builder
@@ -28,6 +37,10 @@ test('should have types', () => {
       system: {},
       component: {}
     },
+    deployments: {
+      env: {},
+      vm: {}
+    },
     relationships: {
       like: {},
       dislike: {}
@@ -50,20 +63,62 @@ test('should have types', () => {
           )
         )
       ),
+      deployment(
+        env('prod').with(
+          vm('vm1'),
+          vm('vm2')
+        ),
+        env('dev').with(
+          vm('vm1'),
+          instanceOf('api', 'cloud.backend.api'),
+          vm('vm2')
+        )
+      ),
       views(
         view('index', $include('*')),
-        viewOf('cloud', 'cloud', $include('*'))
+        viewOf(
+          'cloud',
+          'cloud',
+          $rules(
+            $include('*'),
+            $include('cloud.backend.*')
+          )
+        ),
+        deploymentView(
+          'prod',
+          $rules(
+            $include('prod.*')
+          )
+        )
       )
     )
-    .build()
 
-  expectTypeOf(m).toEqualTypeOf(
+  expectTypeOf(m.Types.Fqn).toEqualTypeOf(
+    '' as 'alice' | 'bob' | 'cloud' | 'cloud.backend' | 'cloud.backend.api' | 'cloud.backend.db' | 'cloud.frontend'
+  )
+  expectTypeOf(m.Types.ViewId).toEqualTypeOf(
+    '' as 'index' | 'cloud' | 'prod'
+  )
+  expectTypeOf(m.Types.DeploymentFqn).toEqualTypeOf(
+    '' as 'prod' | 'dev' | 'prod.vm1' | 'prod.vm2' | 'dev.vm1' | 'dev.vm2' | 'dev.api'
+  )
+
+  expectTypeOf(m.build()).toEqualTypeOf(
     {} as ParsedLikeC4Model<
       'actor' | 'system' | 'component',
       'like' | 'dislike',
       'tag1' | 'tag2',
       'alice' | 'bob' | 'cloud' | 'cloud.backend' | 'cloud.backend.api' | 'cloud.backend.db' | 'cloud.frontend',
-      'index' | 'cloud'
+      'index' | 'cloud' | 'prod',
+      'prod' | 'dev' | 'prod.vm1' | 'prod.vm2' | 'dev.vm1' | 'dev.vm2' | 'dev.api'
+    >
+  )
+
+  expectTypeOf(m.buildComputedModel()).toEqualTypeOf(
+    {} as LikeC4Model.Computed<
+      'alice' | 'bob' | 'cloud' | 'cloud.backend' | 'cloud.backend.api' | 'cloud.backend.db' | 'cloud.frontend',
+      'prod' | 'dev' | 'prod.vm1' | 'prod.vm2' | 'dev.vm1' | 'dev.vm2' | 'dev.api',
+      'index' | 'cloud' | 'prod'
     >
   )
 })

package/src/builder/Builder.ts

@@ -1,11 +1,16 @@
 import defu from 'defu'
 import { fromEntries, hasAtLeast, isFunction, isNonNullish, map, mapToObj, mapValues, pickBy } from 'remeda'
 import type { Writable } from 'type-fest'
+import { computeViews } from '../compute-view'
 import { invariant } from '../errors'
+import { LikeC4Model } from '../model/LikeC4Model'
 import {
   type Color,
   DefaultElementShape,
   DefaultThemeColor,
+  DeploymentElement,
+  type DeploymentRelation,
+  type DeploymentView,
   type Element,
   type ElementShape,
   type ElementView,
@@ -17,22 +22,24 @@ import {
   type ModelGlobals,
   type NonEmptyArray,
   type Relation,
-  type RelationID,
+  type RelationId,
   type Tag
 } from '../types'
 import type { ParsedLikeC4Model } from '../types/model'
 import { isSameHierarchy, nameFromFqn, parentFqn } from '../utils/fqn'
 import type { AnyTypes, BuilderSpecification, Types } from './_types'
-import type { AddElement, AddElementHelpers } from './Builder.element'
-import { type ModelBuilder, type ModelHelpers } from './Builder.model'
+import type { AddDeploymentNode } from './Builder.deployment'
+import type { AddDeploymentNodeHelpers, DeloymentModelHelpers, DeploymentModelBuilder } from './Builder.deploymentModel'
+import type { AddElement } from './Builder.element'
+import type { AddElementHelpers, ModelBuilder, ModelHelpers } from './Builder.model'
 import {
   $autoLayout,
   $exclude,
-  $expr,
   $include,
   $rules,
   $style,
-  type ViewBuilder,
+  type DeploymentViewRuleBuilderOp,
+  mkViewBuilder,
   type ViewHelpers,
   type ViewRuleBuilderOp
 } from './Builder.view'
@@ -52,16 +59,32 @@ export interface Builder<T extends AnyTypes> {
   helpers(): {
     model: ModelHelpers<T>
     views: ViewHelpers<T['NewViewProps']>
+    deployment: DeloymentModelHelpers<T>
   }
 
   __model(): ModelBuilder<T>
   __views(): ViewsBuilder<T>
+  __deployment(): DeploymentModelBuilder<T>
 
+  /**
+   * Returns model as result of parsing only
+   * Model is not computed or layouted
+   */
   build(): ParsedLikeC4Model<
     T['ElementKind'],
     T['RelationshipKind'],
     T['Tag'],
     T['Fqn'],
+    T['ViewId'],
+    T['DeploymentFqn']
+  >
+
+  /**
+   * Returns model with computed views
+   */
+  buildComputedModel(): LikeC4Model.Computed<
+    T['Fqn'],
+    T['DeploymentFqn'],
     T['ViewId']
   >
 
@@ -225,16 +248,21 @@ function builder<Spec extends BuilderSpecification, T extends AnyTypes>(
     predicates: {},
     dynamicPredicates: {},
     styles: {}
-  } as ModelGlobals
+  } as ModelGlobals,
+  _deployments = new Map<string, DeploymentElement>(),
+  _deploymentRelations = [] as DeploymentRelation[]
 ): Builder<T> {
   const toLikeC4Specification = (): Types.ToParsedLikeC4Model<T>['specification'] => ({
-    tags: (spec.tags ?? []) as Tag<T['Tag']>[],
     elements: {
       ...spec.elements as any
     },
+    deployments: {
+      ...spec.deployments as any
+    },
     relationships: {
       ...spec.relationships
-    }
+    },
+    tags: (spec.tags ?? []) as Tag<T['Tag']>[]
   })
 
   const mapLinks = (links?: Array<string | { title?: string; url: string }>): NonEmptyArray<Link> | null => {
@@ -244,54 +272,21 @@ function builder<Spec extends BuilderSpecification, T extends AnyTypes>(
     return map(links, l => (typeof l === 'string' ? { url: l } : l))
   }
 
-  const mkViewBuilder = (view: Writable<ElementView>): ViewBuilder<T> => {
-    const viewBuilder: ViewBuilder<T> = {
-      autoLayout(autoLayout) {
-        view.rules.push({
-          direction: autoLayout
-        })
-        return viewBuilder
-      },
-      exclude(expr) {
-        view.rules.push({
-          exclude: [expr]
-        })
-        return viewBuilder
-      },
-      include(expr) {
-        view.rules.push({
-          include: [expr]
-        })
-        return viewBuilder
-      },
-      style(rule) {
-        view.rules.push(rule)
-        return viewBuilder
-      }
-      // title(title: string) {
-      //   view.title = title
-      //   return viewBuilder
-      // },
-      // description(description: string) {
-      //   view.description = description
-      //   return viewBuilder
-      // }
-    }
-    return viewBuilder
-  }
-
   const self: Builder<T> = {
     get Types(): T {
       throw new Error('Types are not available in runtime')
     },
-    clone: () =>
-      builder(
+    clone: () => {
+      return builder(
         structuredClone(spec),
         structuredClone(_elements),
         structuredClone(_relations),
         structuredClone(_views),
-        structuredClone(_globals)
-      ),
+        structuredClone(_globals),
+        structuredClone(_deployments),
+        structuredClone(_deploymentRelations)
+      )
+    },
     __model: () => ({
       addElement: (element) => {
         const parent = parentFqn(element.id)
@@ -317,7 +312,7 @@ function builder<Spec extends BuilderSpecification, T extends AnyTypes>(
           'Cannot create relationship between elements in the same hierarchy'
         )
         _relations.push({
-          id: `rel${_relations.length + 1}` as RelationID,
+          id: `rel${_relations.length + 1}` as RelationId,
           ...relation
         })
         return self
@@ -341,13 +336,53 @@ function builder<Spec extends BuilderSpecification, T extends AnyTypes>(
         return self
       }
     }),
+    __deployment: () => ({
+      addDeployment: (node: DeploymentElement) => {
+        if (_deployments.has(node.id)) {
+          throw new Error(`Deployment with id "${node.id}" already exists`)
+        }
+        const parent = parentFqn(node.id)
+        if (parent) {
+          invariant(
+            _deployments.get(parent),
+            `Parent element with id "${parent}" not found for node with id "${node.id}"`
+          )
+        }
+        if (DeploymentElement.isInstance(node)) {
+          invariant(parent, 'Instance must have parent')
+        }
+        _deployments.set(node.id, node)
+        return self
+      },
+      addDeploymentRelation: (relation) => {
+        invariant(
+          !isSameHierarchy(relation.source.id, relation.target.id),
+          'Cannot create relationship between elements in the same hierarchy'
+        )
+        _deploymentRelations.push({
+          id: `deploy_rel${_deploymentRelations.length + 1}` as RelationId,
+          ...relation
+        })
+        return self
+      },
+      fqn: (id) => id as Fqn
+    }),
     build: () => ({
       specification: toLikeC4Specification(),
       elements: fromEntries(Array.from(_elements.entries())) as any,
       relations: mapToObj(_relations, r => [r.id, r]),
       globals: structuredClone(_globals),
+      deployments: {
+        elements: fromEntries(Array.from(_deployments.entries())) as any,
+        relations: mapToObj(_deploymentRelations, r => [r.id, r])
+      },
       views: fromEntries(Array.from(_views.entries())) as any
     }),
+    buildComputedModel: () => {
+      const parsed = self.build()
+      const computed = computeViews(parsed)
+      return LikeC4Model.create(computed)
+    },
     helpers: () => ({
       model: {
         model: (...ops: ((b: ModelBuilder<T>) => ModelBuilder<T>)[]) => {
@@ -475,7 +510,7 @@ function builder<Spec extends BuilderSpecification, T extends AnyTypes>(
             return b
           }
         },
-        view: (id, _props, builder?: ViewRuleBuilderOp<T>) => {
+        view: (id, _props, builder?: ViewRuleBuilderOp<any>) => {
           if (isFunction(_props)) {
             builder = _props
             _props = {}
@@ -512,8 +547,8 @@ function builder<Spec extends BuilderSpecification, T extends AnyTypes>(
         viewOf: (
           id,
           viewOf,
-          _props?: T['NewViewProps'] | string | ViewRuleBuilderOp<T>,
-          builder?: ViewRuleBuilderOp<T>
+          _props?: T['NewViewProps'] | string | ViewRuleBuilderOp<any>,
+          builder?: ViewRuleBuilderOp<any>
         ) => {
           if (isFunction(_props)) {
             builder = _props
@@ -549,12 +584,161 @@ function builder<Spec extends BuilderSpecification, T extends AnyTypes>(
             return b
           }
         },
+        deploymentView: (
+          id,
+          _props?: T['NewViewProps'] | string | DeploymentViewRuleBuilderOp<any>,
+          builder?: DeploymentViewRuleBuilderOp<any>
+        ) => {
+          if (isFunction(_props)) {
+            builder = _props as any
+            _props = {}
+          }
+          return <T extends AnyTypes>(b: ViewsBuilder<T>): ViewsBuilder<T> => {
+            const {
+              links: _links = [],
+              title = null,
+              ...props
+            } = typeof _props === 'string' ? { title: _props } : { ..._props }
+
+            const links = mapLinks(_links)
+
+            const view: Writable<DeploymentView> = {
+              id: id as any,
+              __: 'deployment',
+              title,
+              description: null,
+              tags: null,
+              rules: [],
+              links,
+              customColorDefinitions: {},
+              ...props
+            }
+            b.addView(view)
+
+            if (builder) {
+              builder(mkViewBuilder(view))
+            }
+
+            return b
+          }
+        },
         $autoLayout,
         $exclude,
-        $expr,
         $include,
         $rules,
         $style
+      },
+      deployment: {
+        deployment: (...ops: ((b: DeploymentModelBuilder<T>) => DeploymentModelBuilder<T>)[]) => {
+          return (b: Builder<T>) => {
+            const v = b.__deployment()
+            for (const op of ops) {
+              op(v)
+            }
+            return b
+          }
+        },
+        instanceOf: (id, to, _props?: string | T['NewDeploymentNodeProps']) => {
+          return <T extends AnyTypes>(
+            b: DeploymentModelBuilder<T>
+          ): DeploymentModelBuilder<Types.AddDeploymentFqn<T, any>> => {
+            const {
+              links,
+              title,
+              ...props
+            } = typeof _props === 'string' ? { title: _props } : { ..._props }
+            const _id = b.fqn(id)
+            invariant(_elements.has(to), `Target element with id "${to}" not found`)
+            b.addDeployment({
+              id: _id,
+              element: to as any,
+              ...title && { title },
+              ...links && { links: mapLinks(links) },
+              ...props
+            })
+            return b as any
+          }
+        },
+        rel: (source: string, target: string, _props?: T['NewRelationshipProps'] | string) => {
+          return <T extends AnyTypes>(b: DeploymentModelBuilder<T>) => {
+            const {
+              title,
+              links,
+              ...props
+            } = typeof _props === 'string' ? { title: _props } : { ..._props }
+
+            b.addDeploymentRelation({
+              source: {
+                id: source as any
+              },
+              target: {
+                id: target as any
+              },
+              ...title && { title },
+              ...links && { links: mapLinks(links) },
+              ...props
+            })
+            return b
+          }
+        },
+        ...mapValues(
+          spec.deployments ?? {},
+          ({ style: specStyle, ...spec }, kind) =>
+          <Id extends string>(
+            id: Id,
+            _props?: T['NewDeploymentNodeProps'] | string
+          ): AddDeploymentNode<Id> => {
+            const add = (<T extends AnyTypes>(b: DeploymentModelBuilder<T>) => {
+              const {
+                links,
+                icon: _icon,
+                style,
+                title,
+                ...props
+              } = typeof _props === 'string' ? { title: _props } : { ..._props }
+
+              const icon = _icon ?? specStyle?.icon
+
+              const _id = b.fqn(id)
+
+              b.addDeployment({
+                id: _id,
+                kind: kind as any,
+                title: title ?? nameFromFqn(_id),
+                description: null,
+                technology: null,
+                tags: null,
+                color: specStyle?.color ?? DefaultThemeColor as Color,
+                shape: specStyle?.shape ?? DefaultElementShape as ElementShape,
+                style: pickBy({
+                  border: specStyle?.border,
+                  opacity: specStyle?.opacity,
+                  ...style
+                }, isNonNullish),
+                ...links && { links: mapLinks(links) },
+                ...icon && { icon: icon as IconUrl },
+                ...spec,
+                ...props
+              })
+              return b
+            }) as AddDeploymentNode<Id>
+
+            add.with =
+              (...ops: Array<(input: DeploymentModelBuilder<any>) => DeploymentModelBuilder<any>>) =>
+              (b: DeploymentModelBuilder<any>) => {
+                add(b)
+                const nestedBuilder: DeploymentModelBuilder<any> = {
+                  ...b,
+                  fqn: (child) => `${b.fqn(id)}.${child}` as Fqn
+                }
+                for (const op of ops) {
+                  op(nestedBuilder)
+                }
+                return b
+              }
+            return add
+          }
+        ) as AddDeploymentNodeHelpers<T>
       }
     }),
     with: (...ops: ((b: Builder<T>) => Builder<T>)[]) => {
@@ -571,6 +755,7 @@ export namespace Builder {
   ): {
     builder: Builder<Types.FromSpecification<Spec>>
     model: ModelHelpers<Types.FromSpecification<Spec>>
+    deployment: DeloymentModelHelpers<Types.FromSpecification<Spec>>
     views: ViewHelpers<Types.FromSpecification<Spec>['NewViewProps']>
   } {
     const b = builder<Spec, Types.FromSpecification<Spec>>(spec)