@likec4/core 1.17.1 → 1.19.0

package/src/compute-view/element-view/memory/stage-final.ts

@@ -0,0 +1,129 @@
+import { forEach, only, pipe } from 'remeda'
+import { isAncestor, sortByFqnHierarchically } from '../../../utils/fqn'
+import { isome, toArray } from '../../../utils/iterable'
+import { difference, union } from '../../../utils/set'
+import { treeFromMemoryState } from '../../memory/ops'
+import type { Elem } from '../_types'
+import { findRedundantConnections } from '../clean-connections'
+import type { Ctx, Memory } from './memory'
+
+/**
+ * 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 connectionsToExclude = findRedundantConnections(memory.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)
+
+    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),
+      toArray(),
+      sortByFqnHierarchically,
+      forEach((el) => {
+        // if (memory.scope && !memory.scope.isAncestorOf(el)) {
+        //   return
+        // }
+        // 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 && conn.boundary !== conn.source && conn.boundary !== conn.target) {
+        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
+  }
+
+  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/element-view/memory/stage-include.ts

@@ -0,0 +1,128 @@
+import { dropWhile, forEach, pipe, take, zip } from 'remeda'
+import { Expr } from '../../..'
+import { findConnection, findConnectionsBetween } from '../../../model/connection/model'
+import { difference, isAncestor, isIterable } from '../../../utils'
+import { toArray } from '../../../utils/iterable'
+import { type CtxConnection, type StageExpression, AbstractStageInclude } from '../../memory'
+import { type ActiveGroupCtx, type ActiveGroupMemory, type Ctx } from './memory'
+
+export type Elem = Ctx['Element']
+
+export class StageInclude<C extends Ctx = Ctx> extends AbstractStageInclude<C> {
+  /**
+   * 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 addImplicitWithinScope(element: Elem | undefined | null) {
+    if (!element) {
+      return
+    }
+    if (!this.memory.scope || isAncestor(this.memory.scope, element)) {
+      this.addImplicit(element)
+    }
+  }
+
+  protected override processConnections(connections: CtxConnection<Ctx>[]) {
+    if (Expr.isRelationPredicateExpr(this.expression)) {
+      return connections
+    }
+
+    pipe(
+      connections,
+      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 (sourceAncestor === source && targetAncestor === target) {
+              this.addImplicitWithinScope(boundary)
+              return
+            }
+            if (sourceAncestor !== source) {
+              this.addImplicitWithinScope(sourceAncestor)
+            }
+            if (targetAncestor !== target) {
+              this.addImplicitWithinScope(targetAncestor)
+            }
+          }),
+        )
+      }),
+    )
+    return connections
+  }
+
+  protected override postcommit(state: ActiveGroupCtx['MutableState']) {
+    const newExplicits = difference(state.explicits, this.memory.explicits)
+    for (const explicit of newExplicits) {
+      state.explicitFirstSeenIn.set(explicit, '@root' as any)
+    }
+
+    return state
+  }
+}
+
+export class ActiveGroupStageInclude extends StageInclude<ActiveGroupCtx> {
+  constructor(
+    public override readonly memory: ActiveGroupMemory,
+    public override readonly expression: StageExpression<ActiveGroupCtx>,
+  ) {
+    super(memory, expression)
+  }
+
+  protected override postcommit(state: ActiveGroupCtx['MutableState']) {
+    const newExplicits = difference(state.explicits, this.memory.explicits)
+    for (const explicit of newExplicits) {
+      state.explicitFirstSeenIn.set(explicit, this.memory.activeGroupId)
+    }
+
+    for (const implicit of [...this.explicits, ...this.implicits]) {
+      state.lastSeenIn.set(implicit, this.memory.activeGroupId)
+    }
+
+    return state
+  }
+}

package/src/compute-view/element-view/predicates/_utils.ts

@@ -0,0 +1,86 @@
+import { anyPass } from 'remeda'
+import { nonexhaustive } from '../../../errors'
+import type { LikeC4Model } from '../../../model'
+import * as Expr from '../../../types/expression'
+import { isDescendantOf } from '../../../utils/fqn'
+import { ifilter, toArray } from '../../../utils/iterable'
+import type { Elem, Memory, PredicateCtx } from '../_types'
+
+/**
+ * Resolve elements from the model based on the given expression
+ */
+
+export function resolveElements(model: LikeC4Model, expr: Exclude<Expr.ElementExpression, Expr.WildcardExpr>): Elem[] {
+  switch (true) {
+    case Expr.isExpandedElementExpr(expr): {
+      const element = model.element(expr.expanded)
+      return [
+        element,
+        ...element.children(),
+      ]
+    }
+    case Expr.isElementRef(expr): {
+      const element = model.element(expr.element)
+      let children
+      if (expr.isChildren) {
+        children = toArray(element.children())
+      } else if (expr.isDescendants) {
+        children = toArray(element.descendants())
+      }
+      return children && children.length > 0 ? children : [element]
+    }
+    case Expr.isElementKindExpr(expr):
+      return [...ifilter(model.elements(), el => {
+        return expr.isEqual === (el.kind === expr.elementKind)
+      })]
+    case Expr.isElementTagExpr(expr):
+      return [...ifilter(model.elements(), el => {
+        return expr.isEqual === el.tags.includes(expr.elementTag)
+      })]
+    default:
+      nonexhaustive(expr)
+  }
+}
+
+/**
+ * Include elements that are not in the given set but are descendants of the current set
+ * Consider the following example:
+ *    a1.* -> b1
+ * If there are a1.a2.a3 and b1.b2 in the memory, but not connected yet - we connect them
+ */
+export function includeDescendantsFromMemory(elements: Elem[], memory: Memory): Elem[] {
+  if (memory.isEmpty() || elements.length === 0) {
+    return elements
+  }
+  const descedantsOf = anyPass(elements.map(e => isDescendantOf(e)))
+  const fromMemory = toArray(
+    ifilter(
+      memory.elements,
+      el => !elements.includes(el) && descedantsOf(el),
+    ),
+  )
+  return [
+    ...elements,
+    ...fromMemory,
+  ]
+}
+
+/**
+ * Combination of `resolveElements` and `includeDescendantsFromMemory`
+ */
+export function resolveAndIncludeFromMemory(
+  nonWildcard: Expr.NonWilcard,
+  { memory, model }: Pick<PredicateCtx, 'model' | 'memory'>,
+): Elem[] {
+  const resolved = resolveElements(model, nonWildcard)
+  // We include from memory only if the expression is:
+  // - expanded element
+  // - element reference with or with children (but not descendants - they are already included)
+  if (Expr.isExpandedElementExpr(nonWildcard) || Expr.isElementRef(nonWildcard)) {
+    if (nonWildcard.isDescendants === true) {
+      return resolved
+    }
+    return includeDescendantsFromMemory(resolved, memory)
+  }
+  return resolved
+}

