@likec4/core 1.17.1 → 1.19.0

package/src/compute-view/deployment-view/stages/stage-final.ts

@@ -0,0 +1,245 @@
+import DefaultMap from 'mnemonist/default-map'
+import { forEach, only, pipe } from 'remeda'
+import { differenceConnections } from '../../../model/connection'
+import type { RelationshipModel } from '../../../model/RelationModel'
+import { isAncestor, sortByFqnHierarchically } from '../../../utils/fqn'
+import { ifilter, isome, toArray } from '../../../utils/iterable'
+import { difference, union } from '../../../utils/set'
+import { treeFromMemoryState } from '../../memory'
+import { cleanCrossBoundary, cleanRedundantRelationships } from '../clean-connections'
+import type { Ctx, Memory } from '../memory'
+
+type Elem = Ctx['Element']
+/**
+ * This patch:
+ * 1. Keeps connections between leafs or having direct deployment relations
+ * 2. Removes cross-boundary model relations, that already exist inside boundaries
+ *    (e.g. prefer relations inside same deployment node over relations between nodes)
+ * 3. Removes implicit connections between elements, if their descendants have same connection
+ */
+export class StageFinal {
+  static for(memory: Memory) {
+    return new StageFinal(memory)
+  }
+
+  private constructor(
+    protected readonly memory: Memory,
+  ) {
+  }
+
+  public step1CleanConnections(memory: Memory): Memory {
+    if (memory.connections.length < 2) {
+      return memory
+    }
+
+    // const leafs = new Set<Elem>()
+
+    // for (const element of memory.final) {
+    //   // Instance is always leaf
+    //   if (element.isInstance()) {
+    //     leafs.add(element)
+    //     continue
+    //   }
+    //   // Check if element is ancestor of any element in elements
+    //   let isLeaf = true
+    //   for (const el of memory.final) {
+    //     if (isAncestor(element.id, el.id)) {
+    //       isLeaf = false
+    //       break
+    //     }
+    //   }
+    //   if (isLeaf) {
+    //     leafs.add(element)
+    //   }
+    // }
+
+    const connections = pipe(
+      memory.connections,
+      // Keep connections
+      // - between leafs
+      // - has direct deployment relation
+      // filter(c => {
+      //   return (leafs.has(c.source) && leafs.has(c.target)) || c.hasDirectDeploymentRelation()
+      // }),
+      cleanCrossBoundary,
+      cleanRedundantRelationships,
+    )
+
+    const connectionsToExclude = differenceConnections(
+      memory.connections,
+      connections,
+    )
+    if (connectionsToExclude.length === 0) {
+      return memory
+    }
+    const stage = memory.stageExclude({} as any)
+    stage.excludeConnections(connectionsToExclude, true)
+    return stage.commit()
+  }
+
+  public step2ProcessImplicits(memory: Memory): Memory {
+    const implicits = union(this.memory.elements, memory.elements)
+    const final = union(memory.final, this.memory.explicits)
+
+    // Find connections based on same relation but different boundaries
+    const groupedByRelation = new DefaultMap<RelationshipModel, Set<Elem>>(() => new Set())
+    for (const conn of memory.connections) {
+      if (conn.boundary) {
+        for (const relation of conn.relations.model) {
+          groupedByRelation.get(relation).add(conn.boundary)
+        }
+      }
+    }
+    for (const [_, boundaries] of groupedByRelation) {
+      if (boundaries.size < 2) {
+        continue
+      }
+      for (const boundary of boundaries) {
+        if (implicits.delete(boundary)) {
+          final.add(boundary)
+        }
+      }
+    }
+
+    const snapshot = new Set(final)
+    const isFinalOrHasIncludedDescendant = (el: Elem) => {
+      for (const final of snapshot) {
+        if (el === final || isAncestor(el, final)) {
+          return true
+        }
+      }
+      return false
+    }
+
+    // Pick from implicit elements
+    pipe(
+      difference(implicits, snapshot),
+      ifilter(e => e.isDeploymentNode()),
+      toArray(),
+      sortByFqnHierarchically,
+      forEach((el) => {
+        // If element has more 2 or more children included
+        // It can "box" around
+        const childrensToWrap = [...el.children()].filter(isFinalOrHasIncludedDescendant).length
+        if (childrensToWrap >= 2) {
+          final.add(el)
+          return
+        }
+        // If Element has only one child included
+        // and has "similar" sibling with included descendant
+        if (childrensToWrap === 1 && isome(el.siblings(), isFinalOrHasIncludedDescendant)) {
+          final.add(el)
+        }
+      }),
+    )
+
+    return memory.update({ final })
+  }
+
+  public step3ProcessBoundaries(memory: Memory): Memory {
+    const boundaries = new Set<Elem>()
+    for (const conn of memory.connections) {
+      if (conn.boundary) {
+        boundaries.add(conn.boundary)
+      }
+    }
+    const tree = treeFromMemoryState<Ctx>(memory, 'final')
+    const stage = memory.stageExclude({} as any)
+
+    const isRemovable = (el: Elem) =>
+      !(
+        boundaries.has(el)
+        || memory.explicits.has(el)
+        || tree.hasInOut(el)
+        || tree.root.has(el)
+      )
+
+    const singleRoot = only([...tree.root])
+    if (singleRoot && !memory.explicits.has(singleRoot)) {
+      stage.exclude(singleRoot)
+    }
+
+    for (const el of memory.final) {
+      const singleChild = only(tree.children(el))
+      if (singleChild && !tree.hasInOut(singleChild) && isRemovable(el)) {
+        stage.exclude(el)
+      }
+    }
+
+    if (stage.isDirty()) {
+      return stage.commit()
+    }
+    return memory
+  }
+
+  // TODO: Lot of corner cases to cover, skip for now
+  // public step3FlatNodes(memory: Memory): Memory {
+  //   // final implicits
+  //   const explicits = new Set<Elem>([
+  //     ...memory.explicits,
+  //     ...memory.connections.flatMap(c => [c.source, c.target]),
+  //   ])
+  //   const sorted = sortParentsFirst(toArray(memory.final))
+
+  //   const toplevel = new Set<Elem>(sorted)
+  //   const children = sorted.reduce((acc, el, index, all) => {
+  //     acc.set(
+  //       el,
+  //       new Set(
+  //         all
+  //           .slice(index + 1)
+  //           .filter(e => isAncestor(el, e))
+  //           .reduce((acc, el) => {
+  //             if (!acc.some(e => isAncestor(e, el))) {
+  //               toplevel.delete(el)
+  //               acc.push(el)
+  //             }
+  //             return acc
+  //           }, [] as Elem[]),
+  //       ),
+  //     )
+  //     return acc
+  //   }, new DefaultMap<Elem, Set<Elem>>(() => new Set()))
+
+  //   const state = memory.mutableState()
+
+  //   function flattenNode(node: Elem) {
+  //     const _children = [...children.get(node)]
+  //     if (_children.length > 1) {
+  //       for (const child of _children) {
+  //         flattenNode(child)
+  //       }
+  //       return !explicits.has(node)
+  //     }
+  //     if (hasAtLeast(_children, 1)) {
+  //       if (flattenNode(_children[0])) {
+  //         state.final.delete(_children[0])
+  //       }
+  //     }
+  //     return !explicits.has(node)
+  //   }
+
+  //   const root = [...toplevel]
+  //   for (const node of root) {
+  //     flattenNode(node)
+  //     if (!explicits.has(node) && children.get(node).size === 1) {
+  //       state.final.delete(node)
+  //     }
+  //   }
+  //   if (root.length === 1 && !explicits.has(root[0]!)) {
+  //     state.final.delete(root[0]!)
+  //   }
+
+  //   return memory.update(state)
+  // }
+
+  public commit(): Memory {
+    // return []
+    const step1 = this.step1CleanConnections(this.memory)
+    const step2 = this.step2ProcessImplicits(step1)
+    return this.step3ProcessBoundaries(step2)
+    // return step2memory
+    // const step3m?emory = this.step3FlatNodes(step2memory)
+    // return step3memory
+  }
+}

