@likec4/core 1.18.0 → 1.19.0

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

package/src/compute-view/element-view/predicates/relation-direct.ts

@@ -0,0 +1,309 @@
+import { concat, constant, flatMap, hasAtLeast, map, partition, pipe, piped, prop, when } from 'remeda'
+import { invariant } from '../../../errors'
+import { ConnectionModel, findConnectionsBetween, findConnectionsWithin } from '../../../model/connection/model'
+import type { RelationshipModel } from '../../../model/RelationModel'
+import type { AnyAux } from '../../../model/types'
+import * as Expr from '../../../types/expression'
+import { isSameHierarchy } from '../../../utils'
+import { ifilter, iflat, iunique, toArray, toSet } from '../../../utils/iterable'
+import { intersection, union } from '../../../utils/set'
+import type { Elem, PredicateCtx, PredicateExecutor } from '../_types'
+import { NoWhere } from '../utils'
+import { includeDescendantsFromMemory, resolveAndIncludeFromMemory, resolveElements } from './_utils'
+
+export const DirectRelationExprPredicate: PredicateExecutor<Expr.DirectRelationExpr> = {
+  include: ({ expr: { source, target, isBidirectional = false }, memory, model, stage, where, filterWhere }) => {
+    const sourceIsWildcard = Expr.isWildcard(source)
+    const targetIsWildcard = Expr.isWildcard(target)
+
+    const connections = [] as ConnectionModel<AnyAux>[]
+    switch (true) {
+      // This is a special case, we look for all relationships that satisfy the where clause
+      // * -> * ; Empty memory; Where clause
+      case sourceIsWildcard && targetIsWildcard && memory.isEmpty() && where !== NoWhere: {
+        const connections = pipe(
+          model.relationships(),
+          ifilter(where),
+          toArray(),
+          map(r => new ConnectionModel(r.source, r.target, new Set([r]))),
+        )
+        stage.addConnections(connections)
+        return stage
+      }
+
+      // This is a special case, we look for all relationships between elements that satisfy the where clause
+      // * -> *; Not empty memory; Where clause
+      case sourceIsWildcard && targetIsWildcard && !memory.isEmpty() && where !== NoWhere: {
+        connections.push(
+          ...findConnectionsWithin(memory.elements),
+        )
+        break
+      }
+
+      // * -> *
+      case sourceIsWildcard && targetIsWildcard: {
+        connections.push(
+          ...findConnectionsWithin(model.roots()),
+        )
+        break
+      }
+
+      // This is a special case, we look for all relationships that satisfy the where clause
+      // element -> *; Where clause
+      case !sourceIsWildcard && targetIsWildcard && where !== NoWhere: {
+        const sources = resolveElements(model, source)
+        const connections = pipe(
+          sources,
+          flatMap(source =>
+            pipe(
+              source,
+              when(constant(isBidirectional === true), {
+                onTrue: s => union(s.allIncoming, s.allOutgoing),
+                onFalse: s => s.allOutgoing,
+              }),
+              ifilter(where),
+              iunique(),
+              toArray(),
+              partition(r => r.source === source),
+              ([outgoing, incoming]) =>
+                concat(
+                  pipe(
+                    outgoing,
+                    map(outgoing =>
+                      new ConnectionModel(
+                        source,
+                        outgoing.target,
+                        new Set([outgoing]),
+                      )
+                    ),
+                  ),
+                  pipe(
+                    incoming,
+                    map(incoming =>
+                      new ConnectionModel(
+                        incoming.source,
+                        source,
+                        new Set([incoming]),
+                      )
+                    ),
+                  ),
+                ),
+            )
+          ),
+        )
+        stage.addConnections(connections)
+        return stage
+      }
+
+      // element -> *
+      case !sourceIsWildcard && targetIsWildcard: {
+        const [sources, targets] = resolveWildcard(source, { memory, model })
+        const dir = isBidirectional ? 'both' : 'directed'
+        for (const source of sources) {
+          connections.push(
+            ...findConnectionsBetween(source, targets, dir),
+          )
+        }
+        break
+      }
+
+      // This is a special case, we look for all relationships that satisfy the where clause
+      // * -> element; Where clause
+      case sourceIsWildcard && !targetIsWildcard && where !== NoWhere: {
+        const targets = resolveElements(model, target)
+        const connections = pipe(
+          targets,
+          flatMap(target =>
+            pipe(
+              target,
+              when(constant(isBidirectional === true), {
+                onTrue: s => union(s.allIncoming, s.allOutgoing),
+                onFalse: s => s.allIncoming,
+              }),
+              ifilter(where),
+              toArray(),
+              partition(r => r.target === target),
+              ([incoming, outgoing]) =>
+                concat(
+                  pipe(
+                    outgoing,
+                    map(outgoing =>
+                      new ConnectionModel(
+                        target,
+                        outgoing.target,
+                        new Set([outgoing]),
+                      )
+                    ),
+                  ),
+                  pipe(
+                    incoming,
+                    map(incoming =>
+                      new ConnectionModel(
+                        incoming.source,
+                        target,
+                        new Set([incoming]),
+                      )
+                    ),
+                  ),
+                ),
+            )
+          ),
+        )
+        stage.addConnections(connections)
+        return stage
+      }
+
+      // * -> element
+      case sourceIsWildcard && !targetIsWildcard: {
+        const [targets, sources] = resolveWildcard(target, { memory, model })
+        const dir = isBidirectional ? 'both' : 'directed'
+        for (const source of sources) {
+          connections.push(
+            ...findConnectionsBetween(source, targets, dir),
+          )
+        }
+        break
+      }
+
+      default: {
+        invariant(!Expr.isWildcard(source), 'Inference failed - source must be not a wildcard')
+        invariant(!Expr.isWildcard(target), 'Inference failed - target must be not a wildcard')
+        const sources = resolveAndIncludeFromMemory(source, { memory, model })
+        const targets = resolveAndIncludeFromMemory(target, { memory, model })
+        const dir = isBidirectional ? 'both' : 'directed'
+        for (const source of sources) {
+          connections.push(
+            ...findConnectionsBetween(source, targets, dir),
+          )
+        }
+      }
+    }
+
+    stage.addConnections(
+      filterWhere(connections),
+    )
+
+    return stage
+  },
+  exclude: ({ expr: { source, target, isBidirectional }, model, memory, stage, where }) => {
+    const sourceIsWildcard = Expr.isWildcard(source)
+    const targetIsWildcard = Expr.isWildcard(target)
+
+    let relations: Set<RelationshipModel<AnyAux>>
+
+    switch (true) {
+      // * -> *
+      case sourceIsWildcard && targetIsWildcard: {
+        relations = pipe(
+          memory.connections,
+          flatMap(piped(
+            prop('relations'),
+            ifilter(where),
+            toArray(),
+          )),
+          toSet(),
+        )
+        break
+      }
+
+      // element -> *
+      case !sourceIsWildcard && targetIsWildcard: {
+        const sources = resolveElements(model, source)
+        relations = pipe(
+          sources,
+          flatMap(source =>
+            pipe(
+              source,
+              when(constant(isBidirectional === true), {
+                onTrue: s => union(s.allIncoming, s.allOutgoing),
+                onFalse: s => s.allOutgoing,
+              }),
+              ifilter(where),
+              toArray(),
+            )
+          ),
+          toSet(),
+        )
+        break
+      }
+
+      // * -> element
+      case sourceIsWildcard && !targetIsWildcard: {
+        const targets = resolveElements(model, target)
+        relations = pipe(
+          targets,
+          flatMap(target =>
+            pipe(
+              target,
+              when(constant(isBidirectional === true), {
+                onTrue: s => union(s.allIncoming, s.allOutgoing),
+                onFalse: s => s.allIncoming,
+              }),
+              ifilter(where),
+              toArray(),
+            )
+          ),
+          toSet(),
+        )
+        break
+      }
+
+      default: {
+        invariant(!Expr.isWildcard(source), 'Inferrence failed - source must be not a wildcard')
+        invariant(!Expr.isWildcard(target), 'Inferrence failed - target must be not a wildcard')
+        const sources = resolveElements(model, source)
+        const targets = resolveElements(model, target)
+
+        let accum = new Set<RelationshipModel<AnyAux>>()
+        for (const source of sources) {
+          for (const target of targets) {
+            if (isSameHierarchy(source, target)) {
+              continue
+            }
+            accum = union(
+              accum,
+              intersection(source.allOutgoing, target.allIncoming),
+              isBidirectional ? intersection(target.allOutgoing, source.allIncoming) : new Set(),
+            )
+          }
+        }
+
+        relations = toSet(ifilter(accum, where))
+      }
+    }
+
+    stage.excludeRelations(relations)
+    return stage
+  },
+}
+
+/**
+ * Resolve elements for both source and target, when one of them is a wildcard
+ */
+function resolveWildcard(
+  nonWildcard: Expr.NonWilcard,
+  { memory, model }: Pick<PredicateCtx, 'model' | 'memory'>,
+): [elements: Elem[], wildcard: Elem[]] {
+  let sources = resolveElements(model, nonWildcard)
+  if (!hasAtLeast(sources, 1)) {
+    return [[], []]
+  }
+
+  if (Expr.isExpandedElementExpr(nonWildcard) || Expr.isElementRef(nonWildcard)) {
+    const parent = model.element(nonWildcard.element ?? nonWildcard.expanded)
+    const targets = toArray(parent.ascendingSiblings())
+    return [
+      includeDescendantsFromMemory(sources, memory),
+      includeDescendantsFromMemory(targets, memory),
+    ]
+  }
+  const targets = pipe(
+    sources,
+    map(el => el.ascendingSiblings()),
+    iflat(),
+    iunique(),
+    toArray(),
+    all => includeDescendantsFromMemory(all, memory),
+  )
+  return [sources, targets]
+}

