@likec4/core 1.17.1 → 1.19.0

package/src/compute-view/deployment-view/clean-connections.ts

@@ -0,0 +1,238 @@
+import DefaultMap from 'mnemonist/default-map'
+import {
+  dropWhile,
+  filter,
+  flatMap,
+  forEach,
+  groupBy,
+  hasAtLeast,
+  map,
+  pipe,
+  piped,
+  prop,
+  reduce,
+  values,
+} from 'remeda'
+import { invariant } from '../../errors'
+import {
+  DeploymentConnectionModel,
+  differenceConnections,
+  isNestedConnection,
+  mergeConnections,
+  sortConnectionsByBoundaryHierarchy,
+} from '../../model/connection'
+import { findConnection } from '../../model/connection/deployment'
+import { RelationshipsAccum } from '../../model/DeploymentElementModel'
+import type { RelationshipModel } from '../../model/RelationModel'
+import { imap, toArray } from '../../utils/iterable'
+import { intersection, union } from '../../utils/set'
+import type { Connection, Connections } from './_types'
+
+const filterEmptyConnection = filter((c: DeploymentConnectionModel<any>) => c.nonEmpty())
+
+type MapOfExcludesFromConnection = DefaultMap<DeploymentConnectionModel, Set<RelationshipModel>>
+function findCrossBoundarySameSourceOrTarget(connections: Connections): MapOfExcludesFromConnection {
+  // Also find connections based on same relation
+  const groupedByRelation = new DefaultMap<RelationshipModel, Array<DeploymentConnectionModel>>(() => [])
+  for (const conn of connections) {
+    for (const relation of conn.relations.model) {
+      groupedByRelation.get(relation).push(conn)
+    }
+  }
+
+  // Aggreate excluded relations for each connection
+  const excludedRelations = new DefaultMap<
+    DeploymentConnectionModel,
+    Set<RelationshipModel>
+  >(() => new Set())
+
+  // In each group, find connected to same leaf
+  for (const [relation, sameRelationGroup] of groupedByRelation) {
+    if (!hasAtLeast(sameRelationGroup, 2)) {
+      continue
+    }
+
+    // Outgoing from same source
+    pipe(
+      sameRelationGroup,
+      flatMap(conn => [
+        { group: `$source-${conn.source.id}`, conn },
+        { group: `$target-${conn.target.id}`, conn },
+      ]),
+      groupBy(prop('group')),
+      values(),
+      filter(hasAtLeast(2)),
+      forEach(
+        // In each group, sort by hierarchy, first are deepest
+        piped(
+          map(prop('conn')),
+          sortConnectionsByBoundaryHierarchy('desc'),
+          // Drop first, as it is the deepest
+          // Drop if boundary is same as previous
+          dropWhile((conn, i, all) => i === 0 || conn.boundary === all[i - 1]!.boundary),
+          // Drop relations from boundaries above
+          forEach((conn) => {
+            excludedRelations.get(conn).add(relation)
+          }),
+        ),
+      ),
+    )
+  }
+
+  return excludedRelations
+}
+
+/**
+ * Identifies and processes cross-boundary connections in a deployment diagram.
+ * This function analyzes connections between nodes and removes redundant relations
+ * when multiple connections exist between the same elements across different boundaries.
+ *
+ * The function performs the following:
+ * 1. Groups connections by their relationship type
+ * 2. For each relationship group, identifies connections that:
+ *    - Share the same source
+ *    - Share the same target
+ * 3. When multiple connections are found in the same group, keeps only the most specific
+ *    (deepest in hierarchy) connection and removes the relationship from others
+ *
+ * @param connections - The input collection of deployment connections to analyze
+ * @returns connections with redundant cross-boundary relationships
+ */
+export function findCrossBoundaryConnections(connections: Connections): Array<Connection> {
+  // Ensure connections are merged
+  connections = mergeConnections(connections)
+
+  const excludedRelations = findCrossBoundarySameSourceOrTarget(connections)
+
+  for (const c of connections) {
+    const { source, target } = c
+    const connectionModelRelations = c.relations.model
+    // Connections between node and instance
+    // Exclude internal relations of the node (otherwise they are cross-boundary)
+    if (source.isDeploymentNode() !== target.isDeploymentNode()) {
+      const node = source.isDeploymentNode() ? source : c.target
+      invariant(node.isDeploymentNode())
+      const nodeInternals = node.internalModelRelationships()
+      const toExclude = intersection(
+        connectionModelRelations,
+        nodeInternals,
+      )
+      for (const relation of toExclude) {
+        excludedRelations.get(c).add(relation)
+      }
+
+      continue
+    }
+
+    // Connection between nodes
+    if (source.isDeploymentNode() && target.isDeploymentNode()) {
+      const toExclude = union(
+        // Exclude node internals (otherwise thay are cross-boundary)
+        intersection(
+          c.relations.model,
+          source.internalModelRelationships(),
+        ),
+        intersection(
+          c.relations.model,
+          target.internalModelRelationships(),
+        ),
+      )
+      for (const relation of toExclude) {
+        excludedRelations.get(c).add(relation)
+      }
+    }
+  }
+
+  return pipe(
+    excludedRelations.entries(),
+    imap(([c, excluded]) =>
+      c.update({
+        model: excluded,
+        deployment: null,
+      })
+    ),
+    toArray(),
+  )
+}
+
+/**
+ * Cleans connections that cross boundaries by removing overlapping parts.
+ * @example
+ * ```ts
+ * const connections = getConnections();
+ * const cleanedConnections = cleanCrossBoundary(connections);
+ * ```
+ */
+export function cleanCrossBoundary(connections: Connections): Array<Connection> {
+  return differenceConnections(
+    connections,
+    findCrossBoundaryConnections(connections),
+  )
+}
+
+/**
+ * Identifies and returns redundant connections in a deployment view.
+ * A connection is considered redundant if its relationships are already implied
+ * through other connections
+ *
+ * @returns Array of redundant connections that can be safely removed
+ */
+export function findRedundantConnections(connections: Connections): Array<Connection> {
+  return pipe(
+    connections,
+    mergeConnections,
+    reduce((redundants, connection) => {
+      const { source, target, relations } = connection
+
+      // Connection between instances is always explicit
+      if (source.isInstance() && target.isInstance()) {
+        return redundants
+      }
+
+      let redundantAccum = RelationshipsAccum.empty()
+
+      if (source.isDeploymentNode() && target.isDeploymentNode()) {
+        const [reversed] = findConnection(target, source, 'directed')
+        if (reversed) {
+          redundantAccum = relations.intersect(reversed.relations)
+        }
+      }
+
+      for (const c of connections) {
+        if (isNestedConnection(c, connection)) {
+          redundantAccum = redundantAccum.union(
+            relations.intersect(c.relations),
+          )
+        }
+      }
+
+      if (redundantAccum.nonEmpty) {
+        redundants.push(
+          new DeploymentConnectionModel(
+            source,
+            target,
+            redundantAccum,
+          ),
+        )
+      }
+
+      return redundants
+    }, [] as DeploymentConnectionModel[]),
+  )
+}
+
+/**
+ * Remove relationships from connection model, that are already included in the connections between descendants.
+ * In other words - if there is same connection down the hierarchy.
+ *
+ * @returns New connection without redundant relationships
+ *          Connection may be empty if all relationships are redundant, in this case it should be removed
+ */
+export function cleanRedundantRelationships(
+  connections: Connections,
+): Array<Connection> {
+  return differenceConnections(
+    connections,
+    findRedundantConnections(connections),
+  )
+}

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

