@likec4/core 1.18.0 → 1.19.0

package/src/compute-view/element-view/memory/NodeGroup.ts

@@ -0,0 +1,31 @@
+import { ElementKind, type NodeId, type ViewRuleGroup } from '../../../types'
+import type { Elem } from '../_types'
+
+export class NodesGroup {
+  static readonly kind = ElementKind.Group
+
+  constructor(
+    public readonly id: NodeId,
+    public readonly viewRule: ViewRuleGroup,
+    public readonly parent: NodeId | null = null,
+    public readonly elements: ReadonlySet<Elem> = new Set<Elem>()
+  ) {
+  }
+
+  isEmpty() {
+    return this.elements.size === 0
+  }
+
+  update(elements: ReadonlySet<Elem>): NodesGroup {
+    return new NodesGroup(
+      this.id,
+      this.viewRule,
+      this.parent,
+      elements
+    )
+  }
+
+  clone() {
+    return new NodesGroup(this.id, this.viewRule, this.parent, new Set(this.elements))
+  }
+}

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

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

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

@@ -0,0 +1,177 @@
+import Stack from 'mnemonist/stack'
+import { nonNullable } from '../../../errors'
+import type { ConnectionModel } from '../../../model/connection'
+import type { ElementModel } from '../../../model/ElementModel'
+import type { Expression, NodeId, ViewRuleGroup } from '../../../types'
+import { AbstractMemory, type ComputeCtx, type CtxElement, type MutableState, type StageExpression } from '../../memory'
+import { NodesGroup } from './NodeGroup'
+import { ActiveGroupStageExclude, StageExclude } from './stage-exclude'
+import { ActiveGroupStageInclude, StageInclude } from './stage-include'
+
+export interface Ctx extends
+  ComputeCtx<
+    ElementModel,
+    ConnectionModel,
+    Memory<Ctx>,
+    StageInclude<Ctx>,
+    StageExclude,
+    Expression
+  >
+{
+  MutableState: {
+    elements: Set<ElementModel>
+    explicits: Set<ElementModel>
+    final: Set<ElementModel>
+    connections: ConnectionModel[]
+    groups: NodesGroup[]
+    /*
+     * The group where explict element was added first time
+     * May be a root group
+     */
+    explicitFirstSeenIn: Map<ElementModel, NodesGroup['id']>
+    /**
+     * The group where element (implicit or explicit) was last seen (added or updated)
+     * Exclude root group
+     */
+    lastSeenIn: Map<ElementModel, NodesGroup['id']>
+  }
+}
+
+export class Memory<C extends Ctx = Ctx> extends AbstractMemory<C> {
+  static empty(scope: CtxElement<Ctx> | null): Memory {
+    return new Memory({
+      elements: new Set(),
+      explicits: new Set(),
+      final: new Set(),
+      connections: [],
+      groups: [],
+      explicitFirstSeenIn: new Map(),
+      lastSeenIn: new Map(),
+    }, scope)
+  }
+
+  protected constructor(
+    protected override state: MutableState<C>,
+    public readonly scope: CtxElement<C> | null,
+  ) {
+    super(state)
+  }
+
+  public get groups(): ReadonlyArray<NodesGroup> {
+    return this.state.groups
+  }
+
+  public get explicitFirstSeenIn(): ReadonlyMap<ElementModel, NodesGroup['id']> {
+    return this.state.explicitFirstSeenIn
+  }
+
+  public get lastSeenIn(): ReadonlyMap<ElementModel, NodesGroup['id']> {
+    return this.state.lastSeenIn
+  }
+
+  override stageInclude(expr: StageExpression<Ctx>): StageInclude {
+    return new StageInclude(this, expr)
+  }
+  override stageExclude(expr: StageExpression<Ctx>): StageExclude {
+    return new StageExclude(this, expr)
+  }
+
+  override mutableState(): MutableState<C> {
+    return ({
+      elements: new Set(this.state.elements),
+      explicits: new Set(this.state.explicits),
+      final: new Set(this.state.final),
+      connections: [...this.state.connections],
+      groups: this.state.groups.map((g) => g.clone()),
+      explicitFirstSeenIn: new Map(this.state.explicitFirstSeenIn),
+      lastSeenIn: new Map(this.state.lastSeenIn),
+    })
+  }
+
+  override update(newstate: Partial<C['MutableState']>): Memory {
+    return new Memory({
+      ...this.state,
+      ...newstate,
+    }, this.scope)
+  }
+}
+
+type ActiveGroupState = Ctx['MutableState'] & {
+  // activeGroup: NodesGroup
+}
+
+export interface ActiveGroupCtx extends Ctx {
+  MutableState: ActiveGroupState
+}
+
+export class ActiveGroupMemory extends Memory<ActiveGroupCtx> {
+  static enter(
+    memory: Memory,
+    rule: ViewRuleGroup,
+  ): ActiveGroupMemory {
+    const groupId = `@gr${memory.groups.length + 1}` as NodeId
+    if (memory instanceof ActiveGroupMemory) {
+      const stack = Stack.from(memory.stack)
+      const state = memory.mutableState()
+      state.groups.push(new NodesGroup(groupId, rule, memory.activeGroupId))
+      stack.push(groupId)
+      return new ActiveGroupMemory(state, memory.scope, stack)
+    }
+    const state = memory.mutableState() as ActiveGroupState
+    state.groups.push(new NodesGroup(groupId, rule, null))
+    const stack = Stack.of(groupId)
+    return new ActiveGroupMemory(state, memory.scope, stack)
+  }
+
+  protected constructor(
+    protected override state: ActiveGroupState,
+    public override readonly scope: CtxElement<ActiveGroupCtx> | null,
+    // Stack of group ids
+    protected stack: Stack<NodeId>,
+  ) {
+    super(state, scope)
+  }
+
+  get activeGroupId(): NodeId {
+    return nonNullable(this.stack.peek(), 'Stack must not be empty')
+  }
+
+  override mutableState(): ActiveGroupState {
+    const state = super.mutableState()
+    return ({
+      ...state,
+      // activeGroup: this.findActiveGroup(state.groups)
+    })
+  }
+
+  // private findActiveGroup(groups: NodesGroup[]): NodesGroup {
+  //   return nonNullable(groups.find(g => g.id === this.activeGroup.id), 'Active group not found in groups')
+  // }
+
+  override update(newstate: Partial<ActiveGroupState>): ActiveGroupMemory {
+    const nextstate = {
+      ...this.state,
+      ...newstate,
+    }
+    // const activeGroup = this.findActiveGroup(nextstate.groups)
+    // invariant(Object.is(activeGroup, nextstate.activeGroup), 'Active group must strictly equal to the group in groups')
+    return new ActiveGroupMemory(nextstate, this.scope, this.stack)
+  }
+
+  override stageInclude(expr: StageExpression<Ctx>): ActiveGroupStageInclude {
+    return new ActiveGroupStageInclude(this, expr)
+  }
+  override stageExclude(expr: StageExpression<Ctx>): ActiveGroupStageExclude {
+    return new ActiveGroupStageExclude(this, expr)
+  }
+
+  public leave(): Memory {
+    const state = this.mutableState()
+    this.stack.pop()
+    const prevgroup = this.stack.peek()
+    if (prevgroup) {
+      return new ActiveGroupMemory(state, this.scope, this.stack)
+    }
+    return new Memory(state, this.scope)
+  }
+}

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