package/src/compute-view/element-view/predicates/relation-in-out.ts

@@ -0,0 +1,66 @@
+import { unique } from 'remeda'
+import { type ConnectionModel, findConnectionsBetween } from '../../../model/connection/model'
+import type { RelationshipModel } from '../../../model/RelationModel'
+import type { AnyAux } from '../../../model/types'
+import * as Expr from '../../../types/expression'
+import { toArray } from '../../../utils/iterable'
+import { toSet } from '../../../utils/iterable/to'
+import type { PredicateExecutor } from '../_types'
+import { resolveAndIncludeFromMemory, resolveElements } from './_utils'
+
+export const InOutRelationPredicate: PredicateExecutor<Expr.InOutExpr> = {
+  include: ({ expr: { inout }, scope, model, memory, stage, filterWhere }) => {
+    const connections = [] as ConnectionModel<AnyAux>[]
+    if (Expr.isWildcard(inout)) {
+      if (!scope) {
+        return
+      }
+      connections.push(
+        ...findConnectionsBetween(
+          scope,
+          scope.ascendingSiblings(),
+        ),
+      )
+    } else {
+      const elements = resolveAndIncludeFromMemory(inout, { memory, model })
+      let visibleElements = [...memory.elements]
+      if (visibleElements.length === 0) {
+        visibleElements = unique(
+          elements.flatMap(el => toArray(el.ascendingSiblings())),
+        )
+      }
+      for (const el of elements) {
+        connections.push(
+          ...findConnectionsBetween(
+            el,
+            visibleElements,
+          ),
+        )
+      }
+    }
+
+    stage.addConnections(
+      filterWhere(connections),
+    )
+
+    return stage
+  },
+  exclude: ({ expr: { inout }, model, scope, stage, where }) => {
+    const excluded = [] as RelationshipModel[]
+    if (Expr.isWildcard(inout)) {
+      if (!scope) {
+        return
+      }
+      excluded.push(...scope.allOutgoing)
+      excluded.push(...scope.allIncoming)
+    } else {
+      const elements = resolveElements(model, inout)
+      excluded.push(
+        ...elements.flatMap(e => [...e.allOutgoing, ...e.allIncoming]),
+      )
+    }
+    stage.excludeRelations(toSet(excluded.filter(where)))
+
+    return stage
+  },
+}

