@likec4/core 1.18.0 → 1.19.1

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

@@ -1,36 +1,49 @@
 import DefaultMap from 'mnemonist/default-map'
-import { dropWhile, filter, flatMap, forEach, forEachObj, groupBy, hasAtLeast, map, pipe, prop, sort } from 'remeda'
-import { mergeConnections } from '../../model/connection/deployment'
-import { DeploymentConnectionModel } from '../../model/connection/DeploymentConnectionModel'
+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 type { AnyAux } from '../../model/types'
-import { compareFqnHierarchically, isAncestor } from '../../utils'
-import { difference } from '../../utils/set'
-import type { Connections, Elem } from './_types'
-import { type Patch } from './Memory'
+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())
 
-// We add '.' to distinguish between connections with boundary and without
-// This way we can sort them hierarchically
-const connectionBoundary = (conn: DeploymentConnectionModel<any>) => conn.boundary?.id ? `.${conn.boundary.id}` : ''
-
-function cleanCrossBoundary<M extends AnyAux>(connections: Connections<M>): Connections<M> {
-  // Keep only connections between leafs
+type MapOfExcludesFromConnection = DefaultMap<DeploymentConnectionModel, Set<RelationshipModel>>
+function findCrossBoundarySameSourceOrTarget(connections: Connections): MapOfExcludesFromConnection {
   // Also find connections based on same relation
-  const groupedByRelation = new DefaultMap<RelationshipModel<M>, Array<DeploymentConnectionModel<M>>>(() => [])
+  const groupedByRelation = new DefaultMap<RelationshipModel, Array<DeploymentConnectionModel>>(() => [])
   for (const conn of connections) {
     for (const relation of conn.relations.model) {
       groupedByRelation.get(relation).push(conn)
     }
   }
 
-  // DeploymentConnectionModel is immutables
-  // So we create new instances without excluded relations
+  // Aggreate excluded relations for each connection
   const excludedRelations = new DefaultMap<
-    DeploymentConnectionModel<M>,
-    Set<RelationshipModel<M>>
+    DeploymentConnectionModel,
+    Set<RelationshipModel>
   >(() => new Set())
 
   // In each group, find connected to same leaf
@@ -44,186 +57,182 @@ function cleanCrossBoundary<M extends AnyAux>(connections: Connections<M>): Conn
       sameRelationGroup,
       flatMap(conn => [
         { group: `$source-${conn.source.id}`, conn },
-        { group: `$target-${conn.target.id}`, conn }
+        { group: `$target-${conn.target.id}`, conn },
       ]),
       groupBy(prop('group')),
-      forEachObj((connections) => {
-        if (connections.length < 2) {
-          return
-        }
-        pipe(
-          connections,
+      values(),
+      filter(hasAtLeast(2)),
+      forEach(
+        // In each group, sort by hierarchy, first are deepest
+        piped(
           map(prop('conn')),
-          // Sort by hierarchy, first are deepest
-          sort((a, b) => compareFqnHierarchically(connectionBoundary(a), connectionBoundary(b)) * -1),
-          // Skip connections until we reach another boundary
+          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),
-          // Clean relations from the rest
+          // 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,
-    map(conn => {
-      const excluded = excludedRelations.get(conn)
-      if (excluded && excluded.size > 0) {
-        const updated = new DeploymentConnectionModel(
-          conn.source,
-          conn.target,
-          new RelationshipsAccum(
-            difference(conn.relations.model, excluded),
-            conn.relations.deployment
-          )
-        )
-        return updated
-      }
-      return conn
-    }),
-    filterEmptyConnection
+    findCrossBoundaryConnections(connections),
   )
 }
 
 /**
- * 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.
+ * Identifies and returns redundant connections in a deployment view.
+ * A connection is considered redundant if its relationships are already implied
+ * through other connections
  *
- * @returns New connection without redundant relationships
- *          Connection may be empty if all relationships are redundant, in this case it should be removed
+ * @returns Array of redundant connections that can be safely removed
  */
-function excludeRedundantRelationships<M extends AnyAux>(
-  connections: Connections<M>
-): Array<DeploymentConnectionModel<M>> {
+export function findRedundantConnections(connections: Connections): Array<Connection> {
   return pipe(
     connections,
-    map(connection => {
-      const { source, target } = connection
+    mergeConnections,
+    reduce((redundants, connection) => {
+      const { source, target, relations } = connection
 
       // Connection between instances is always explicit
       if (source.isInstance() && target.isInstance()) {
-        return connection
+        return redundants
       }
 
-      let modelRelations = connection.relations.model
-      let deploymentRelations = connection.relations.deployment
+      let redundantAccum = RelationshipsAccum.empty()
 
-      for (const c of connections) {
-        if (
-          isAncestor(source.id, c.source.id) && isAncestor(target.id, c.target.id)
-          || isAncestor(source.id, c.source.id) && c.target.id === target.id
-          || isAncestor(target.id, c.target.id) && c.source.id === source.id
-        ) {
-          modelRelations = difference(modelRelations, c.relations.model)
-          deploymentRelations = difference(deploymentRelations, c.relations.deployment)
+      if (source.isDeploymentNode() && target.isDeploymentNode()) {
+        const [reversed] = findConnection(target, source, 'directed')
+        if (reversed) {
+          redundantAccum = relations.intersect(reversed.relations)
         }
       }
 
-      // if any set changed, return new connection
-      if (modelRelations !== connection.relations.model || deploymentRelations !== connection.relations.deployment) {
-        return new DeploymentConnectionModel(
-          source,
-          target,
-          new RelationshipsAccum(
-            modelRelations,
-            deploymentRelations
+      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 connection
-    }),
-    filterEmptyConnection
+      return redundants
+    }, [] as DeploymentConnectionModel[]),
   )
 }
+
 /**
- * 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
+ * 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 const cleanConnections: Patch = (memory) => {
-  if (memory.connections.length < 2) {
-    return memory
-  }
-
-  const leafs = new Set<Elem>()
-
-  for (const element of memory.elements) {
-    // 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.elements) {
-      if (isAncestor(element.id, el.id)) {
-        isLeaf = false
-        break
-      }
-    }
-    if (isLeaf) {
-      leafs.add(element)
-    }
-  }
-
-  const connectedElements = new Set<Elem>()
-
-  const connections = pipe(
-    memory.connections,
-    mergeConnections,
-    // Keep connections
-    // - between leafs
-    // - has direct deployment relation
-    filter(c => {
-      return (leafs.has(c.source) && leafs.has(c.target)) || c.hasDirectDeploymentRelation()
-    }),
-    cleanCrossBoundary,
-    excludeRedundantRelationships,
-    forEach((c) => {
-      connectedElements.add(c.source)
-      connectedElements.add(c.target)
-      if (c.boundary) {
-        connectedElements.add(c.boundary)
-      }
-    })
+export function cleanRedundantRelationships(
+  connections: Connections,
+): Array<Connection> {
+  return differenceConnections(
+    connections,
+    findRedundantConnections(connections),
   )
-
-  const isAncestorOfConnected = (el: Elem) => {
-    if (el.isInstance()) {
-      return false
-    }
-    for (const connected of connectedElements) {
-      if (isAncestor(el.id, connected.id)) {
-        return true
-      }
-    }
-    return false
-  }
-
-  // Update memory
-  const newMemory = memory.clone()
-  newMemory.connections = connections
-
-  // Iterate over elements (preserving order) and pick:
-  // - explicitly included
-  // - connected elements
-  // - ancestors of connected elements
-  const finalElements = new Set<Elem>()
-  for (const el of newMemory.finalElements) {
-    if (
-      newMemory.isExplicit(el)
-      || connectedElements.has(el)
-      || isAncestorOfConnected(el)
-    ) {
-      finalElements.add(el)
-    }
-  }
-  newMemory.finalElements = finalElements
-  return newMemory
 }

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

@@ -1,73 +1,73 @@
-import { findLast } from 'remeda'
+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,
-  DeploymentElementExpression,
-  DeploymentRelationExpression,
   type DeploymentView,
+  FqnExpr,
   isViewRuleAutoLayout,
-  isViewRulePredicate
+  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 { cleanConnections } from './clean-connections'
-import { MutableMemory, type Patch } from './Memory'
-import { DeploymentRefPredicate } from './predicates/deployment-ref'
+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 { Stage } from './Stage'
+import { StageFinal } from './stages/stage-final'
 import { applyDeploymentViewRuleStyles, buildNodes, toComputedEdges } from './utils'
 
-function processPredicates<M extends AnyAux>(
+export function processPredicates<M extends AnyAux>(
   model: LikeC4DeploymentModel<M>,
-  rules: DeploymentViewRule[]
+  rules: DeploymentViewRule[],
 ) {
-  let memory = MutableMemory.empty()
-  let stage: Stage | null = null
+  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) {
-        stage = new Stage(stage)
+        let stage = op === 'include' ? memory.stageInclude(expr) : memory.stageExclude(expr)
         const ctx = { model, stage, memory }
-        let patch: Patch | undefined
         switch (true) {
-          case DeploymentElementExpression.isRef(expr):
-            patch = DeploymentRefPredicate[op](expr, ctx)
+          case FqnExpr.isModelRef(expr):
+            // Ignore model refs in deployment view
             break
-          case DeploymentElementExpression.isWildcard(expr):
-            patch = WildcardPredicate[op](expr, ctx)
+          case FqnExpr.isDeploymentRef(expr):
+            stage = DeploymentRefPredicate[op]({ ...ctx, expr } as any) ?? stage
             break
-          case DeploymentRelationExpression.isDirect(expr):
-            patch = DirectRelationPredicate[op](expr, ctx)
+          case FqnExpr.isWildcard(expr):
+            stage = WildcardPredicate[op]({ ...ctx, expr } as any) ?? stage
             break
-          case DeploymentRelationExpression.isInOut(expr):
-            patch = InOutRelationPredicate[op](expr, ctx)
+          case RelationExpr.isDirect(expr):
+            stage = DirectRelationPredicate[op]({ ...ctx, expr } as any) ?? stage
             break
-          case DeploymentRelationExpression.isOutgoing(expr):
-            patch = OutgoingRelationPredicate[op](expr, ctx)
+          case RelationExpr.isInOut(expr):
+            stage = InOutRelationPredicate[op]({ ...ctx, expr } as any) ?? stage
             break
-          case DeploymentRelationExpression.isIncoming(expr):
-            patch = IncomingRelationPredicate[op](expr, ctx)
+          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)
         }
-        patch ??= stage.patch()
-        memory = patch(memory)
+        memory = stage.commit()
       }
     }
   }
-  return cleanConnections(memory)
+  return StageFinal.for(memory).commit()
 }
 
 export function computeDeploymentView<M extends AnyAux>(
@@ -76,9 +76,9 @@ export function computeDeploymentView<M extends AnyAux>(
     docUri: _docUri, // exclude docUri
     rules, // exclude rules
     ...view
-  }: DeploymentView
+  }: DeploymentView,
 ): ComputedDeploymentView<M['ViewId']> {
-  const memory = processPredicates<M>(likec4model.deployment, rules)
+  let memory = processPredicates<M>(likec4model.deployment, rules)
 
   const nodesMap = buildNodes(memory)
 
@@ -87,25 +87,39 @@ export function computeDeploymentView<M extends AnyAux>(
   linkNodesWithEdges(nodesMap, computedEdges)
 
   const sorted = topologicalSort({
-    nodes: [...nodesMap.values()],
-    edges: computedEdges
+    nodes: nodesMap,
+    edges: computedEdges,
   })
 
   const nodes = applyDeploymentViewRuleStyles(
     rules,
-    sorted.nodes
+    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 })
+      ...(autoLayoutRule?.rankSep && { rankSep: autoLayoutRule.rankSep }),
     },
-    nodes,
-    edges: sorted.edges
+    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
+  }
+}