@likec4/core 1.18.0 → 1.19.0

package/src/compute-view/deployment-view/__test__/TestHelper.ts

@@ -0,0 +1,236 @@
+import { indexBy, isArray, isString, map, mapValues, pipe, prop } from 'remeda'
+import type { Writable } from 'type-fest'
+import type { ExpectStatic } from 'vitest'
+import { expect as vitestExpect } from 'vitest'
+import {
+  type AnyTypes,
+  type Builder,
+  type DeploymentRulesBuilderOp,
+  type Types,
+  type ViewPredicate,
+} from '../../../builder'
+import * as viewhelpers from '../../../builder/Builder.view-common'
+import { mkViewBuilder } from '../../../builder/Builder.views'
+import { differenceConnections } from '../../../model/connection'
+import type { ComputedDeploymentView, DeploymentView, DeploymentViewRule, ViewId } from '../../../types'
+import { imap, toArray } from '../../../utils/iterable'
+import { difference as differenceSet } from '../../../utils/set'
+import { withReadableEdges } from '../../utils/with-readable-edges'
+import { processPredicates as processPredicatesImpl } from '../compute'
+import { Memory } from '../memory'
+
+type ConnectionExpression<T extends AnyTypes> = `${T['DeploymentFqn']} -> ${T['DeploymentFqn']}`
+
+type ConnectionsDeepMatcher<M extends string, D extends string> = {
+  [K in `${D} -> ${D}`]?: {
+    model?: Array<`${M} -> ${M}`>
+    deployment?: Array<`${D} -> ${D}`>
+  }
+}
+
+type ToDeepMatcher<T extends AnyTypes> = ConnectionsDeepMatcher<T['Fqn'], T['DeploymentFqn']>
+
+type ConnectionEqual<T extends AnyTypes> = [ToDeepMatcher<T>] | [ConnectionExpression<T>, ...ConnectionExpression<T>[]]
+
+type Elem = Memory['Ctx']['Element']
+type Connection = Memory['Ctx']['Connection']
+
+export class TestHelper<T extends AnyTypes> {
+  model: Types.ToLikeC4Model<T>
+
+  static $include = viewhelpers.$include
+  static $exclude = viewhelpers.$exclude
+  static $style = viewhelpers.$style
+
+  $include = viewhelpers.$include
+  $exclude = viewhelpers.$exclude
+  $style = viewhelpers.$style
+
+  static from<const T extends AnyTypes>(builder: Builder<T>, expect = vitestExpect): TestHelper<T> {
+    return new TestHelper(builder, expect)
+  }
+
+  constructor(
+    private builder: Builder<T>,
+    private _expect: ExpectStatic,
+  ) {
+    this.model = builder.toLikeC4Model() as Types.ToLikeC4Model<T>
+  }
+
+  computeView = (...rules: DeploymentRulesBuilderOp<T>[]) => {
+    return withReadableEdges(
+      this.builder
+        .clone()
+        .views(_ => _.deploymentView('dev').with(...rules))
+        .toLikeC4Model()
+        .view('dev')
+        .$view as ComputedDeploymentView<'dev'>,
+      ' -> ',
+    )
+  }
+
+  processPredicates(...rules: DeploymentRulesBuilderOp<T>[]) {
+    return ProcessPredicates.execute(this, ...rules)
+  }
+
+  expectView(view: ComputedDeploymentView) {
+    return {
+      toHave: (nodesAndEdges: { nodes: Array<T['DeploymentFqn']>; edges: Array<ConnectionExpression<T>> }) => {
+        const actual = {
+          nodes: view.nodes.map(prop('id')),
+          edges: view.edges.map(prop('id')),
+        }
+        this._expect(actual).toEqual(nodesAndEdges)
+      },
+      toHaveNodes: <Id extends T['DeploymentFqn']>(...nodes: Id[]) => {
+        this._expect(view.nodes.map(prop('id'))).toEqual(nodes)
+      },
+      toHaveEdges: <Id extends ConnectionExpression<T>>(...edges: Id[]) => {
+        this._expect(view.edges.map(prop('id'))).toEqual(edges)
+      },
+    }
+  }
+
+  expectComputedView(...rules: DeploymentRulesBuilderOp<T>[]) {
+    return this.expectView(this.computeView(...rules))
+  }
+
+  expectMemory = (memory: Memory) => ({
+    toHaveAllElements: <Id extends T['DeploymentFqn']>(...ids: Id[]) => {
+      this._expect(map([...memory.elements], prop('id'))).toEqual(ids)
+    },
+    toHaveElements: <Id extends T['DeploymentFqn']>(...ids: Id[]) => {
+      this._expect(map([...memory.final], prop('id'))).toEqual(ids)
+    },
+    toHaveConnections: (...matchers: ConnectionEqual<T>) => {
+      this.expectConnections(memory.connections).toEqual(...matchers)
+    },
+  })
+
+  expectElements = (elements: ReadonlySet<Elem>) => ({
+    toEqual: <const Id extends ViewPredicate.DeploymentConnectionExpression<T>>(...ids: Id[]) => {
+      this._expect(toArray(imap(elements, prop('id')))).toEqual(ids)
+    },
+  })
+
+  expectConnections = (connections: ReadonlyArray<Connection>) => ({
+    toBeEmpty: () => {
+      this._expect(connections.map(c => c.expression)).to.be.empty
+    },
+    toEqual: (...matchers: ConnectionEqual<T>) => {
+      const [matcher, ...rest] = matchers
+      if (isString(matcher)) {
+        this._expect(connections.map(c => c.expression)).toEqual([matcher, ...rest])
+        return
+      }
+      const obj = pipe(
+        connections,
+        indexBy(prop('expression')),
+        mapValues(c => ({
+          model: toArray(imap(c.relations.model, prop('expression'))).sort(),
+          deployment: toArray(imap(c.relations.deployment, prop('expression'))).sort(),
+        })),
+      )
+      const expected = mapValues(matcher, (v: any) => ({
+        ...v,
+        model: v.model ? [...v.model].sort() : [],
+        deployment: v.deployment ? [...v.deployment].sort() : [],
+      }))
+      this._expect(obj).toEqual(expected)
+    },
+  })
+
+  expectStep = (step: ProcessPredicates<T>) => ({
+    ...this.expectMemory(step.memory),
+  })
+
+  expect(value: ComputedDeploymentView): ReturnType<typeof this['expectView']>
+  expect(value: Set<Elem>): ReturnType<typeof this['expectElements']>
+  expect(value: ReadonlyArray<Connection>): ReturnType<typeof this['expectConnections']>
+  expect(value: Memory | ProcessPredicates<T>): ReturnType<typeof this['expectMemory']>
+  expect(value: Memory | ProcessPredicates<T> | Set<Elem> | ComputedDeploymentView | ReadonlyArray<Connection>) {
+    if (value instanceof Memory) {
+      return this.expectMemory(value)
+    }
+    if (value instanceof ProcessPredicates) {
+      return this.expectStep(value)
+    }
+    if (value instanceof Set) {
+      return this.expectElements(value)
+    }
+    if (isArray(value)) {
+      return this.expectConnections(value)
+    }
+    return this.expectView(value)
+  }
+}
+
+class ProcessPredicates<T extends AnyTypes> {
+  static execute<A extends AnyTypes>(
+    test: TestHelper<A>,
+    ...rules: DeploymentRulesBuilderOp<A>[]
+  ): ProcessPredicates<A> {
+    const processor = new ProcessPredicates(test)
+    processor.next(...rules)
+    return processor
+  }
+
+  public viewrules: ReadonlyArray<DeploymentViewRule> = []
+
+  public previousMemory: Memory = Memory.empty()
+  public memory: Memory = Memory.empty()
+  public predicates: DeploymentRulesBuilderOp<T>[] = []
+
+  constructor(
+    public readonly t: TestHelper<T>,
+    protected age = 0,
+  ) {}
+
+  get elements() {
+    return toArray(imap(this.memory.elements, prop('id')))
+  }
+
+  get connections() {
+    return this.memory.connections.map(c => c.expression)
+  }
+
+  diff() {
+    const prevState = this.previousMemory
+    const state = this.memory
+    return {
+      added: this.memory.update({
+        elements: differenceSet(state.elements, prevState.elements),
+        explicits: differenceSet(state.explicits, prevState.explicits),
+        final: differenceSet(state.final, prevState.final),
+        connections: differenceConnections(state.connections, prevState.connections),
+      }),
+      removed: this.memory.update({
+        elements: differenceSet(prevState.elements, state.elements),
+        explicits: differenceSet(prevState.explicits, state.explicits),
+        final: differenceSet(prevState.final, state.final),
+        connections: differenceConnections(prevState.connections, state.connections),
+      }),
+    }
+  }
+
+  next(...predicates: DeploymentRulesBuilderOp<T>[]): this {
+    const view = {
+      id: 'test' as ViewId,
+      __: 'deployment',
+      rules: [],
+    } as any as Writable<DeploymentView>
+    let vb = mkViewBuilder(view) as any
+    this.predicates = [
+      ...this.predicates,
+      ...predicates,
+    ]
+    for (const rule of this.predicates) {
+      rule(vb)
+    }
+    this.previousMemory = this.memory
+    this.viewrules = view.rules
+    this.memory = processPredicatesImpl(this.t.model.deployment, view.rules)
+    this.age++
+    return this
+  }
+}