@@ -0,0 +1,125 @@
+import { findLast, map } from 'remeda'
+import { nonexhaustive } from '../../errors'
+import { type LikeC4DeploymentModel, LikeC4Model } from '../../model'
+import type { AnyAux } from '../../model/types'
+import type { DeploymentViewRule } from '../../types'
+import {
+  type ComputedDeploymentView,
+  type DeploymentView,
+  FqnExpr,
+  isViewRuleAutoLayout,
+  isViewRulePredicate,
+} from '../../types'
+import { RelationExpr } from '../../types/expression-v2'
+import { buildElementNotations } from '../utils/buildElementNotations'
+import { linkNodesWithEdges } from '../utils/link-nodes-with-edges'
+import { topologicalSort } from '../utils/topological-sort'
+import { calcViewLayoutHash } from '../utils/view-hash'
+import { Memory } from './memory'
+import { DeploymentRefPredicate } from './predicates/elements'
+import { DirectRelationPredicate } from './predicates/relation-direct'
+import { InOutRelationPredicate } from './predicates/relation-in-out'
+import { IncomingRelationPredicate } from './predicates/relation-incoming'
+import { OutgoingRelationPredicate } from './predicates/relation-outgoing'
+import { WildcardPredicate } from './predicates/wildcard'
+import { StageFinal } from './stages/stage-final'
+import { applyDeploymentViewRuleStyles, buildNodes, toComputedEdges } from './utils'
+
+export function processPredicates<M extends AnyAux>(
+  model: LikeC4DeploymentModel<M>,
+  rules: DeploymentViewRule[],
+) {
+  let memory = Memory.empty()
+
+  for (const rule of rules) {
+    if (isViewRulePredicate(rule)) {
+      const op = 'include' in rule ? 'include' : 'exclude'
+      const exprs = rule.include ?? rule.exclude
+      for (const expr of exprs) {
+        let stage = op === 'include' ? memory.stageInclude(expr) : memory.stageExclude(expr)
+        const ctx = { model, stage, memory }
+        switch (true) {
+          case FqnExpr.isModelRef(expr):
+            // Ignore model refs in deployment view
+            break
+          case FqnExpr.isDeploymentRef(expr):
+            stage = DeploymentRefPredicate[op]({ ...ctx, expr } as any) ?? stage
+            break
+          case FqnExpr.isWildcard(expr):
+            stage = WildcardPredicate[op]({ ...ctx, expr } as any) ?? stage
+            break
+          case RelationExpr.isDirect(expr):
+            stage = DirectRelationPredicate[op]({ ...ctx, expr } as any) ?? stage
+            break
+          case RelationExpr.isInOut(expr):
+            stage = InOutRelationPredicate[op]({ ...ctx, expr } as any) ?? stage
+            break
+          case RelationExpr.isOutgoing(expr):
+            stage = OutgoingRelationPredicate[op]({ ...ctx, expr } as any) ?? stage
+            break
+          case RelationExpr.isIncoming(expr):
+            stage = IncomingRelationPredicate[op]({ ...ctx, expr } as any) ?? stage
+            break
+          default:
+            nonexhaustive(expr)
+        }
+        memory = stage.commit()
+      }
+    }
+  }
+  return StageFinal.for(memory).commit()
+}
+
+export function computeDeploymentView<M extends AnyAux>(
+  likec4model: LikeC4Model<M>,
+  {
+    docUri: _docUri, // exclude docUri
+    rules, // exclude rules
+    ...view
+  }: DeploymentView,
+): ComputedDeploymentView<M['ViewId']> {
+  let memory = processPredicates<M>(likec4model.deployment, rules)
+
+  const nodesMap = buildNodes(memory)
+
+  const computedEdges = toComputedEdges(memory.connections)
+
+  linkNodesWithEdges(nodesMap, computedEdges)
+
+  const sorted = topologicalSort({
+    nodes: nodesMap,
+    edges: computedEdges,
+  })
+
+  const nodes = applyDeploymentViewRuleStyles(
+    rules,
+    sorted.nodes,
+  )
+
+  const autoLayoutRule = findLast(rules, isViewRuleAutoLayout)
+
+  const elementNotations = buildElementNotations(nodes)
+
+  return calcViewLayoutHash({
+    ...view,
+    autoLayout: {
+      direction: autoLayoutRule?.direction ?? 'TB',
+      ...(autoLayoutRule?.nodeSep && { nodeSep: autoLayoutRule.nodeSep }),
+      ...(autoLayoutRule?.rankSep && { rankSep: autoLayoutRule.rankSep }),
+    },
+    edges: sorted.edges,
+    nodes: map(nodes, n => {
+      // omit notation
+      delete n.notation
+      if (n.icon === 'none') {
+        delete n.icon
+      }
+      return n
+    }),
+    ...(elementNotations.length > 0 && {
+      notation: {
+        elements: elementNotations,
+      },
+    }),
+  })
+}