package/src/compute-view/element-view/predicates/relation-in.ts

@@ -0,0 +1,118 @@
+import { anyPass, unique } from 'remeda'
+import { nonexhaustive } from '../../../errors'
+import type { LikeC4Model } from '../../../model'
+import {
+  Connection,
+  type ConnectionModel,
+  findConnection,
+  findConnectionsBetween
+} from '../../../model/connection/model'
+import type { RelationshipModel } from '../../../model/RelationModel'
+import type { AnyAux } from '../../../model/types'
+import * as Expr from '../../../types/expression'
+import { elementExprToPredicate } from '../../utils/elementExpressionToPredicate'
+import type { ConnectionWhere, PredicateExecutor } from '../_types'
+import { resolveAndIncludeFromMemory, resolveElements } from './_utils'
+
+export const IncomingExprPredicate: PredicateExecutor<Expr.IncomingExpr> = {
+  include: ({ expr, scope, model, memory, stage, filterWhere }) => {
+    const target = expr.incoming
+    const connections = [] as ConnectionModel<AnyAux>[]
+    if (Expr.isWildcard(target)) {
+      if (!scope) {
+        return
+      }
+      for (const sibling of scope.ascendingSiblings()) {
+        connections.push(
+          ...findConnection(
+            sibling,
+            scope,
+            'directed'
+          )
+        )
+      }
+    } else {
+      const targets = resolveAndIncludeFromMemory(target, { memory, model })
+      const visibleElements = [...memory.elements]
+      if (visibleElements.length === 0) {
+        visibleElements.push(
+          ...unique(
+            targets.flatMap(el => [...el.ascendingSiblings()])
+          )
+        )
+      }
+      const ensureIncoming = incomingConnectionPredicate(model, target)
+      for (const visible of visibleElements) {
+        connections.push(
+          ...findConnectionsBetween(
+            visible,
+            targets,
+            'directed'
+          ).filter(ensureIncoming)
+        )
+      }
+    }
+
+    stage.addConnections(
+      filterWhere(connections)
+    )
+
+    return stage
+  },
+  exclude: ({ expr: { incoming }, model, scope, stage, where }) => {
+    const excluded = [] as RelationshipModel[]
+    if (Expr.isWildcard(incoming)) {
+      if (!scope) {
+        return
+      }
+      excluded.push(...scope.allIncoming)
+    } else {
+      const elements = resolveElements(model, incoming)
+      excluded.push(
+        ...elements.flatMap(e => [...e.allIncoming])
+      )
+    }
+    stage.excludeRelations(new Set(excluded.filter(where)))
+
+    return stage
+  }
+}
+
+export function incomingConnectionPredicate(
+  model: LikeC4Model,
+  expr: Exclude<Expr.ElementExpression, Expr.WildcardExpr>
+): ConnectionWhere {
+  switch (true) {
+    case Expr.isElementKindExpr(expr):
+    case Expr.isElementTagExpr(expr): {
+      const isElement = elementExprToPredicate(expr)
+      return (connection) => isElement(connection.target)
+    }
+    case Expr.isElementRef(expr) && expr.isChildren: {
+      return anyPass(
+        [...model.children(expr.element)].map(
+          el => Connection.isIncoming(el.id)
+        )
+      )
+    }
+    case Expr.isElementRef(expr) && expr.isDescendants: {
+      return anyPass([
+        Connection.isInside(expr.element),
+        ...[...model.children(expr.element)].map(
+          el => Connection.isIncoming(el.id)
+        )
+      ])
+    }
+    case Expr.isExpandedElementExpr(expr): {
+      return anyPass([
+        Connection.isIncoming(expr.expanded),
+        Connection.isInside(expr.expanded)
+      ])
+    }
+    case Expr.isElementRef(expr): {
+      return Connection.isIncoming(expr.element)
+    }
+    default:
+      nonexhaustive(expr)
+  }
+}