@@ -0,0 +1,59 @@
+import { filter, forEach, pipe } from 'remeda'
+import type { RelationshipModel } from '../../../model/RelationModel'
+import { difference, hasIntersection, intersection } from '../../../utils/set'
+import { AbstractStageExclude, type MutableState, type StageExpression } from '../../memory'
+import { type ActiveGroupCtx, type ActiveGroupMemory, type Ctx } from './memory'
+
+export class StageExclude<C extends Ctx = Ctx> extends AbstractStageExclude<C> {
+  public excludeRelations(excluded: ReadonlySet<RelationshipModel<any>>): this {
+    pipe(
+      this.memory.connections,
+      filter(c => hasIntersection(c.relations, excluded)),
+      forEach(c => {
+        this.excludeConnections(
+          c.update(intersection(c.relations, excluded)),
+        )
+      }),
+    )
+    return this
+  }
+
+  /**
+   * Precommit hook
+   */
+  protected override precommit(state: MutableState<C>): MutableState<C> {
+    if (this.excluded.elements.size > 0) {
+      const excludeRelationships = new Set(
+        [...this.excluded.elements].flatMap(el => [
+          ...el.incoming('direct'),
+          ...el.outgoing('direct'),
+        ]),
+      )
+      this.excludeRelations(excludeRelationships)
+    }
+    return state
+  }
+
+  protected override postcommit(state: C['MutableState']) {
+    const leftExplicits = difference(this.memory.explicits, state.explicits)
+    for (const explicit of leftExplicits) {
+      state.explicitFirstSeenIn.delete(explicit)
+    }
+
+    // Left elements
+    const left = difference(this.memory.elements, state.elements)
+    for (const el of left) {
+      state.lastSeenIn.delete(el)
+    }
+    return state
+  }
+}
+
+export class ActiveGroupStageExclude extends StageExclude {
+  constructor(
+    public override readonly memory: ActiveGroupMemory,
+    public override readonly expression: StageExpression<ActiveGroupCtx>,
+  ) {
+    super(memory, expression)
+  }
+}

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