package/src/compute-view/deployment-view/memory/index.ts

@@ -0,0 +1,9 @@
+import type { StageExclude } from '../stages/stage-exclude'
+import type { StageInclude } from '../stages/stage-include'
+
+export { StageExclude } from '../stages/stage-exclude'
+export { StageInclude } from '../stages/stage-include'
+export { Memory } from './memory'
+export type { Ctx } from './memory'
+
+export type Stage = StageInclude | StageExclude

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

@@ -0,0 +1,97 @@
+import { isDeepEqual } from 'remeda'
+import { type DeploymentConnectionModel, differenceConnections } from '../../../model/connection'
+import type { DeploymentElementModel } from '../../../model/DeploymentElementModel'
+import type { AnyAux } from '../../../model/types'
+import type { ExpressionV2 } from '../../../types'
+import { difference as differenceSet } from '../../../utils'
+import { customInspectSymbol } from '../../../utils/const'
+import { toArray } from '../../../utils/iterable'
+import { AbstractMemory, type ComputeCtx, type StageExpression } from '../../memory'
+import { StageExclude } from '../stages/stage-exclude'
+import { StageInclude } from '../stages/stage-include'
+
+export type Ctx = ComputeCtx<
+  DeploymentElementModel<AnyAux>,
+  DeploymentConnectionModel<AnyAux>,
+  Memory,
+  StageInclude,
+  StageExclude,
+  ExpressionV2
+>
+
+export class Memory extends AbstractMemory<Ctx> {
+  static empty(): Memory {
+    return new Memory({
+      elements: new Set(),
+      explicits: new Set(),
+      final: new Set(),
+      connections: [],
+    })
+  }
+
+  override stageInclude(expr: StageExpression<Ctx>): StageInclude {
+    return new StageInclude(this, expr)
+  }
+  override stageExclude(expr: StageExpression<Ctx>): StageExclude {
+    return new StageExclude(this, expr)
+  }
+
+  override mutableState(): Ctx['MutableState'] {
+    return ({
+      elements: new Set(this.state.elements),
+      explicits: new Set(this.state.explicits),
+      final: new Set(this.state.final),
+      connections: [...this.state.connections],
+    })
+  }
+
+  override update(newstate: Partial<Ctx['MutableState']>): Memory {
+    return new Memory({
+      ...this.state,
+      ...newstate,
+    })
+  }
+
+  equals(other: unknown): boolean {
+    return other instanceof Memory && isDeepEqual(this.state, other.state)
+  }
+
+  diff(state: Memory) {
+    const current = this
+    return {
+      added: {
+        elements: toArray(differenceSet(state.elements, current.elements)),
+        explicits: toArray(differenceSet(state.explicits, current.explicits)),
+        final: toArray(differenceSet(state.final, current.final)),
+        connections: toArray(differenceConnections(state.connections, current.connections)),
+      },
+      removed: {
+        elements: toArray(differenceSet(current.elements, state.elements)),
+        explicits: toArray(differenceSet(current.explicits, state.explicits)),
+        final: toArray(differenceSet(current.final, state.final)),
+        connections: differenceConnections(current.connections, state.connections),
+      },
+    }
+  }
+
+  public override toString(): string {
+    return [
+      'final:',
+      ...[...this.final].map(e => '  ' + e.id),
+      'connections:',
+      ...this.connections.map(c => '  ' + c.expression),
+    ].join('\n')
+  }
+
+  [customInspectSymbol](_depth: unknown, _inspectOptions: unknown, _inspect: unknown) {
+    const asString = this.toString()
+
+    // // Trick so that node displays the name of the constructor
+    // Object.defineProperty(asString, 'constructor', {
+    //   value: this.constructor,
+    //   enumerable: false,
+    // })
+
+    return asString
+  }
+}