package/src/compute-view/element-view/predicates/element-expand.ts

@@ -0,0 +1,33 @@
+import { findConnectionsWithin } from '../../../model/connection/model'
+import type * as Expr from '../../../types/expression'
+import type { Elem, PredicateExecutor } from '../_types'
+
+export const ExpandedElementPredicate: PredicateExecutor<Expr.ExpandedElementExpr> = {
+  include: ({ expr, model, stage, where }) => {
+    const parent = model.element(expr.expanded)
+    if (where(parent)) {
+      stage.addExplicit(parent)
+      stage.connectWithExisting(parent)
+    }
+
+    const children = [...parent.children()].filter(where)
+    const expanded = [] as Elem[]
+    for (const child of children) {
+      stage.addImplicit(child)
+      if (stage.connectWithExisting(child)) {
+        expanded.push(child)
+      }
+    }
+    stage.addConnections(findConnectionsWithin(expanded))
+    return stage
+  },
+  exclude: ({ expr, model, stage, where }) => {
+    const parent = model.element(expr.expanded)
+    const elements = [
+      parent,
+      ...parent.children()
+    ].filter(where)
+    stage.exclude(elements)
+    return stage
+  }
+}

package/src/compute-view/element-view/predicates/element-kind-tag.ts

@@ -0,0 +1,26 @@
+import { findConnectionsWithin } from '../../../model/connection/model'
+import * as Expr from '../../../types/expression'
+import type { PredicateExecutor } from '../_types'
+import { resolveElements } from './_utils'
+
+export const ElementKindOrTagPredicate: PredicateExecutor<Expr.ElementKindExpr | Expr.ElementTagExpr> = {
+  include: ({ expr, model, stage, filterWhere }) => {
+    const elements = filterWhere(resolveElements(model, expr))
+    if (elements.length === 0) {
+      return
+    }
+
+    stage.addExplicit(elements)
+    stage.connectWithExisting(elements)
+    stage.addConnections(findConnectionsWithin(elements))
+
+    return stage
+  },
+
+  exclude: ({ expr, model, stage, filterWhere }) => {
+    const elements = filterWhere(resolveElements(model, expr))
+    stage.exclude(elements)
+
+    return stage
+  }
+}

package/src/compute-view/element-view/predicates/element-ref.ts

@@ -0,0 +1,37 @@
+import { findConnectionsWithin } from '../../../model/connection/model'
+import type { ElementRefExpr } from '../../../types/expression'
+import * as Expr from '../../../types/expression'
+import type { Elem, PredicateExecutor } from '../_types'
+
+function applyElementSelector(elem: Elem, expr: Expr.ElementRefExpr) {
+  let children
+  if (expr.isChildren) {
+    children = [...elem.children()]
+  } else if (expr.isDescendants) {
+    children = [...elem.descendants()]
+  }
+  return children && children.length > 0 ? children : [elem]
+}
+
+export const ElementRefPredicate: PredicateExecutor<ElementRefExpr> = {
+  include: ({ expr, model, stage, where }) => {
+    const element = model.element(expr.element)
+    const elements = applyElementSelector(element, expr).filter(where)
+    if (elements.length === 0) {
+      return
+    }
+
+    stage.addExplicit(elements)
+    stage.connectWithExisting(elements)
+    stage.addConnections(findConnectionsWithin(elements))
+
+    return stage
+  },
+  exclude: ({ expr, model, stage, filterWhere }) => {
+    const element = model.element(expr.element)
+    const elements = filterWhere(applyElementSelector(element, expr))
+    stage.exclude(elements)
+
+    return stage
+  }
+}