@likec4/core 1.17.1 → 1.19.0

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

@@ -0,0 +1,83 @@
+import { mapValues } from 'remeda'
+import { nonexhaustive } from '../errors'
+import { LikeC4Model } from '../model'
+import {
+  type ComputedLikeC4Model,
+  type ComputedView,
+  isDeploymentView,
+  isDynamicView,
+  isElementView,
+  type LikeC4View,
+  type ParsedLikeC4Model
+} from '../types'
+import { computeDeploymentView } from './deployment-view/compute'
+import { computeDynamicView } from './dynamic-view/compute'
+import { computeElementView } from './element-view/compute'
+
+export type ComputeViewResult<V extends ComputedView = ComputedView> =
+  | {
+    isSuccess: true
+    error?: undefined
+    view: V
+  }
+  | {
+    isSuccess: false
+    error: Error
+    view: undefined
+  }
+
+export function unsafeComputeView(
+  viewsource: LikeC4View,
+  likec4model: LikeC4Model
+): ComputedView {
+  switch (true) {
+    case isDeploymentView(viewsource): {
+      return computeDeploymentView(likec4model, viewsource)
+    }
+    case isDynamicView(viewsource):
+      return computeDynamicView(likec4model, viewsource)
+    case isElementView(viewsource):
+      return computeElementView(likec4model, viewsource)
+    default:
+      nonexhaustive(viewsource)
+  }
+}
+
+export function computeView<V extends LikeC4View>(
+  viewsource: V,
+  likec4model: LikeC4Model
+): ComputeViewResult {
+  try {
+    return {
+      isSuccess: true,
+      view: unsafeComputeView(viewsource, likec4model)
+    }
+  } catch (e) {
+    return {
+      isSuccess: false,
+      error: e instanceof Error ? e : new Error(`Unknown error: ${e}`),
+      view: undefined
+    }
+  }
+}
+
+export function computeViews<P extends ParsedLikeC4Model>(parsed: P): ComputedLikeC4Model {
+  const { views, ...rest } = parsed as Omit<P, '__'>
+  const likec4model = LikeC4Model.create({
+    ...rest,
+    views: {}
+  })
+  const compute = (source: LikeC4View): ComputedView => {
+    const result = computeView(source, likec4model)
+    if (result.isSuccess) {
+      return result.view
+    } else {
+      throw result.error
+    }
+  }
+  return {
+    ...rest,
+    __: 'computed',
+    views: mapValues(parsed.views, compute)
+  }
+}

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

