@likec4/core 1.38.1 → 1.39.0

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

@@ -1,249 +0,0 @@
-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 type { AnyAux, LikeC4Model } from '../../../model'
-import { differenceConnections } from '../../../model/connection'
-import {
-  type ComputedDeploymentView,
-  type DeploymentViewRule,
-  type ParsedDeploymentView as DeploymentView,
-  type ViewId,
-  _stage,
-  _type,
-} from '../../../types'
-import { difference as differenceSet, imap, invariant, toArray } from '../../../utils'
-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> {
-  Aux!: Types.ToAux<T>
-
-  model: LikeC4Model.Computed<typeof this.Aux>
-
-  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()
-  }
-
-  computeView = (...rules: DeploymentRulesBuilderOp<T>[]) => {
-    const view = this.builder
-      .clone()
-      .views(_ => _.deploymentView('dev').with(...rules))
-      .toLikeC4Model()
-      .view('dev')
-    invariant(view.isDeploymentView())
-    return withReadableEdges(
-      view.$view,
-      ' -> ',
-    )
-  }
-
-  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<AnyAux>> = []
-
-  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,
-      [_stage]: 'parsed',
-      [_type]: 'deployment',
-      rules: [],
-      title: null,
-      description: null,
-    } as Writable<DeploymentView<typeof this.t.model.Aux>>
-    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,238 +0,0 @@
-import { map, prop } from 'remeda'
-import type { DeploymentRulesBuilderOp } from '../../../builder'
-import { Builder } from '../../../builder'
-import { LikeC4Model } from '../../../model'
-import type { ParsedDeploymentView as 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: {},
-  },
-  tags: {
-    old: {
-      color: 'red',
-    },
-    next: {
-      color: 'green',
-    },
-    temp: {
-      color: 'blue',
-    },
-  },
-  relationships: { 'https': {} },
-})
-
-export const builder = b
-  .with(
-    model(
-      person('customer', {
-        title: 'Happy Customer',
-      }),
-      system('cloud').with(
-        component('frontend').with(
-          webapp('dashboard', {
-            title: 'Dashboard',
-          }),
-          mobile('mobile', {
-            title: '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', {
-        title: 'opens in browser',
-        tags: ['old'],
-      }),
-      $m.rel('cloud.frontend.dashboard', 'cloud.auth', {
-        title: 'authenticates',
-        color: 'green',
-      }),
-      $m.rel('cloud.frontend.dashboard', 'cloud.backend.api', {
-        title: 'fetches data',
-        tags: ['old'],
-      }),
-      $m.rel('cloud.frontend.dashboard', 'cloud.media', {
-        title: 'fetches media',
-        tags: ['temp'],
-      }),
-      $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', {
-              title: 'prod.eu.zone1/dashboard',
-            }),
-          ),
-          zone('zone2').with(
-            instanceOf('api', 'cloud.backend.api'),
-            instanceOf('ui', 'cloud.frontend.dashboard', {
-              title: 'prod.eu.zone2/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', {
-              title: 'prod.us.zone1/dashboard',
-            }),
-          ),
-          instanceOf('db', 'aws.rds'),
-        ),
-      ),
-      env('dev').with(
-        node('devCustomer').with(
-          instanceOf('instance', 'customer'),
-        ),
-        node('devCloud').with(
-          instanceOf('instance', 'cloud'),
-        ),
-      ),
-      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.fromParsed(modelsource)
-
-  const view = withReadableEdges(computeDeploymentView(model, modelsource.views.index as DeploymentView<any>))
-
-  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,
-  }
-}
-
-export function createModel() {
-  return LikeC4Model.fromParsed(builder.build())
-}

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

@@ -1,67 +0,0 @@
-import { partition } from 'remeda'
-import type {
-  DynamicViewIncludeRule,
-  DynamicViewRule,
-  DynamicViewStep,
-  ElementViewPredicate,
-  Fqn,
-  ParsedDynamicView as DynamicView,
-  ViewId,
-} from '../../../types'
-import { type $Aux, type FakeElementIds, fakeModel } from '../../element-view/__test__/fixture'
-import { computeDynamicView } from '../compute'
-
-const emptyView = {
-  _type: 'dynamic' as const,
-  id: 'index' as ViewId,
-  title: null,
-  description: null,
-  tags: null,
-  links: null,
-  rules: [],
-}
-
-type StepExpr = `${FakeElementIds} ${'->' | '<-'} ${FakeElementIds}`
-type StepProps = Omit<DynamicViewStep, 'source' | 'target' | 'isBackward'>
-
-export function $step(expr: StepExpr, props?: string | Partial<StepProps>): DynamicViewStep {
-  const title = typeof props === 'string' ? props : props?.title
-  if (expr.includes(' -> ')) {
-    const [source, target] = expr.split(' -> ')
-    return {
-      source: source as Fqn,
-      target: target as Fqn,
-      ...(typeof props === 'object' ? props : {}),
-      title: title ?? null,
-    }
-  }
-  if (expr.includes(' <- ')) {
-    const [target, source] = expr.split(' <- ')
-    return {
-      source: source as Fqn,
-      target: target as Fqn,
-      ...(typeof props === 'object' ? props : {}),
-      title: title ?? null,
-      isBackward: true,
-    }
-  }
-  throw new Error(`Invalid step expression: ${expr}`)
-}
-
-export function compute(
-  stepsAndRules: (DynamicViewStep<$Aux> | ElementViewPredicate<$Aux> | DynamicViewIncludeRule<$Aux>)[],
-) {
-  const [steps, rules] = partition(stepsAndRules, (s): s is DynamicViewStep => 'source' in s)
-  let view = computeDynamicView(
-    fakeModel,
-    {
-      ...emptyView,
-      steps,
-      rules: rules as DynamicViewRule[],
-    } as DynamicView,
-  )
-  return Object.assign(view, {
-    nodeIds: view.nodes.map((node) => node.id) as string[],
-    edgeIds: view.edges.map((edge) => edge.id) as string[],
-  })
-}