@likec4/core 1.17.1 → 1.19.0

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

@@ -0,0 +1,324 @@
+import { filter, findLast, flatMap, hasAtLeast, isTruthy, map, only, pipe, reduce, unique } from 'remeda'
+import { nonNullable } from '../../errors'
+import type { LikeC4Model } from '../../model'
+import { findConnection } from '../../model/connection/model'
+import type { ElementModel } from '../../model/ElementModel'
+import type { AnyAux } from '../../model/types'
+import {
+  type Color,
+  type ComputedDynamicView,
+  type ComputedEdge,
+  DefaultArrowType,
+  DefaultLineStyle,
+  DefaultRelationshipColor,
+  type DynamicView,
+  type DynamicViewStep,
+  isDynamicViewParallelSteps,
+  isViewRuleAutoLayout,
+  isViewRulePredicate,
+  type NonEmptyArray,
+  type RelationId,
+  type RelationshipArrowType,
+  type RelationshipLineType,
+  type StepEdgeId,
+  stepEdgeId,
+  type Tag,
+  type ViewId
+} from '../../types'
+import { ancestorsFqn, commonAncestor, parentFqn } from '../../utils/fqn'
+import { applyCustomElementProperties } from '../utils/applyCustomElementProperties'
+import { applyViewRuleStyles } from '../utils/applyViewRuleStyles'
+import { buildComputedNodesFromElements } from '../utils/buildComputedNodes'
+import { buildElementNotations } from '../utils/buildElementNotations'
+import { elementExprToPredicate } from '../utils/elementExpressionToPredicate'
+import { resolveGlobalRulesInDynamicView } from '../utils/resolve-global-rules'
+import { calcViewLayoutHash } from '../utils/view-hash'
+
+type Element = ElementModel
+
+namespace DynamicViewCompute {
+  export interface Step {
+    id: StepEdgeId
+    source: Element
+    target: Element
+    title: string | null
+    description?: string
+    technology?: string
+    color?: Color
+    line?: RelationshipLineType
+    head?: RelationshipArrowType
+    tail?: RelationshipArrowType
+    relations: RelationId[]
+    isBackward: boolean
+    navigateTo?: ViewId
+    tags?: NonEmptyArray<Tag>
+  }
+}
+
+class DynamicViewCompute {
+  // Intermediate state
+  private explicits = new Set<Element>()
+  private steps = [] as DynamicViewCompute.Step[]
+
+  constructor(
+    protected model: LikeC4Model,
+    protected view: DynamicView
+  ) {}
+
+  private addStep(
+    {
+      source: stepSource,
+      target: stepTarget,
+      title: stepTitle,
+      isBackward,
+      navigateTo: stepNavigateTo,
+      ...step
+    }: DynamicViewStep,
+    index: number,
+    parent?: number
+  ) {
+    const id = parent ? stepEdgeId(parent, index) : stepEdgeId(index)
+    const source = this.model.element(stepSource)
+    const target = this.model.element(stepTarget)
+
+    this.explicits.add(source)
+    this.explicits.add(target)
+
+    const {
+      title,
+      relations,
+      tags,
+      navigateTo: derivedNavigateTo,
+      head,
+      tail,
+      color,
+      line,
+      notation
+    } = this.findRelations(source, target)
+
+    const navigateTo = isTruthy(stepNavigateTo) && stepNavigateTo !== this.view.id ? stepNavigateTo : derivedNavigateTo
+
+    this.steps.push({
+      id,
+      ...step,
+      source,
+      target,
+      title: stepTitle ?? title,
+      relations: relations ?? [],
+      isBackward: isBackward ?? false,
+      ...(navigateTo ? { navigateTo } : {}),
+      ...(tags ? { tags } : {}),
+      ...(head ? { head } : {}),
+      ...(tail ? { tail } : {}),
+      ...(color ? { color } : {}),
+      ...(line ? { line } : {}),
+      ...(notation ? { notation } : {})
+    })
+  }
+
+  compute(): ComputedDynamicView {
+    const {
+      docUri: _docUri, // exclude docUri
+      rules: _rules, // exclude rules
+      steps: viewSteps,
+      ...view
+    } = this.view
+
+    let stepNum = 1
+    for (const step of viewSteps) {
+      if (isDynamicViewParallelSteps(step)) {
+        if (step.__parallel.length === 0) {
+          continue
+        }
+        if (step.__parallel.length === 1) {
+          this.addStep(step.__parallel[0]!, stepNum)
+        } else {
+          step.__parallel.forEach((s, i) => this.addStep(s, i + 1, stepNum))
+        }
+      } else {
+        this.addStep(step, stepNum)
+      }
+      stepNum++
+    }
+
+    const rules = resolveGlobalRulesInDynamicView(_rules, this.model.globals())
+
+    for (const rule of rules) {
+      if (isViewRulePredicate(rule)) {
+        for (const expr of rule.include) {
+          const satisfies = elementExprToPredicate(expr)
+          for (const e of this.model.elements()) {
+            if (satisfies(e)) {
+              this.explicits.add(e)
+            }
+          }
+        }
+      }
+    }
+
+    const elements = [...this.explicits].map(e => e.$element)
+    const nodesMap = buildComputedNodesFromElements(elements)
+
+    const edges = this.steps.map(({ source, target, relations, title, isBackward, ...step }) => {
+      const sourceNode = nonNullable(nodesMap.get(source.id), `Source node ${source.id} not found`)
+      const targetNode = nonNullable(nodesMap.get(target.id), `Target node ${target.id} not found`)
+      const edge: ComputedEdge = {
+        parent: commonAncestor(source.id, target.id),
+        source: source.id,
+        target: target.id,
+        label: title,
+        relations,
+        color: DefaultRelationshipColor,
+        line: DefaultLineStyle,
+        head: DefaultArrowType,
+        ...step
+      }
+      if (isBackward) {
+        edge.dir = 'back'
+      }
+
+      while (edge.parent && !nodesMap.has(edge.parent)) {
+        edge.parent = parentFqn(edge.parent)
+      }
+      sourceNode.outEdges.push(edge.id)
+      targetNode.inEdges.push(edge.id)
+      // Process edge source ancestors
+      for (const sourceAncestor of ancestorsFqn(edge.source)) {
+        if (sourceAncestor === edge.parent) {
+          break
+        }
+        nodesMap.get(sourceAncestor)?.outEdges.push(edge.id)
+      }
+      // Process target hierarchy
+      for (const targetAncestor of ancestorsFqn(edge.target)) {
+        if (targetAncestor === edge.parent) {
+          break
+        }
+        nodesMap.get(targetAncestor)?.inEdges.push(edge.id)
+      }
+      return edge
+    })
+
+    const nodes = applyCustomElementProperties(
+      rules,
+      applyViewRuleStyles(
+        rules,
+        // Keep order of elements
+        elements.map(e => nonNullable(nodesMap.get(e.id)))
+      )
+    )
+
+    const autoLayoutRule = findLast(rules, isViewRuleAutoLayout)
+
+    const elementNotations = buildElementNotations(nodes)
+
+    return calcViewLayoutHash({
+      ...view,
+      autoLayout: {
+        direction: autoLayoutRule?.direction ?? 'LR',
+        ...(autoLayoutRule?.nodeSep && { nodeSep: autoLayoutRule.nodeSep }),
+        ...(autoLayoutRule?.rankSep && { rankSep: autoLayoutRule.rankSep })
+      },
+      nodes: map(nodes, n => {
+        // omit notation
+        delete n.notation
+        if (n.icon === 'none') {
+          delete n.icon
+        }
+        return n
+      }),
+      edges,
+      ...(elementNotations.length > 0 && {
+        notation: {
+          elements: elementNotations
+        }
+      })
+    })
+  }
+
+  private findRelations(source: Element, target: Element): {
+    title: string | null
+    tags: NonEmptyArray<Tag> | null
+    relations: NonEmptyArray<RelationId> | null
+    navigateTo: ViewId | null
+    tail: RelationshipArrowType | null
+    head: RelationshipArrowType | null
+    color: Color | null
+    line: RelationshipLineType | null
+    notation: string | null
+  } {
+    const relationships = findConnection(source, target, 'directed').flatMap(r => [...r.relations])
+    if (relationships.length === 0) {
+      return {
+        title: null,
+        tags: null,
+        relations: null,
+        navigateTo: null,
+        tail: null,
+        head: null,
+        color: null,
+        line: null,
+        notation: null
+      }
+    }
+    const alltags = pipe(
+      relationships,
+      flatMap(r => r.tags),
+      filter(isTruthy),
+      unique()
+    )
+    const tags = hasAtLeast(alltags, 1) ? alltags : null
+    const relations = hasAtLeast(relationships, 1) ? map(relationships, r => r.id) : null
+
+    // Most closest relation
+    const relation = only(relationships) || relationships.find(r => r.source === source && r.target === target)
+    const relationNavigateTo = relation?.$relationship.navigateTo ?? null
+
+    const navigateTo = relationNavigateTo && relationNavigateTo !== this.view.id ? relationNavigateTo : pipe(
+      relationships,
+      map(r => r.$relationship.navigateTo),
+      filter(isTruthy),
+      filter(v => v !== this.view.id),
+      unique(),
+      only()
+    )
+
+    const commonProperties = pipe(
+      relationships,
+      reduce((acc, { title, $relationship: r }) => {
+        isTruthy(title) && acc.title.add(title)
+        isTruthy(r.tail) && acc.tail.add(r.tail)
+        isTruthy(r.head) && acc.head.add(r.head)
+        isTruthy(r.color) && acc.color.add(r.color)
+        isTruthy(r.line) && acc.line.add(r.line)
+
+        return acc
+      }, {
+        tail: new Set<RelationshipArrowType>(),
+        head: new Set<RelationshipArrowType>(),
+        color: new Set<Color>(),
+        line: new Set<RelationshipLineType>(),
+        notation: new Set<string>(),
+        title: new Set<string>()
+      })
+    )
+
+    return {
+      tags,
+      relations,
+      navigateTo: navigateTo ?? null,
+      title: only([...commonProperties.title]) ?? null,
+      tail: only([...commonProperties.tail]) ?? null,
+      head: only([...commonProperties.head]) ?? null,
+      color: only([...commonProperties.color]) ?? null,
+      line: only([...commonProperties.line]) ?? null,
+      notation: only([...commonProperties.notation]) ?? null
+    }
+  }
+}
+export function computeDynamicView<M extends AnyAux>(
+  model: LikeC4Model<M>,
+  view: DynamicView
+): ComputedDynamicView {
+  return new DynamicViewCompute(model, view).compute()
+}

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

