@likec4/core 1.18.0 → 1.19.0

package/src/compute-view/deployment-view/predicates/relation-outgoing.ts

@@ -1,18 +1,21 @@
-import { identity } from 'remeda'
+import { anyPass } from 'remeda'
+import { invariant } from '../../../errors'
+import type { LikeC4DeploymentModel } from '../../../model'
 import { findConnection, findConnectionsBetween } from '../../../model/connection/deployment'
-import type { DeploymentConnectionModel } from '../../../model/connection/deployment'
-import { DeploymentElementExpression, type DeploymentRelationExpression } from '../../../types/deployments'
-import type { PredicateExecutor } from '../_types'
-import { deploymentExpressionToPredicate, resolveElements } from '../utils'
-import { resolveAscendingSiblings } from './relation-direct'
+import type { RelationshipModel } from '../../../model/RelationModel'
+import { FqnExpr, type RelationExpr } from '../../../types'
+import { isAncestor } from '../../../utils'
+import type { Connection, Elem, PredicateExecutor } from '../_types'
+import { resolveElements, resolveModelElements } from '../utils'
+import { excludeModelRelations, resolveAscendingSiblings } from './relation-direct'
 
-export const OutgoingRelationPredicate: PredicateExecutor<DeploymentRelationExpression.Outgoing> = {
-  include: (expr, { model, memory, stage }) => {
+export const OutgoingRelationPredicate: PredicateExecutor<RelationExpr.Outgoing> = {
+  include: ({ expr, model, memory, stage }) => {
     const targets = [...memory.elements]
 
     // * -> (to visible elements)
     // outgoing from wildcard to visible element
-    if (DeploymentElementExpression.isWildcard(expr.outgoing)) {
+    if (FqnExpr.isWildcard(expr.outgoing)) {
       for (const target of targets) {
         if (target.allIncoming.isEmpty) {
           continue
@@ -21,29 +24,65 @@ export const OutgoingRelationPredicate: PredicateExecutor<DeploymentRelationExpr
           stage.addConnections(findConnection(source, target, 'directed'))
         }
       }
-      return stage.patch()
+      return stage
     }
+    invariant(FqnExpr.isDeploymentRef(expr.outgoing), 'Only deployment refs are supported in include')
 
     const sources = resolveElements(model, expr.outgoing)
     for (const source of sources) {
       stage.addConnections(findConnectionsBetween(source, targets, 'directed'))
     }
 
-    return stage.patch()
+    return stage
   },
-  exclude: (expr, { memory, stage }) => {
-    const isSource = deploymentExpressionToPredicate(expr.outgoing)
-
-    const satisfies = (connection: DeploymentConnectionModel) => {
-      return isSource(connection.source)
+  exclude: ({ expr, model, memory, stage }) => {
+    // Exclude all connections that have model relationshps with the elements
+    if (FqnExpr.isModelRef(expr.outgoing)) {
+      const excludedRelations = resolveAllOutgoingRelations(model, expr.outgoing)
+      return excludeModelRelations(excludedRelations, { stage, memory })
     }
-
-    const toExclude = memory.connections.filter(satisfies)
-    if (toExclude.length === 0) {
-      return identity()
+    if (FqnExpr.isWildcard(expr.outgoing)) {
+      // non-sense
+      return stage
     }
 
+    const isOutgoing = filterOutgoingConnections(resolveElements(model, expr.outgoing))
+    const toExclude = memory.connections.filter(isOutgoing)
     stage.excludeConnections(toExclude)
-    return stage.patch()
-  }
+    return stage
+  },
+}
+
+export function filterOutgoingConnections(
+  sources: Elem[],
+): (connection: Connection) => boolean {
+  return anyPass(
+    sources.map(source => {
+      const satisfies = (el: Elem) => el === source || isAncestor(source, el)
+      return (connection: Connection) => {
+        return satisfies(connection.source) && !satisfies(connection.target)
+      }
+    }),
+  )
+  // if (FqnExpr.isDeploymentRef(expr) && isNullish(expr.selector)) {
+  //   // element ->
+  //   const source = model.element(expr.ref.deployment)
+  //   const isInside = (el: Elem) => el === source || isAncestor(source, el)
+  //   return (connection: Connection) => {
+  //     return isInside(connection.source) && !isInside(connection.target)
+  //   }
+  // } else {
+  //   const isSource = deploymentExpressionToPredicate(expr)
+  //   return (connection: Connection) => {
+  //     return isSource(connection.source)
+  //   }
+  // }
+}
+
+export function resolveAllOutgoingRelations(
+  model: LikeC4DeploymentModel,
+  moodelRef: FqnExpr.ModelRef,
+): Set<RelationshipModel> {
+  const targets = resolveModelElements(model, moodelRef)
+  return new Set(targets.flatMap(e => [...e.allOutgoing]))
 }

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

@@ -1,29 +1,29 @@
 import { findConnectionsWithin } from '../../../model/connection/deployment'
-import type { DeploymentElementExpression } from '../../../types/deployments'
-import type { Elem, PredicateExecutor } from '../_types'
-import { MutableMemory } from '../Memory'
+import type { FqnExpr } from '../../../types'
+import { type Elem, type PredicateExecutor } from '../_types'
 
-export const WildcardPredicate: PredicateExecutor<DeploymentElementExpression.Wildcard> = {
-  include: (_, { model, stage }) => {
+export const WildcardPredicate: PredicateExecutor<FqnExpr.Wildcard> = {
+  include: ({ model, stage }) => {
     const children = [] as Elem[]
 
     const rootElements = [...model.roots()].map(root => {
-      const onlyOneInstance = root.onlyOneInstance()
-      if (onlyOneInstance) {
-        children.push(onlyOneInstance)
-        return onlyOneInstance
+      if (!root.onlyOneInstance()) {
+        children.push(...root.children())
       }
-      children.push(...root.children())
       return root
     })
 
     stage.addExplicit(rootElements)
     if (children.length > 1) {
-      stage.addConnections(findConnectionsWithin(children))
+      stage.addConnections(findConnectionsWithin([
+        ...rootElements,
+        ...children,
+      ]))
     }
-    return stage.patch()
+    return stage
+  },
+  exclude: ({ stage, memory }) => {
+    stage.exclude(memory.elements)
+    return stage
   },
-  exclude: () => {
-    return () => MutableMemory.empty()
-  }
 }

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

@@ -0,0 +1,5 @@
+import { AbstractStageExclude } from '../../memory'
+import { type Ctx } from '../memory/memory'
+
+export class StageExclude extends AbstractStageExclude<Ctx> {
+}

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
+  }
+}