@likec4/core 1.17.1 → 1.19.0

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

@@ -0,0 +1,113 @@
+import { allPass, anyPass, pipe, prop, reduce } from 'remeda'
+import { Connection, ConnectionModel } from '../../model/connection'
+import {
+  differenceConnections,
+  findDeepestNestedConnection,
+  findDescendantConnections,
+  isAnyInOut,
+  isIncoming,
+  isOutgoing,
+  mergeConnections,
+} from '../../model/connection/ops'
+import type { RelationshipModel } from '../../model/RelationModel'
+import { intersection, union } from '../../utils'
+import { ifilter, toSet } from '../../utils/iterable'
+
+export function allRelationshipsFrom(connections: Iterable<ConnectionModel>): Set<RelationshipModel> {
+  const relations = new Set<RelationshipModel>()
+  for (const c of connections) {
+    for (const rel of c.relations) {
+      relations.add(rel)
+    }
+  }
+  return relations
+}
+
+function isInOutToDescendant(id: string): (c: ConnectionModel) => boolean {
+  return anyPass([
+    allPass([
+      Connection.isOutgoing(id),
+      c => c.source.id !== id,
+    ]),
+    allPass([
+      Connection.isIncoming(id),
+      c => c.target.id !== id,
+    ]),
+  ])
+}
+
+export function findRedundantConnections(connections: Iterable<ConnectionModel>): Array<ConnectionModel> {
+  return pipe(
+    [...connections],
+    mergeConnections,
+    reduce((reducedConnections, connection, _, all) => {
+      const descendants = findDescendantConnections(all, connection)
+      const nestedRelations = union(
+        ...descendants.map(prop('relations')),
+      )
+
+      let accum = intersection(connection.relations, nestedRelations)
+
+      if (descendants.length > 0) {
+        accum = union(accum, connection.directRelations)
+      }
+      // Check if there is any reversed connection to descendant
+      if (findDeepestNestedConnection(all, connection.reversed(false))) {
+        accum = union(accum, connection.directRelations)
+      }
+
+      if (accum.size < connection.relations.size) {
+        const isSourceExpanded = all.some(isAnyInOut(connection.source))
+        const isTargetExpanded = all.some(isAnyInOut(connection.target))
+
+        // Check if source expandaded
+        if (isSourceExpanded) {
+          accum = union(
+            accum,
+            toSet(
+              ifilter(
+                connection.relations,
+                isOutgoing(connection.source),
+              ),
+            ),
+          )
+        }
+
+        // Check if target expandaded
+        if (isTargetExpanded) {
+          accum = union(
+            accum,
+            toSet(
+              ifilter(
+                connection.relations,
+                isIncoming(connection.target),
+              ),
+            ),
+          )
+        }
+      }
+
+      if (accum.size > 0) {
+        reducedConnections.push(connection.update(accum))
+      }
+
+      return reducedConnections
+    }, [] as ConnectionModel[]),
+  )
+}
+
+/**
+ * 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: Iterable<ConnectionModel>,
+): Array<ConnectionModel> {
+  return differenceConnections(
+    connections,
+    findRedundantConnections(connections),
+  )
+}

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

@@ -0,0 +1,315 @@
+import DefaultMap from 'mnemonist/default-map'
+import { filter, findLast, forEach, map, pipe } from 'remeda'
+import { invariant, nonexhaustive, nonNullable } from '../../errors'
+import { type ElementModel, LikeC4Model } from '../../model'
+import { ConnectionModel } from '../../model/connection/model/ConnectionModel'
+import type { RelationshipModel } from '../../model/RelationModel'
+import type { AnyAux } from '../../model/types'
+import type {
+  ComputedElementView,
+  ElementPredicateExpression,
+  ElementView,
+  NodeId,
+  RelationPredicateExpression,
+  ViewRule,
+} from '../../types'
+import { isViewRuleAutoLayout, isViewRuleGroup, isViewRulePredicate, whereOperatorAsPredicate } from '../../types'
+import * as Expr from '../../types/expression'
+import { sortNaturalByFqn, sortParentsFirst } from '../../utils'
+import { applyCustomElementProperties } from '../utils/applyCustomElementProperties'
+import { applyCustomRelationProperties } from '../utils/applyCustomRelationProperties'
+import { applyViewRuleStyles } from '../utils/applyViewRuleStyles'
+import { buildElementNotations } from '../utils/buildElementNotations'
+import { linkNodesWithEdges } from '../utils/link-nodes-with-edges'
+import { resolveGlobalRulesInElementView } from '../utils/resolve-global-rules'
+import { topologicalSort } from '../utils/topological-sort'
+import { calcViewLayoutHash } from '../utils/view-hash'
+import { type Connection, type Elem, type PredicateCtx } from './_types'
+import { type NodesGroup, type Stage, Memory } from './memory'
+import { ActiveGroupMemory } from './memory/memory'
+import { StageFinal } from './memory/stage-final'
+import { ExpandedElementPredicate } from './predicates/element-expand'
+import { ElementKindOrTagPredicate } from './predicates/element-kind-tag'
+import { ElementRefPredicate } from './predicates/element-ref'
+import { DirectRelationExprPredicate } from './predicates/relation-direct'
+import { IncomingExprPredicate } from './predicates/relation-in'
+import { InOutRelationPredicate } from './predicates/relation-in-out'
+import { OutgoingExprPredicate } from './predicates/relation-out'
+import { WildcardPredicate } from './predicates/wildcard'
+import { buildNodes, NoFilter, NoWhere, toComputedEdges } from './utils'
+
+function processElementPredicate(
+  // ...args:
+  //   | [expr: ElementPredicateExpression, op: 'include', IncludePredicateCtx<ElementPredicateExpression>]
+  //   | [expr: ElementPredicateExpression, op: 'exclude', ExcludePredicateCtx<ElementPredicateExpression>]
+  expr: ElementPredicateExpression,
+  op: 'include' | 'exclude',
+  ctx: Omit<PredicateCtx<RelationPredicateExpression>, 'expr'>,
+): Stage {
+  switch (true) {
+    case Expr.isCustomElement(expr): {
+      if (op === 'include') {
+        return processElementPredicate(expr.custom.expr, op, ctx)
+      }
+      return ctx.stage
+    }
+    case Expr.isElementWhere(expr): {
+      const where = whereOperatorAsPredicate(expr.where.condition)
+      const filterWhere = filter<Elem>(where)
+      return processElementPredicate(expr.where.expr, op, { ...ctx, where, filterWhere } as any)
+    }
+    case Expr.isExpandedElementExpr(expr): {
+      return ExpandedElementPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
+    }
+    case Expr.isElementRef(expr): {
+      return ElementRefPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
+    }
+    case Expr.isWildcard(expr):
+      return WildcardPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
+    case Expr.isElementKindExpr(expr):
+    case Expr.isElementTagExpr(expr):
+      return ElementKindOrTagPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
+    default:
+      nonexhaustive(expr)
+  }
+}
+function processRelationtPredicate(
+  expr: RelationPredicateExpression,
+  op: 'include' | 'exclude',
+  ctx: Omit<PredicateCtx<RelationPredicateExpression>, 'expr'>,
+): Stage {
+  switch (true) {
+    case Expr.isCustomRelationExpr(expr): {
+      if (op === 'include') {
+        return processRelationtPredicate(expr.customRelation.relation, op, ctx)
+      }
+      return ctx.stage
+    }
+    case Expr.isRelationWhere(expr): {
+      const where = whereOperatorAsPredicate(expr.where.condition)
+      const filterRelations = (relations: ReadonlySet<RelationshipModel>) => {
+        return new Set(filter([...relations], where))
+      }
+      const filterWhere = (connections: ReadonlyArray<Connection>) => {
+        return pipe(
+          connections,
+          map(c => new ConnectionModel(c.source, c.target, filterRelations(c.relations))),
+          filter(c => c.nonEmpty()),
+        )
+      }
+      return processRelationtPredicate(expr.where.expr, op, {
+        ...ctx,
+        where,
+        filterWhere,
+      })
+    }
+    case Expr.isInOut(expr): {
+      return InOutRelationPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
+    }
+    case Expr.isRelation(expr): {
+      return DirectRelationExprPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
+    }
+    case Expr.isOutgoing(expr): {
+      return OutgoingExprPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
+    }
+    case Expr.isIncoming(expr): {
+      return IncomingExprPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
+    }
+    default:
+      nonexhaustive(expr)
+  }
+}
+
+export function processPredicates<M extends AnyAux>(
+  model: LikeC4Model<M>,
+  memory: Memory,
+  rules: ViewRule[],
+): Memory {
+  const ctx = {
+    model,
+    scope: memory.scope,
+    where: NoWhere,
+    filterWhere: NoFilter,
+  }
+  for (const rule of rules) {
+    if (isViewRuleGroup(rule)) {
+      const groupMemory = ActiveGroupMemory.enter(memory, rule)
+      memory = processPredicates(model, groupMemory, rule.groupRules)
+      invariant(memory instanceof ActiveGroupMemory, 'processPredicates must return ActiveGroupMemory')
+      memory = memory.leave()
+      continue
+    }
+    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)
+        switch (true) {
+          case Expr.isElementPredicateExpr(expr):
+            stage = processElementPredicate(expr, op, {
+              ...ctx,
+              stage,
+              memory,
+            } as any) ?? stage
+            break
+          case Expr.isRelationPredicateExpr(expr):
+            stage = processRelationtPredicate(expr, op, {
+              ...ctx,
+              stage,
+              memory,
+            }) ?? stage
+            break
+          default:
+            nonexhaustive(expr)
+        }
+        memory = stage.commit()
+      }
+    }
+  }
+  return StageFinal.for(memory).commit()
+}
+
+export function computeElementView<M extends AnyAux>(
+  likec4model: LikeC4Model<M>,
+  {
+    docUri: _docUri, // exclude docUri
+    rules, // exclude rules
+    ...view
+  }: ElementView,
+): ComputedElementView<M['ViewId']> {
+  rules = resolveGlobalRulesInElementView(rules, likec4model.globals())
+  const scope = view.viewOf ? likec4model.element(view.viewOf) : null
+  let memory = processPredicates<M>(
+    likec4model,
+    Memory.empty(scope),
+    rules,
+  )
+  if (memory.isEmpty() && scope) {
+    memory = memory.update({
+      final: new Set([scope]),
+    })
+  }
+  memory = assignElementsToGroups(memory)
+
+  const nodesMap = buildNodes(memory)
+
+  const computedEdges = toComputedEdges(memory.connections)
+
+  linkNodesWithEdges(nodesMap, computedEdges)
+
+  const sorted = topologicalSort({
+    nodes: nodesMap,
+    edges: computedEdges,
+  })
+
+  const nodes = applyCustomElementProperties(
+    rules,
+    applyViewRuleStyles(
+      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: applyCustomRelationProperties(rules, nodes, 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,
+      },
+    }),
+  })
+}
+
+/**
+ * Clean up group.explicits and group.implicits
+ */
+function assignElementsToGroups(memory: Memory) {
+  if (memory.groups.length === 0) {
+    return memory
+  }
+  const groupAssignments = new DefaultMap<NodeId, Set<Elem>>(() => new Set())
+
+  const assignedTo = new Map<ElementModel, NodesGroup['id']>()
+
+  const isAncestorAssigned = (el: Elem) => {
+    for (const parent of el.ancestors()) {
+      const groupId = assignedTo.get(parent)
+      if (groupId) {
+        assignedTo.set(el, groupId)
+        groupAssignments.get(groupId).add(el)
+        return true
+      }
+    }
+    return false
+  }
+
+  const isDescendantAssigned = (el: Elem) => {
+    for (const descendant of el.descendants('asc')) {
+      const groupId = assignedTo.get(descendant)
+      if (groupId) {
+        assignedTo.set(el, groupId)
+        groupAssignments.get(groupId).add(el)
+        return true
+      }
+    }
+    return false
+  }
+
+  pipe(
+    sortParentsFirst([...memory.explicitFirstSeenIn.keys()]),
+    forEach((el) => {
+      if (!isAncestorAssigned(el)) {
+        const groupId = nonNullable(memory.explicitFirstSeenIn.get(el))
+        assignedTo.set(el, groupId)
+        groupAssignments.get(groupId).add(el)
+      }
+    }),
+  )
+
+  pipe(
+    sortParentsFirst([...memory.lastSeenIn.keys()]),
+    filter(el => !assignedTo.has(el)),
+    forEach((el) => {
+      if (isAncestorAssigned(el)) {
+        return
+      }
+      if (isDescendantAssigned(el)) {
+        return
+      }
+      const groupId = nonNullable(memory.lastSeenIn.get(el))
+      assignedTo.set(el, groupId)
+      groupAssignments.get(groupId).add(el)
+    }),
+  )
+
+  if (groupAssignments.size === 0) {
+    return memory
+  }
+
+  let groups = memory.groups.map(group => {
+    const explicits = groupAssignments.get(group.id)
+    if (!explicits) {
+      return group
+    }
+    return group.update(explicits)
+  })
+  return memory.update({ groups })
+}

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