package/src/compute-view/deployment-view/__test__/fixture.ts

@@ -1,6 +1,6 @@
 import { map, prop } from 'remeda'
+import type { DeploymentRulesBuilderOp } from '../../../builder'
 import { Builder } from '../../../builder'
-import type { DeploymentViewRuleBuilderOp } from '../../../builder/Builder.view'
 import { LikeC4Model } from '../../../model'
 import type { DeploymentView } from '../../../types'
 import { withReadableEdges } from '../../utils/with-readable-edges'
@@ -26,70 +26,67 @@ const {
     ...$d
   },
   views: {
-    view,
     views,
-    viewOf,
     deploymentView,
     $rules,
     $include,
     $exclude,
-    $style
-  }
+  },
 } = Builder.forSpecification({
   elements: {
     person: {
       style: {
-        shape: 'person'
-      }
+        shape: 'person',
+      },
     },
     system: {},
     component: {},
     webapp: {
       style: {
-        shape: 'browser'
-      }
+        shape: 'browser',
+      },
     },
     mobile: {
       style: {
-        shape: 'mobile'
-      }
-    }
+        shape: 'mobile',
+      },
+    },
   },
   deployments: {
     env: {},
     zone: {},
-    node: {}
-  }
+    node: {},
+  },
 })
 
 export const builder = b
   .with(
     model(
       person('customer', {
-        title: 'Happy Customer'
+        title: 'Happy Customer',
       }),
       system('cloud').with(
         component('frontend').with(
           webapp('dashboard'),
-          mobile('mobile')
+          mobile('mobile'),
         ),
         component('auth'),
         component('backend').with(
-          component('api')
+          component('api'),
         ),
         component('media', {
-          shape: 'storage'
-        })
+          shape: 'storage',
+        }),
       ),
       system('aws').with(
         component('rds', {
-          shape: 'storage'
+          shape: 'storage',
         }),
         component('s3', {
-          shape: 'storage'
-        })
+          shape: 'storage',
+        }),
       ),