@@ -0,0 +1,198 @@
+import { map, prop } from 'remeda'
+import type { DeploymentRulesBuilderOp } from '../../../builder'
+import { Builder } from '../../../builder'
+import { LikeC4Model } from '../../../model'
+import type { DeploymentView } from '../../../types'
+import { withReadableEdges } from '../../utils/with-readable-edges'
+import { computeDeploymentView } from '../compute'
+
+const {
+  builder: b,
+  model: {
+    model,
+    person,
+    system,
+    component,
+    webapp,
+    mobile,
+    ...$m
+  },
+  deployment: {
+    deployment,
+    env,
+    node,
+    zone,
+    instanceOf,
+    ...$d
+  },
+  views: {
+    views,
+    deploymentView,
+    $rules,
+    $include,
+    $exclude,
+  },
+} = Builder.forSpecification({
+  elements: {
+    person: {
+      style: {
+        shape: 'person',
+      },
+    },
+    system: {},
+    component: {},
+    webapp: {
+      style: {
+        shape: 'browser',
+      },
+    },
+    mobile: {
+      style: {
+        shape: 'mobile',
+      },
+    },
+  },
+  deployments: {
+    env: {},
+    zone: {},
+    node: {},
+  },
+})
+
+export const builder = b
+  .with(
+    model(
+      person('customer', {
+        title: 'Happy Customer',
+      }),
+      system('cloud').with(
+        component('frontend').with(
+          webapp('dashboard'),
+          mobile('mobile'),
+        ),
+        component('auth'),
+        component('backend').with(
+          component('api'),
+        ),
+        component('media', {
+          shape: 'storage',
+        }),
+      ),
+      system('aws').with(
+        component('rds', {
+          shape: 'storage',
+        }),
+        component('s3', {
+          shape: 'storage',
+        }),
+      ),
+      system('email'),
+    ),
+    model(
+      $m.rel('customer', 'cloud', 'uses services'),
+      $m.rel('customer', 'cloud.frontend.mobile', 'opens mobile app'),
+      $m.rel('customer', 'cloud.frontend.dashboard', 'opens in browser'),
+      $m.rel('cloud.frontend.dashboard', 'cloud.auth', {
+        title: 'authenticates',
+        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',
+      }),
+      $m.rel('cloud.frontend.mobile', 'cloud.backend.api', 'fetches data'),
+      $m.rel('cloud.frontend.mobile', 'cloud.media', 'fetches media'),
+      $m.rel('cloud.backend.api', 'cloud.auth', 'authorizes'),
+      $m.rel('cloud.backend.api', 'cloud.media', 'uploads media'),
+      $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'),
+    ),
+    deployment(
+      node('customer').with(
+        instanceOf('instance', 'customer'),
+      ),
+      env('prod').with(
+        zone('eu').with(
+          zone('zone1').with(
+            instanceOf('api', 'cloud.backend.api'),
+            instanceOf('ui', 'cloud.frontend.dashboard'),
+          ),
+          zone('zone2').with(
+            instanceOf('api', 'cloud.backend.api'),
+            instanceOf('ui', 'cloud.frontend.dashboard'),
+          ),
+          instanceOf('auth', 'cloud.auth'),
+          instanceOf('media', 'cloud.media'),
+          instanceOf('db', 'aws.rds'),
+        ),
+        zone('us').with(
+          zone('zone1').with(
+            instanceOf('api', 'cloud.backend.api'),
+            instanceOf('ui', 'cloud.frontend.dashboard'),
+          ),
+          instanceOf('db', 'aws.rds'),
+        ),
+      ),
+      env('acc').with(
+        node('testCustomer').with(
+          instanceOf('instance', 'customer'),
+        ),
+        zone('eu').with(
+          instanceOf('api', 'cloud.backend.api'),
+          instanceOf('ui', 'cloud.frontend.dashboard'),
+          instanceOf('auth', 'cloud.auth'),
+          instanceOf('db', 'aws.rds'),
+        ),
+      ),
+      env('global').with(
+        instanceOf('email', 'email'),
+      ),
+      $d.rel('prod.eu.db', 'prod.us.db', {
+        title: 'replicates',
+        color: 'green',
+      }),
+      $d.rel('prod.us.db', 'prod.eu.db', {
+        title: 'replicates',
+        color: 'amber',
+      }),
+    ),
+  )
+  .clone()
+
+export type Types = typeof builder['Types']
+
+export { $exclude, $include }
+
+export function computeView(...rules: DeploymentRulesBuilderOp<Types>[]) {
+  const modelsource = builder.clone()
+    .with(
+      views(
+        deploymentView('index', $rules(...rules)),
+      ),
+    ).build()
+
+  const model = LikeC4Model.create({
+    ...modelsource,
+    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[],
+  })
+}
+
+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,
+  }
+}

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

@@ -0,0 +1,37 @@
+import { LikeC4DeploymentModel } from '../../model'
+import type { RelationshipModel } from '../../model/RelationModel'
+import type { ExpressionV2 } from '../../types'
+import type { Ctx, Memory, Stage, StageExclude, StageInclude } from './memory'
+
+export { Memory, type Stage } from './memory'
+
+export type Where<T extends {}> = (x: T) => boolean
+
+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
+  stage: Stage
+  model: LikeC4DeploymentModel
+  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 ExpressionV2> {
+  include(ctx: IncludePredicateCtx<Expr>): StageInclude | undefined
+  exclude(ctx: ExcludePredicateCtx<Expr>): StageExclude | undefined
+}