package/src/compute-view/deployment-view/stages/stage-include.ts

@@ -0,0 +1,95 @@
+import { dropWhile, forEach, pipe, take, zip } from 'remeda'
+import { findConnection, findConnectionsBetween } from '../../../model/connection/deployment'
+import { isIterable } from '../../../utils'
+import { toArray } from '../../../utils/iterable'
+import { type CtxConnection, type CtxElement, AbstractStageInclude } from '../../memory'
+import { cleanCrossBoundary, cleanRedundantRelationships } from '../clean-connections'
+import { type Ctx } from '../memory/memory'
+
+type Elem = CtxElement<Ctx>
+type Connection = CtxConnection<Ctx>
+
+export class StageInclude extends AbstractStageInclude<Ctx> {
+  /**
+   * Connects elements with existing ones in the memory
+   */
+  public override connectWithExisting(
+    elements: Elem | Iterable<Elem>,
+    direction: 'in' | 'out' | 'both' = 'both',
+  ): boolean {
+    const before = this._connections.length
+    const hasChanged = () => this._connections.length > before
+    if (!isIterable(elements)) {
+      if (direction === 'in' || direction === 'both') {
+        for (const el of this.memory.elements) {
+          this.addConnections(
+            findConnection(el, elements, 'directed'),
+          )
+        }
+      }
+      if (direction === 'out' || direction === 'both') {
+        this.addConnections(
+          findConnectionsBetween(elements, this.memory.elements, 'directed'),
+        )
+      }
+      return hasChanged()
+    }
+
+    const targets = [...elements]
+    if (direction === 'in' || direction === 'both') {
+      for (const el of this.memory.elements) {
+        this.addConnections(
+          findConnectionsBetween(el, targets, 'directed'),
+        )
+      }
+    }
+    if (direction === 'out' || direction === 'both') {
+      for (const el of targets) {
+        this.addConnections(
+          findConnectionsBetween(el, this.memory.elements, 'directed'),
+        )
+      }
+    }
+    return hasChanged()
+  }
+
+  protected override processConnections(connections: Connection[]) {
+    const clean = pipe(
+      connections,
+      cleanCrossBoundary,
+      cleanRedundantRelationships,
+    )
+
+    pipe(
+      clean,
+      // Process only connection from this stage
+      // filter(c => this._connections.some(c2 => c2.id === c.id)),
+      forEach(({ source, target, boundary }) => {
+        pipe(
+          zip(
+            [...toArray(source.ancestors()).reverse(), source],
+            [...toArray(target.ancestors()).reverse(), target],
+          ),
+          // Filter out common ancestors
+          dropWhile(([sourceAncestor, targetAncestor]) => sourceAncestor === targetAncestor),
+          take(1),
+          forEach(([sourceAncestor, targetAncestor]) => {
+            if (source === sourceAncestor && target === targetAncestor) {
+              this.addImplicit(boundary)
+              return
+            }
+            if (sourceAncestor !== source && sourceAncestor.isDeploymentNode() && !sourceAncestor.onlyOneInstance()) {
+              // state.final.add(source)
+              this.addImplicit(sourceAncestor)
+            }
+            if (targetAncestor !== target && targetAncestor.isDeploymentNode() && !targetAncestor.onlyOneInstance()) {
+              // state.final.add(source)
+              this.addImplicit(targetAncestor)
+            }
+          }),
+        )
+      }),
+    )
+    return clean
+  }
+}

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