package/src/compute-view/deployment-view/predicates/elements.ts

@@ -0,0 +1,144 @@
+import { pipe, reduce } from 'remeda'
+import { isDeployedInstance } from '../../../model'
+import { findConnectionsBetween, findConnectionsWithin } from '../../../model/connection/deployment'
+import type { DeploymentElementModel, DeploymentNodeModel } from '../../../model/DeploymentElementModel'
+import type { FqnExpr } from '../../../types'
+import type { Elem, IncludePredicateCtx, PredicateExecutor } from '../_types'
+import { cleanCrossBoundary, cleanRedundantRelationships } from '../clean-connections'
+import type { StageInclude } from '../memory'
+import { deploymentExpressionToPredicate } from '../utils'
+
+export const DeploymentRefPredicate: PredicateExecutor<FqnExpr.DeploymentRef> = {
+  include: (ctx) => {
+    const { expr } = ctx
+    const el = ctx.model.element(expr.ref.deployment)
+
+    if (isDeployedInstance(el)) {
+      ctx.stage.addExplicit(el)
+      ctx.stage.connectWithExisting(el)
+      return ctx.stage
+    }
+
+    switch (true) {
+      case expr.selector === 'expanded':
+        includeDeployedNodeWithExpanded(el, ctx)
+        break
+      case expr.selector === 'children':
+        includeDeployedNodeChildren(el, ctx)
+        break
+      case expr.selector === 'descendants':
+        includeDeployedNodeDescendants(el, ctx)
+        break
+      default: {
+        ctx.stage.addExplicit(el)
+        ctx.stage.connectWithExisting(el)
+      }
+    }
+    return ctx.stage
+  },
+
+  exclude: ({ expr, stage, memory }) => {
+    const exprPredicate = deploymentExpressionToPredicate(expr)
+    stage.exclude([...memory.elements].filter(exprPredicate))
+    return stage
+  },
+}
+
+/**
+ * include node.*
+ */
+function includeDeployedNodeChildren(
+  node: DeploymentNodeModel,
+  { stage }: IncludePredicateCtx,
+) {
+  const children = [...node.children()]
+  if (children.length === 0) {
+    return
+  }
+  stage.addImplicit(node)
+
+  stage.addConnections(findConnectionsWithin(children))
+  stage.connectWithExisting(children)
+
+  stage.addExplicit(children)
+}
+
+/**
+ * include node._
+ */
+function includeDeployedNodeWithExpanded(
+  node: DeploymentNodeModel,
+  { memory, stage }: IncludePredicateCtx,
+) {
+  const children = [...node.children()]
+  stage.addImplicit(node)
+  stage.connectWithExisting(node)
+
+  let hasConnectionsWithVisible = false
+  for (const child of children) {
+    if (findConnectionsBetween(child, memory.elements).length > 0) {
+      hasConnectionsWithVisible = true
+      break
+    }
+  }
+
+  if (hasConnectionsWithVisible) {
+    stage.connectWithExisting(children, 'in')
+    stage.addConnections(findConnectionsWithin(children))
+    stage.connectWithExisting(children, 'out')
+  }
+  stage.addImplicit(children)
+
+  if (stage.connections.length > 0) {
+    stage.addExplicit(node)
+  }
+}
+
+/**
+ * include node.**
+ */
+function includeDeployedNodeDescendants(
+  node: DeploymentNodeModel,
+  { stage }: IncludePredicateCtx,
+) {
+  const dfs = (node: DeploymentNodeModel): DeploymentElementModel[] => {
+    const children = [] as DeploymentElementModel[]
+    for (const child of node.children()) {
+      if (child.isDeploymentNode()) {
+        children.push(...dfs(child))
+      }
+      children.push(child)
+    }
+    stage.connectWithExisting(children, 'in')
+    stage.addConnections(findConnectionsWithin(children))
+    stage.addImplicit(children)
+    return children
+  }
+
+  const descendants = dfs(node)
+  if (descendants.length === 0) {
+    return
+  }
+  stage.connectWithExisting(descendants, 'out')
+  // stage.addImplicit(descendants)
+
+  const allconnected = findConnectedElements(stage)
+  descendants.forEach((desc) => {
+    if (allconnected.has(desc)) {
+      stage.addExplicit(desc)
+    }
+  })
+}
+
+function findConnectedElements(stage: StageInclude) {
+  return pipe(
+    stage.mergedConnections(),
+    cleanCrossBoundary,
+    cleanRedundantRelationships,
+    reduce((acc, c) => {
+      acc.add(c.source)
+      acc.add(c.target)
+      return acc
+    }, new Set<Elem>()),
+  )
+}