-      system('email')
+      system('email'),
     ),
     model(
       $m.rel('customer', 'cloud', 'uses services'),
@@ -97,13 +94,13 @@ export const builder = b
       $m.rel('customer', 'cloud.frontend.dashboard', 'opens in browser'),
       $m.rel('cloud.frontend.dashboard', 'cloud.auth', {
         title: 'authenticates',
-        color: 'green'
+        color: 'green',
       }),
       $m.rel('cloud.frontend.dashboard', 'cloud.backend.api', 'fetches data'),
       $m.rel('cloud.frontend.dashboard', 'cloud.media', 'fetches media'),
       $m.rel('cloud.frontend.mobile', 'cloud.auth', {
         title: 'authenticates',
-        color: 'amber'
+        color: 'amber',
       }),
       $m.rel('cloud.frontend.mobile', 'cloud.backend.api', 'fetches data'),
       $m.rel('cloud.frontend.mobile', 'cloud.media', 'fetches media'),
@@ -112,99 +109,90 @@ export const builder = b
       $m.rel('cloud.backend.api', 'aws.rds', 'reads/writes'),
       $m.rel('cloud.backend.api', 'email', 'sends emails'),
       $m.rel('cloud.media', 'aws.s3', 'uploads'),
-      $m.rel('email', 'customer', 'sends emails')
+      $m.rel('email', 'customer', 'sends emails'),
     ),
     deployment(
       node('customer').with(
-        instanceOf('instance', 'customer')
+        instanceOf('instance', 'customer'),
       ),
       env('prod').with(
         zone('eu').with(
           zone('zone1').with(
             instanceOf('api', 'cloud.backend.api'),
-            instanceOf('ui', 'cloud.frontend.dashboard')
+            instanceOf('ui', 'cloud.frontend.dashboard'),
           ),
           zone('zone2').with(
             instanceOf('api', 'cloud.backend.api'),
-            instanceOf('ui', 'cloud.frontend.dashboard')
+            instanceOf('ui', 'cloud.frontend.dashboard'),
           ),
           instanceOf('auth', 'cloud.auth'),
           instanceOf('media', 'cloud.media'),
-          instanceOf('db', 'aws.rds')
+          instanceOf('db', 'aws.rds'),
         ),
         zone('us').with(
           zone('zone1').with(
             instanceOf('api', 'cloud.backend.api'),
-            instanceOf('ui', 'cloud.frontend.dashboard')
+            instanceOf('ui', 'cloud.frontend.dashboard'),
           ),
-          instanceOf('db', 'aws.rds')
-        )
+          instanceOf('db', 'aws.rds'),
+        ),
       ),
       env('acc').with(
         node('testCustomer').with(
-          instanceOf('instance', 'customer')
+          instanceOf('instance', 'customer'),
         ),
         zone('eu').with(
           instanceOf('api', 'cloud.backend.api'),
           instanceOf('ui', 'cloud.frontend.dashboard'),
           instanceOf('auth', 'cloud.auth'),
-          instanceOf('db', 'aws.rds')
-        )
+          instanceOf('db', 'aws.rds'),
+        ),
       ),
       env('global').with(
-        instanceOf('email', 'email')
+        instanceOf('email', 'email'),
       ),
       $d.rel('prod.eu.db', 'prod.us.db', {
         title: 'replicates',
-        color: 'green'
+        color: 'green',
       }),
       $d.rel('prod.us.db', 'prod.eu.db', {
         title: 'replicates',
-        color: 'amber'
-      })
-    )
-    // views(
-    //   view('index', $include('*')),
-    //   viewOf('cloud', 'cloud', $rules(
-    //     $include('*'),
-    //   )),
-    //   deploymentView('prod', $rules(
-    //     $include('customer.c'),
-    //     $include('prod._'),
-    //     $exclude('prod.eu.zone1 <-> prod.eu.zone2')
-    //   ))
-    // )
+        color: 'amber',
+      }),
+    ),
   )