package/src/compute-view/element-view/predicates/relation-out.ts

@@ -0,0 +1,116 @@
+import { anyPass, unique } from 'remeda'
+import { nonexhaustive } from '../../../errors'
+import type { LikeC4Model } from '../../../model'
+import { Connection, type ConnectionModel, findConnectionsBetween } from '../../../model/connection/model'
+import type { RelationshipModel } from '../../../model/RelationModel'
+import type { AnyAux } from '../../../model/types'
+import * as Expr from '../../../types/expression'
+import { toSet } from '../../../utils/iterable/to'
+import { elementExprToPredicate } from '../../utils/elementExpressionToPredicate'
+import type { ConnectionWhere, PredicateExecutor } from '../_types'
+import { resolveAndIncludeFromMemory, resolveElements } from './_utils'
+
+export const OutgoingExprPredicate: PredicateExecutor<Expr.OutgoingExpr> = {
+  include: ({ expr, scope, model, memory, stage, filterWhere }) => {
+    const target = expr.outgoing
+    const connections = [] as ConnectionModel<AnyAux>[]
+    if (Expr.isWildcard(target)) {
+      if (!scope) {
+        return
+      }
+
+      connections.push(
+        ...findConnectionsBetween(
+          scope,
+          scope.ascendingSiblings(),
+          'directed'
+        )
+      )
+    } else {
+      const elements = resolveAndIncludeFromMemory(target, { memory, model })
+      const visibleElements = [...memory.elements]
+      if (visibleElements.length === 0) {
+        visibleElements.push(
+          ...unique(
+            elements.flatMap(el => [...el.ascendingSiblings()])
+          )
+        )
+      }
+      const ensureOutgoing = outgoingConnectionPredicate(model, target)
+
+      for (const source of elements) {
+        connections.push(
+          ...findConnectionsBetween(
+            source,
+            visibleElements,
+            'directed'
+          ).filter(ensureOutgoing)
+        )
+      }
+    }
+
+    stage.addConnections(
+      filterWhere(connections)
+    )
+
+    return stage
+  },
+  exclude: ({ expr: { outgoing }, model, scope, stage, where }) => {
+    const excluded = [] as RelationshipModel[]
+    if (Expr.isWildcard(outgoing)) {
+      if (!scope) {
+        return
+      }
+      excluded.push(...scope.allOutgoing)
+    } else {
+      const elements = resolveElements(model, outgoing)
+      excluded.push(
+        ...elements.flatMap(e => [...e.allOutgoing])
+      )
+    }
+    stage.excludeRelations(
+      toSet(excluded.filter(where))
+    )
+
+    return stage
+  }
+}
+
+export function outgoingConnectionPredicate(
+  model: LikeC4Model,
+  expr: Exclude<Expr.ElementExpression, Expr.WildcardExpr>
+): ConnectionWhere {
+  switch (true) {
+    case Expr.isElementKindExpr(expr):
+    case Expr.isElementTagExpr(expr): {
+      const isElement = elementExprToPredicate(expr)
+      return (connection) => isElement(connection.source)
+    }
+    case Expr.isElementRef(expr) && expr.isChildren: {
+      return anyPass(
+        [...model.children(expr.element)].map(
+          el => Connection.isOutgoing(el.id)
+        )
+      )
+    }
+    case Expr.isElementRef(expr) && expr.isDescendants: {
+      return anyPass([
+        Connection.isInside(expr.element),
+        ...[...model.children(expr.element)].map(
+          el => Connection.isOutgoing(el.id)
+        )
+      ])
+    }
+    case Expr.isExpandedElementExpr(expr): {
+      return anyPass([
+        Connection.isOutgoing(expr.expanded),
+        Connection.isInside(expr.expanded)
+      ])
+    }
+    case Expr.isElementRef(expr): {
+      return Connection.isOutgoing(expr.element)
+    }
+    default:
+      nonexhaustive(expr)
+  }
+}