@@ -0,0 +1,276 @@
+import { hasAtLeast, isEmpty, isNumber, isString } from 'remeda'
+import { invariant, nonexhaustive } from '../../errors'
+import type { LikeC4DeploymentModel } from '../../model'
+import type { DeploymentConnectionModel } from '../../model/connection/deployment'
+import type { ElementModel } from '../../model/ElementModel'
+import type { AnyAux } from '../../model/types'
+import {
+  type ComputedEdge,
+  type ComputedNode,
+  DefaultArrowType,
+  type DeploymentNodeKind,
+  type DeploymentViewRule,
+  type Fqn,
+  FqnExpr,
+  isViewRuleStyle,
+  type NonEmptyArray,
+  type Tag,
+} from '../../types'
+import { nameFromFqn, parentFqn } from '../../utils'
+import { applyViewRuleStyle } from '../utils/applyViewRuleStyles'
+import { buildComputedNodes, type ComputedNodeSource } from '../utils/buildComputedNodes'
+import { mergePropsFromRelationships } from '../utils/merge-props-from-relationships'
+import { uniqueTags } from '../utils/uniqueTags'
+import type { Elem, Memory } from './_types'
+
+type Predicate<T> = (x: T) => boolean
+
+export function resolveElements(
+  model: LikeC4DeploymentModel,
+  expr: FqnExpr.DeploymentRef,
+): Elem[] {
+  const ref = model.element(expr.ref.deployment)
+  if (ref.isDeploymentNode()) {
+    if (expr.selector === 'children') {
+      return [...ref.children()]
+    }
+    if (expr.selector === 'expanded') {
+      return [ref, ...ref.children()]
+    }
+    if (expr.selector === 'descendants') {
+      return [...ref.descendants()]
+    }
+  }
+  return [ref]
+}
+
+export function resolveModelElements(
+  model: LikeC4DeploymentModel,
+  expr: FqnExpr.ModelRef,
+): ElementModel[] {
+  const ref = model.$model.element(expr.ref.model)
+  if (expr.selector === 'children') {
+    return [...ref.children()]
+  }
+  if (expr.selector === 'expanded') {
+    return [ref, ...ref.children()]
+  }
+  if (expr.selector === 'descendants') {
+    return [...ref.descendants()]
+  }
+  return [ref]
+}
+
+export function deploymentExpressionToPredicate<T extends { id: string; modelRef?: number | string }>(
+  target: FqnExpr,
+): Predicate<T> {
+  if (FqnExpr.isWildcard(target)) {
+    return () => true
+  }
+  if (FqnExpr.isDeploymentRef(target)) {
+    const fqn = target.ref.deployment
+    if (target.selector === 'expanded') {
+      const fqnWithDot = fqn + '.'
+      return n => n.id === fqn || n.id.startsWith(fqnWithDot)
+    }
+    if (target.selector === 'descendants') {
+      const fqnWithDot = fqn + '.'
+      return n => n.id.startsWith(fqnWithDot)
+    }
+    if (target.selector === 'children') {
+      return n => parentFqn(n.id) === fqn
+    }
+    return n => n.id === fqn
+  }
+  if (FqnExpr.isModelRef(target)) {
+    const modelFqn = (node: T) => {
+      if (isString(node.modelRef)) {
+        return node.modelRef
+      }
+      if (isNumber(node.modelRef)) {
+        return node.id
+      }
+      return null
+    }
+
+    const fqn = target.ref.model
+    if (target.selector === 'expanded') {
+      const fqnWithDot = fqn + '.'
+      return (n) => {
+        const m = modelFqn(n)
+        if (!m) {
+          return true
+        }
+        return m === fqn || m.startsWith(fqnWithDot)
+      }
+    }
+    if (target.selector === 'descendants') {
+      const fqnWithDot = fqn + '.'
+      return (n) => {
+        const m = modelFqn(n)
+        if (!m) {
+          return true
+        }
+        return m.startsWith(fqnWithDot)
+      }
+    }
+    if (target.selector === 'children') {
+      return (n) => {
+        const m = modelFqn(n)
+        if (!m) {
+          return true
+        }
+        return parentFqn(m) === fqn
+      }
+    }
+    return (n) => {
+      const m = modelFqn(n)
+      if (!m) {
+        return true
+      }
+      return m === fqn
+    }
+  }
+  nonexhaustive(target)
+}
+
+export function toNodeSource(el: Elem): ComputedNodeSource {
+  if (el.isDeploymentNode()) {
+    const onlyOneInstance = el.onlyOneInstance()
+    let { title, kind, id, ...$node } = el.$node
+    const { icon, color, shape, ...style } = el.$node.style ?? {}
+
+    // If there is only one instance and title was not overriden
+    if (onlyOneInstance && title === nameFromFqn(el.id)) {
+      title = onlyOneInstance.title
+    }
+
+    return {
+      ...(onlyOneInstance && {
+        ...toNodeSource(onlyOneInstance),
+        modelRef: onlyOneInstance.element.id,
+      }),
+      title,
+      ...$node,
+      ...(icon && { icon }),
+      ...(color && { color }),
+      ...(shape && { shape }),
+      style: {
+        ...style,
+      },
+      deploymentRef: 1,
+      kind,
+      id,
+    }
+  }
+  invariant(el.isInstance(), 'Expected Instance')
+  const instance = el.$instance
+  const element = el.element.$element
+
+  const icon = instance.style?.icon ?? element.icon
+  const color = instance.style?.color ?? element.color
+  const shape = instance.style?.shape ?? element.shape
+
+  const links = [
+    ...(element.links ?? []),
+    ...(instance.links ?? []),
+  ]
+
+  const metadata = {
+    ...element.metadata,
+    ...instance.metadata,
+  }
+
+  const notation = instance.notation ?? element.notation
+
+  return {
+    id: el.id,
+    kind: 'instance' as DeploymentNodeKind,
+    title: instance.title ?? element.title,
+    description: instance.description ?? element.description,
+    technology: instance.technology ?? element.technology,
+    tags: uniqueTags([element, instance]) as NonEmptyArray<Tag>,
+    links: hasAtLeast(links, 1) ? links : null,
+    ...icon && { icon },
+    ...color && { color },
+    ...shape && { shape },
+    style: {
+      ...element.style,
+      ...instance.style,
+    },
+    deploymentRef: el.id === instance.id ? 1 : instance.id,
+    modelRef: el.id === element.id ? 1 : element.id,
+    ...notation && { notation },
+    ...!isEmpty(metadata) && ({ metadata }),
+  }
+}
+
+export function toComputedEdges<M extends AnyAux>(
+  connections: ReadonlyArray<DeploymentConnectionModel<M>>,
+): ComputedEdge[] {
+  return connections.reduce((acc, e) => {
+    // const modelRelations = []
+    // const deploymentRelations = []
+    const relations = [
+      ...e.relations.model,
+      ...e.relations.deployment,
+    ]
+    invariant(hasAtLeast(relations, 1), 'Edge must have at least one relation')
+
+    const source = e.source.id
+    const target = e.target.id
+
+    const {
+      title,
+      ...props
+    } = mergePropsFromRelationships(relations.map(r => r.$relationship)) // || relations.find(r => r.source === source && r.target === target)
+
+    const edge: ComputedEdge = {
+      id: e.id,
+      parent: e.boundary?.id ?? null,
+      source,
+      target,
+      label: title ?? null,
+      relations: relations.map((r) => r.id as M['RelationId']),
+      ...props,
+    }
+
+    // If exists same edge but in opposite direction
+    const existing = acc.find(e => e.source === target && e.target === source)
+    if (existing && edge.label === existing.label) {
+      existing.dir = 'both'
+      const head = existing.head ?? edge.head ?? DefaultArrowType
+      existing.head ??= head
+      existing.tail ??= head
+
+      if (edge.color) {
+        existing.color ??= edge.color
+      }
+      if (edge.line) {
+        existing.line ??= edge.line
+      }
+      return acc
+    }
+
+    acc.push(edge)
+    return acc
+  }, [] as ComputedEdge[])
+}
+
+export function buildNodes(memory: Memory): ReadonlyMap<Fqn, ComputedNode> {
+  return buildComputedNodes([...memory.final].map(toNodeSource))
+}
+
+export function applyDeploymentViewRuleStyles(
+  rules: DeploymentViewRule[],
+  nodes: ComputedNode[],
+): ComputedNode[] {
+  for (const rule of rules) {
+    if (!isViewRuleStyle(rule) || rule.targets.length === 0) {
+      continue
+    }
+    const predicates = rule.targets.map(deploymentExpressionToPredicate)
+    applyViewRuleStyle(rule, predicates, nodes)
+  }
+  return nodes
+}

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

@@ -0,0 +1,58 @@
+import { partition } from 'remeda'
+import type { DynamicViewRule, DynamicViewStep, Fqn, ViewId, ViewRulePredicate } from '../../../types'
+import { type FakeElementIds, fakeModel } from '../../element-view/__test__/fixture'
+import { computeDynamicView } from '../compute'
+
+const emptyView = {
+  __: 'dynamic' as const,
+  id: 'index' as ViewId,
+  title: null,
+  description: null,
+  tags: null,
+  links: null,
+  customColorDefinitions: {},
+  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 | ViewRulePredicate)[]) {
+  const [steps, rules] = partition(stepsAndRules, (s): s is DynamicViewStep => 'source' in s)
+  let view = computeDynamicView(
+    fakeModel,
+    {
+      ...emptyView,
+      steps,
+      rules: rules as DynamicViewRule[]
+    }
+  )
+  return Object.assign(view, {
+    nodeIds: view.nodes.map((node) => node.id) as string[],
+    edgeIds: view.edges.map((edge) => edge.id) as string[]
+  })
+}