+  .clone()
 
 export type Types = typeof builder['Types']
 
 export { $exclude, $include }
 
-export function computeView(...rules: DeploymentViewRuleBuilderOp<Types>[]) {
-  const modelsource = builder.with(
-    views(
-      deploymentView('index', $rules(...rules))
-    )
-  ).build()
+export function computeView(...rules: DeploymentRulesBuilderOp<Types>[]) {
+  const modelsource = builder.clone()
+    .with(
+      views(
+        deploymentView('index', $rules(...rules)),
+      ),
+    ).build()
 
   const model = LikeC4Model.create({
     ...modelsource,
-    views: {}
+    views: {},
   })
 
   const view = withReadableEdges(computeDeploymentView(model, modelsource.views.index as DeploymentView))
 
   return Object.assign(view, {
     nodeIds: map(view.nodes, prop('id')) as string[],
-    edgeIds: map(view.edges, prop('id')) as string[]
+    edgeIds: map(view.edges, prop('id')) as string[],
   })
 }
 
-export function computeNodesAndEdges(...rules: DeploymentViewRuleBuilderOp<Types>[]) {
+export function computeNodesAndEdges(...rules: DeploymentRulesBuilderOp<Types>[]) {
   const { nodeIds, edgeIds } = computeView(...rules)
   return {
     // Starts with capital letter to be first in snapshot
     Nodes: nodeIds,
-    edges: edgeIds
+    edges: edgeIds,
   }
 }

package/src/compute-view/deployment-view/_types.ts

@@ -1,29 +1,37 @@
 import { LikeC4DeploymentModel } from '../../model'
-import type { DeploymentConnectionModel } from '../../model/connection/deployment'
-import type { DeploymentElementModel } from '../../model/DeploymentElementModel'
-import type { AnyAux } from '../../model/types'
-import type { DeploymentExpression } from '../../types'
-import type { Memory, Patch } from './Memory'
-import type { Stage } from './Stage'
+import type { RelationshipModel } from '../../model/RelationModel'
+import type { ExpressionV2 } from '../../types'
+import type { Ctx, Memory, Stage, StageExclude, StageInclude } from './memory'
 
-export type Elem = DeploymentElementModel<AnyAux>
+export { Memory, type Stage } from './memory'
 
-export type Connections<M extends AnyAux = AnyAux> = ReadonlyArray<DeploymentConnectionModel<M>>
+export type Where<T extends {}> = (x: T) => boolean
 
-export type PredicateParams<Expr extends DeploymentExpression = any> = {
+export type Elem = Ctx['Element']
+export type Connection = Ctx['Connection']
+
+export type ElementWhere = Where<Elem>
+export type ElementWhereFilter = (elements: readonly Elem[]) => Elem[]
+export type ConnectionWhere = Where<Connection>
+export type RelationshipWhere = Where<RelationshipModel>
+export type ConnectionWhereFilter = (connections: readonly Connection[]) => Connection[]
+
+export type Connections = ReadonlyArray<Connection>
+
+export interface PredicateCtx<Expr extends ExpressionV2 = ExpressionV2> {
   expr: Expr
-  model: LikeC4DeploymentModel
   stage: Stage
-  memory: Memory
-}
-
-export interface PredicateCtx {
   model: LikeC4DeploymentModel
-  stage: Stage
   memory: Memory
 }
+export interface IncludePredicateCtx<Expr extends ExpressionV2 = ExpressionV2> extends PredicateCtx<Expr> {
+  stage: StageInclude
+}
+export interface ExcludePredicateCtx<Expr extends ExpressionV2 = ExpressionV2> extends PredicateCtx<Expr> {
+  stage: StageExclude
+}
 
-export interface PredicateExecutor<Expr extends DeploymentExpression> {
-  include(expr: Expr, ctx: PredicateCtx): Patch
-  exclude(expr: Expr, ctx: PredicateCtx): Patch
+export interface PredicateExecutor<Expr extends ExpressionV2> {
+  include(ctx: IncludePredicateCtx<Expr>): StageInclude | undefined
+  exclude(ctx: ExcludePredicateCtx<Expr>): StageExclude | undefined
 }