@@ -0,0 +1,258 @@
+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 ElementViewRulesBuilder,
+  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 { ComputedElementView, ElementView, ViewId, ViewRule } from '../../../types'
+import { compareNatural } from '../../../utils'
+import { imap, toArray } from '../../../utils/iterable'
+import { difference as differenceSet } from '../../../utils/set'
+import type { CtxConnection, CtxElement } from '../../memory'
+import { withReadableEdges } from '../../utils/with-readable-edges'
+import { processPredicates as processPredicatesImpl } from '../compute'
+import { type Ctx, Memory } from '../memory'
+
+type ConnectionExpression<T extends AnyTypes> = `${T['Fqn']} -> ${T['Fqn']}`
+
+// type ConnectionsDeepMatcher<T extends AnyTypes> = {
+//   [K in `${T['Fqn']} -> ${T['Fqn']}`]?: {
+//     relations?: Array<`${T['Fqn']} -> ${T['Fqn']}`>
+//   }
+// }
+
+type ConnectionsDeepMatcher<Expr extends string> = {
+  [K in Expr]?: Array<Expr>
+}
+
+type ConnectionEqual<T extends AnyTypes> = [ConnectionsDeepMatcher<ConnectionExpression<T>>] | [
+  ConnectionExpression<T>,
+  ...ConnectionExpression<T>[],
+]
+
+type Elem = CtxElement<Ctx>
+type Connection = CtxConnection<Ctx>
+
+export class TestHelper<T extends AnyTypes> {
+  model: Types.ToLikeC4Model<T>
+
+  static $include = viewhelpers.$include
+  static $exclude = viewhelpers.$exclude
+  static $rules = viewhelpers.$rules
+  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: ElementViewRulesBuilder<T>[]) => {
+    return withReadableEdges(
+      this.builder
+        .clone()
+        .views(_ => _.view('dev').with(...rules))
+        .toLikeC4Model()
+        .view('dev')
+        .$view as ComputedElementView<'dev'>,
+      ' -> ',
+    )
+  }
+
+  processPredicates(...rules: ElementViewRulesBuilder<T>[]) {
+    return ProcessPredicates.execute(this, ...rules)
+  }
+  processPredicatesWithScope(scope: T['Fqn'], ...rules: ElementViewRulesBuilder<T>[]) {
+    return ProcessPredicates.executeWithScope(this, scope, ...rules)
+  }
+
+  expectView(view: ComputedElementView) {
+    return {
+      toHave: (nodesAndEdges: { nodes: Array<T['Fqn']>; 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['Fqn']>(...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: ElementViewRulesBuilder<T>[]) {
+    return this.expectView(this.computeView(...rules))
+  }
+
+  expectMemory = (memory: Memory) => ({
+    toHaveAllElements: <Id extends T['Fqn']>(...ids: Id[]) => {
+      this._expect(map([...memory.elements], prop('id'))).toEqual(ids)
+    },
+    /**
+     * Final elements (visible in the view)
+     */
+    toHaveElements: <Id extends T['Fqn']>(...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 => [...c.relations].map(prop('expression')).sort(compareNatural)),
+      )
+      const expected = mapValues(matcher, (v: any) => [...v].sort(compareNatural))
+      this._expect(obj).toEqual(expected)
+    },
+  })
+
+  expectStep = (step: ProcessPredicates<T>) => ({
+    ...this.expectMemory(step.memory),
+  })
+
+  expect(value: ComputedElementView): 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> | ComputedElementView | 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: ElementViewRulesBuilder<A>[]
+  ): ProcessPredicates<A> {
+    const processor = new ProcessPredicates(test)
+    processor.next(...rules)
+    return processor
+  }
+
+  static executeWithScope<A extends AnyTypes>(
+    test: TestHelper<A>,
+    scope: A['Fqn'],
+    ...rules: ElementViewRulesBuilder<A>[]
+  ): ProcessPredicates<A> {
+    const processor = new ProcessPredicates(test, scope)
+    processor.next(...rules)
+    return processor
+  }
+
+  public viewrules: ReadonlyArray<ViewRule> = []
+
+  public previousMemory: Memory = Memory.empty(null)
+  public memory: Memory = Memory.empty(null)
+  public predicates: ElementViewRulesBuilder<T>[] = []
+
+  constructor(
+    public readonly t: TestHelper<T>,
+    public scope: T['Fqn'] | null = null,
+    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: ElementViewRulesBuilder<T>[]): this {
+    const view = {
+      id: 'test' as ViewId,
+      __: 'element',
+      rules: [],
+    } as any as Writable<ElementView>
+    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
+    const scope = this.scope ? this.t.model.element(this.scope) : null
+    this.memory = processPredicatesImpl(
+      this.t.model,
+      Memory.empty(scope),
+      view.rules,
+    )
+    this.age++
+    return this
+  }
+}