@likec4/core 1.18.0 → 1.19.0

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

@@ -0,0 +1,88 @@
+import { filter } from 'remeda'
+import { findConnectionsBetween, findConnectionsWithin } from '../../../model/connection/model'
+import type { WildcardExpr } from '../../../types/expression'
+import { ifilter, toArray } from '../../../utils/iterable'
+import { toSet } from '../../../utils/iterable/to'
+import { type PredicateExecutor, Memory } from '../_types'
+import { NoWhere } from '../utils'
+
+export const WildcardPredicate: PredicateExecutor<WildcardExpr> = {
+  include: ({ scope, model, stage, memory, where }) => {
+    if (!scope) {
+      const rootElements = [...model.roots()].filter(where)
+      if (rootElements.length === 0) {
+        return
+      }
+      stage.addExplicit(rootElements)
+      stage.addConnections(findConnectionsWithin(rootElements))
+
+      stage.connectWithExisting(rootElements)
+
+      return stage
+    }
+    const root = where(scope) ? scope : null
+
+    const children = toArray(ifilter(scope.children(), where))
+    const hasChildren = children.length > 0
+    if (!hasChildren) {
+      if (!root) {
+        return stage
+      } else {
+        // Any edges with siblings?
+        const edgesWithSiblings = findConnectionsBetween(root, root.siblings())
+        if (edgesWithSiblings.length === 0) {
+          // If no edges with siblings, i.e. root is orphan
+          // Lets add parent for better view
+          const parent = root.parent
+          if (parent && where(parent)) {
+            stage.addExplicit(parent)
+          }
+        }
+        children.push(root)
+      }
+    }
+
+    if (root) {
+      stage.addExplicit(root)
+    }
+
+    const neighbours = toSet([
+      ...memory.elements,
+      ...scope.descendingSiblings(),
+    ])
+
+    // Add incoming connections
+    for (const neighbour of neighbours) {
+      stage.addConnections(findConnectionsBetween(neighbour, children, 'directed'))
+    }
+
+    // connection between children
+    if (hasChildren) {
+      stage.addConnections(findConnectionsWithin(children))
+      stage.addExplicit(children)
+    }
+
+    // Add outgoing connections
+    for (const child of children) {
+      stage.addConnections(findConnectionsBetween(child, neighbours, 'directed'))
+    }
+
+    return stage
+  },
+  exclude: ({ scope, memory, stage, where }) => {
+    if (where !== NoWhere) {
+      stage.exclude(
+        filter(
+          [...memory.elements],
+          where,
+        ),
+      )
+      return stage
+    }
+    if (scope) {
+      stage.exclude([scope, ...scope.descendants()])
+      return stage
+    }
+    return Memory.empty(memory.scope).stageExclude(stage.expression)
+  },
+}

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

@@ -0,0 +1,59 @@
+import { hasAtLeast } from 'remeda'
+import { invariant } from '../../errors'
+import { type ComputedEdge, type ComputedNode, type Fqn } from '../../types'
+import { buildComputedNodes, type ComputedNodeSource } from '../utils/buildComputedNodes'
+import { mergePropsFromRelationships } from '../utils/merge-props-from-relationships'
+import type { Connection, Elem, Memory } from './_types'
+
+export const NoWhere = () => true
+export const NoFilter = <T>(x: T[] | readonly T[]): T[] => x as T[]
+
+export function toNodeSource(el: Elem): ComputedNodeSource {
+  return {
+    ...el.$element,
+    modelRef: 1
+  }
+}
+
+export function toComputedEdges(
+  connections: ReadonlyArray<Connection>
+): ComputedEdge[] {
+  return connections.reduce((acc, e) => {
+    // const modelRelations = []
+    // const deploymentRelations = []
+    const relations = [
+      ...e.relations
+    ]
+    invariant(hasAtLeast(relations, 1), 'Edge must have at least one relation')
+
+    const source = e.source.id
+    const target = e.target.id
+
+    const {
+      title,
+      ...props
+    } = mergePropsFromRelationships(
+      relations.map(r => r.$relationship),
+      relations.find(r => r.source.id === source && r.target.id === target)?.$relationship
+    )
+
+    const edge: ComputedEdge = {
+      id: e.id,
+      parent: e.boundary?.id ?? null,
+      source,
+      target,
+      label: title ?? null,
+      relations: relations.map((r) => r.id),
+      ...props
+    }
+
+    acc.push(edge)
+    return acc
+  }, [] as ComputedEdge[])
+}
+
+export function buildNodes(memory: Memory): ReadonlyMap<Fqn, ComputedNode> {
+  // typecast to MutableMemory
+  // invariant(memory instanceof MutableMemory, 'Expected MutableMemory')
+  return buildComputedNodes([...memory.final].map(toNodeSource), memory.groups)
+}

package/src/compute-view/index.ts

@@ -1,5 +1,4 @@
-export { computeViews, mkComputeView } from './compute-view'
-export { LikeC4ModelGraph } from './LikeC4ModelGraph'
+export { computeView, computeViews, unsafeComputeView } from './compute-view'
+export type { ComputeViewResult } from './compute-view'
 export { resolveRulesExtendedViews } from './utils/resolve-extended-views'
-export { withReadableEdges } from './utils/with-readable-edges'
-export { viewsWithReadableEdges } from './utils/with-readable-edges'
+export { viewsWithReadableEdges, withReadableEdges } from './utils/with-readable-edges'

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

@@ -0,0 +1,45 @@
+import type { AnyCtx, ComputeMemory, GenericCtx, MutableState, StageExpression } from './_types'
+
+export abstract class AbstractMemory<T extends AnyCtx = GenericCtx> implements ComputeMemory<T> {
+  /**
+   * Provides access to context types
+   * !IMPORTANT: Should not be called in runtime
+   *
+   * @example
+   * ```ts
+   *   type State = SomeMemory['Ctx']['MutableState']
+   * ```
+   */
+  public get Ctx(): T {
+    throw new Error('Should not be called in runtime')
+  }
+
+  protected constructor(protected state: MutableState<T>) {
+  }
+
+  public get elements(): ReadonlySet<T['Element']> {
+    return this.state.elements
+  }
+  public get explicits(): ReadonlySet<T['Element']> {
+    return this.state.explicits
+  }
+  public get final(): ReadonlySet<T['Element']> {
+    return this.state.final
+  }
+  public get connections(): ReadonlyArray<T['Connection']> {
+    return this.state.connections
+  }
+
+  public isEmpty(): boolean {
+    return this.elements.size === 0 && this.connections.length === 0
+      && this.explicits.size === 0 && this.final.size === 0
+  }
+
+  abstract mutableState(): MutableState<T>
+
+  abstract stageInclude(expr: StageExpression<T>): T['StageInclude']
+
+  abstract stageExclude(expr: StageExpression<T>): T['StageExclude']
+
+  abstract update(newstate: Partial<MutableState<T>>): T['Memory']
+}

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

@@ -0,0 +1,216 @@
+import { isBoolean, pipe } from 'remeda'
+import { invariant } from '../../errors'
+import { findAscendingConnections } from '../../model/connection'
+import { difference, intersection, isDescendantOf, isIterable } from '../../utils'
+import { ifilter, isome, toSet } from '../../utils/iterable'
+import type { AnyCtx, CtxConnection, CtxElement, MutableState, StageExclude, StageExpression } from './_types'
+
+export abstract class AbstractStageExclude<T extends AnyCtx> implements StageExclude<T> {
+  // Removed elements
+  protected excluded = {
+    elements: new Set<CtxElement<T>>(),
+    connections: [] as CtxConnection<T>[],
+  }
+
+  constructor(
+    public readonly memory: T['Memory'],
+    public readonly expression: StageExpression<T>,
+  ) {
+  }
+
+  protected markedToMoveExplicitToImplicit = false
+
+  protected _removeElement(element: CtxElement<T>): void {
+    this.excluded.elements.add(element)
+  }
+
+  public exclude(element: CtxElement<T> | Iterable<CtxElement<T>> | false | undefined | null): this {
+    if (!element) {
+      return this
+    }
+    if (isIterable(element)) {
+      for (const el of element) {
+        this._removeElement(el)
+      }
+      return this
+    }
+    this._removeElement(element)
+    return this
+  }
+
+  protected _removeConnection(connection: CtxConnection<T>): void {
+    this.excluded.connections.push(connection)
+  }
+  /**
+   * Excludes from the memory relationships from given connections (still connection may be included, but without given relationships)
+   * @param moveExplicitToImplicit - if true, disconnected explicit elements will be moved to implicit
+   * @default false
+   */
+  public excludeConnections(
+    connection: CtxConnection<T> | Iterable<CtxConnection<T>>,
+    moveExplicitToImplicit?: boolean,
+  ) {
+    if (isBoolean(moveExplicitToImplicit)) {
+      invariant(!this.markedToMoveExplicitToImplicit, 'Already marked to move explicits')
+      this.markedToMoveExplicitToImplicit = moveExplicitToImplicit
+    }
+    if (isIterable(connection)) {
+      for (const c of connection) {
+        this._removeConnection(c)
+      }
+      return this
+    }
+    this._removeConnection(connection)
+    return this
+  }
+
+  public isDirty(): boolean {
+    return this.excluded.elements.size > 0 || this.excluded.connections.length > 0
+  }
+
+  public isEmpty(): boolean {
+    return !this.isDirty()
+  }
+
+  /**
+   * Determines whether disconnected explicits should become implicits.
+   * By default moves all disconnected explicits to implicits, if there were operation to exclude elements.
+   *
+   * Override this method to change the behavior.
+   */
+  protected filterForMoveToImplicits(disconnectedExplicits: Set<CtxElement<T>>): Set<CtxElement<T>> {
+    if (this.markedToMoveExplicitToImplicit || this.excluded.elements.size > 0) {
+      return disconnectedExplicits
+    }
+    return new Set()
+  }
+
+  // Check if Leaf EXPLICIT elements are becoming IMPLICIT
+  // (it means that they are not connected anymore)
+  protected moveDisconnectedExplicitsToImplicits(state: MutableState<T>): MutableState<T> {
+    // Check if EXPLICIT elements are becoming IMPLICIT
+    let disconnected = difference(
+      new Set(this.memory.connections.flatMap(c => [c.source, c.target])),
+      new Set(state.connections.flatMap(c => [c.source, c.target])),
+    )
+    // Ensure existing in implicits
+    disconnected = intersection(
+      disconnected,
+      state.elements,
+    )
+    // Ensure this is a leaf explici element
+    disconnected = pipe(
+      disconnected,
+      ifilter(el => {
+        return state.explicits.has(el) && !isome(state.final, isDescendantOf(el))
+      }),
+      toSet(),
+    )
+    if (disconnected.size > 0) {
+      disconnected = this.filterForMoveToImplicits(disconnected)
+      state.explicits = difference(state.explicits, disconnected)
+      // Exclude from final elements
+      state.final = difference(state.final, disconnected)
+    }
+    return state
+  }
+
+  protected removeElements(state: MutableState<T>): MutableState<T> {
+    state.elements = difference(state.elements, this.excluded.elements)
+    state.explicits = difference(state.explicits, this.excluded.elements)
+    state.final = difference(state.final, this.excluded.elements)
+    return state
+  }
+
+  protected removeConnections(state: MutableState<T>): MutableState<T> {
+    const excludedMap = this.excluded.connections.reduce((acc, c) => {
+      const existing = acc.get(c.id)
+      if (existing) {
+        acc.set(c.id, existing.mergeWith(c) as CtxConnection<T>)
+      } else {
+        acc.set(c.id, c)
+      }
+      return acc
+    }, new Map<string, CtxConnection<T>>())
+
+    // were connected before and not anymore
+    let disconnected = new Set<CtxElement<T>>()
+
+    state.connections = state.connections.reduce((acc, c) => {
+      const excluded = excludedMap.get(c.id)
+      if (excluded) {
+        disconnected.add(c.source)
+        disconnected.add(c.target)
+        const diff = c.difference(excluded) as CtxConnection<T>
+        if (diff.nonEmpty()) {
+          acc.push(diff)
+        }
+      } else {
+        acc.push(c)
+      }
+      return acc
+    }, [] as CtxConnection<T>[])
+
+    for (const stillExists of state.connections) {
+      disconnected.delete(stillExists.source)
+      disconnected.delete(stillExists.target)
+      if (stillExists.boundary && state.elements.has(stillExists.boundary)) {
+        disconnected.delete(stillExists.boundary)
+      }
+    }
+
+    if (disconnected.size === 0) {
+      return state
+    }
+    // Keep explicits
+    disconnected = difference(disconnected, state.explicits)
+    // Even if not connected, implicit elements should be kept
+    // state.elements = difference(state.elements, excludedElements)
+    state.final = difference(state.final, disconnected)
+
+    return state
+  }
+
+  /**
+   * Precommit hook
+   */
+  protected precommit(state: MutableState<T>): MutableState<T> {
+    return state
+  }
+
+  /**
+   * Postcommit hook
+   */
+  protected postcommit(state: MutableState<T>): MutableState<T> {
+    invariant(difference(state.explicits, state.elements).size === 0, 'Explicits must be subset of elements')
+    invariant(difference(state.final, state.elements).size === 0, 'Final elements must be subset of elements')
+    return state
+  }
+
+  public commit(): T['Memory'] {
+    let state = this.precommit(this.memory.mutableState())
+
+    // Exclude connections from excluded elements
+    if (this.excluded.elements.size > 0) {
+      const excludedConnections = state.connections
+        .filter(c => this.excluded.elements.has(c.source) || this.excluded.elements.has(c.target))
+        .flatMap(c => [
+          c,
+          ...findAscendingConnections(state.connections, c)
+            .map(asc => asc.intersect(c) as CtxConnection<T>),
+        ])
+        .filter(asc => asc.nonEmpty())
+      this.excludeConnections(excludedConnections)
+    }
+    if (this.excluded.connections.length > 0) {
+      state = this.removeConnections(state)
+    }
+    if (this.excluded.elements.size > 0) {
+      state = this.removeElements(state)
+    }
+
+    state = this.moveDisconnectedExplicitsToImplicits(state)
+
+    return this.memory.update(this.postcommit(state))
+  }
+}

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

@@ -0,0 +1,200 @@
+import { partition } from 'remeda'
+import { mergeConnections } from '../../model/connection'
+import { intersection, isIterable, union } from '../../utils'
+import type {
+  AnyCtx,
+  CtxConnection as Connection,
+  CtxElement as Elem,
+  GenericCtx,
+  MutableState,
+  StageExpression,
+  StageInclude,
+} from './_types'
+
+export abstract class AbstractStageInclude<T extends AnyCtx = GenericCtx> implements StageInclude<T> {
+  // New elements
+  protected explicits = new Set<Elem<T>>()
+  protected implicits = new Set<Elem<T>>()
+
+  // Ordered Set of explicit and implicit elements
+  protected _ordered = new Set<Elem<T>>()
+
+  protected _connections = [] as Connection<T>[]
+
+  constructor(
+    public readonly memory: T['Memory'],
+    public readonly expression: StageExpression<T>,
+  ) {
+  }
+
+  get elements(): ReadonlySet<Elem<T>> {
+    return this.explicits
+  }
+
+  /**
+   * Connections from this stage
+   */
+  get connections(): readonly Connection<T>[] {
+    return this._connections
+  }
+
+  mergedConnections(): readonly Connection<T>[] {
+    return mergeConnections([
+      ...this.memory.connections,
+      ...this._connections,
+    ])
+  }
+
+  public connectWithExisting(
+    _element: Elem<T> | Iterable<Elem<T>>,
+    _direction?: 'in' | 'out' | 'both',
+  ): boolean {
+    throw new Error('Method not implements, depends on the model')
+  }
+
+  /**
+   * Possible to override
+   */
+  protected _addExplicit(elements: Elem<T>): void {
+    this._ordered.add(elements)
+    this.explicits.add(elements)
+    this.implicits.delete(elements)
+  }
+
+  public addExplicit(element: Elem<T> | Iterable<Elem<T>> | false | undefined | null): this {
+    if (!element) {
+      return this
+    }
+    if (isIterable(element)) {
+      for (const el of element) {
+        this._addExplicit(el)
+      }
+      return this
+    }
+    this._addExplicit(element)
+    return this
+  }
+
+  /**
+   * Possible to override
+   */
+  protected _addImplicit(elements: Elem<T>): void {
+    if (this.explicits.has(elements)) {
+      return
+    }
+    this._ordered.add(elements)
+    this.implicits.add(elements)
+  }
+
+  public addImplicit(elements: Elem<T> | Iterable<Elem<T>> | false | undefined | null): this {
+    if (!elements) {
+      return this
+    }
+    if (isIterable(elements)) {
+      for (const el of elements) {
+        this._addImplicit(el)
+      }
+      return this
+    }
+    this._addImplicit(elements)
+    return this
+  }
+
+  /**
+   * Possible to override
+   */
+  protected _addConnection(connection: Connection<T>): void {
+    this._connections.push(connection)
+    this._addImplicit(connection.source)
+    this._addImplicit(connection.target)
+  }
+
+  public addConnections(connection: Connection<T> | Iterable<Connection<T>>): this {
+    if (isIterable(connection)) {
+      for (const c of connection) {
+        this._addConnection(c)
+      }
+      return this
+    }
+    this._addConnection(connection)
+    return this
+  }
+
+  public isDirty(): boolean {
+    return this.explicits.size > 0 || this.implicits.size > 0 || this._connections.length > 0
+  }
+
+  public isEmpty(): boolean {
+    return !this.isDirty()
+  }
+
+  /**
+   * Precommit hook
+   */
+  protected precommit(state: MutableState<T>): MutableState<T> {
+    return state
+  }
+
+  /**
+   * Postcommit hook
+   */
+  protected postcommit(state: MutableState<T>): MutableState<T> {
+    return state
+  }
+
+  protected processConnections(connections: Connection<T>[]): Connection<T>[] { // To preserve order, we split new connections into two sets
+    return connections
+  }
+
+  public commit(): T['Memory'] {
+    let state = this.precommit(this.memory.mutableState())
+
+    let fromConnections = new Set<Elem<T>>()
+
+    if (this._connections.length > 0) {
+      // To preserve order, we split new connections into two sets
+      // First are outgoing from known elements (in memory.elements)
+      const [fromKnown, rest] = partition(
+        this._connections,
+        c => state.final.has(c.source),
+      )
+
+      state.connections = this.processConnections(
+        mergeConnections([
+          ...state.connections,
+          ...fromKnown,
+          ...rest,
+        ]),
+      )
+
+      fromConnections = new Set(state.connections.flatMap(c => [c.source, c.target]))
+    }
+
+    state.elements = union(
+      state.elements,
+      this._ordered,
+      this.explicits,
+      fromConnections,
+      this.implicits,
+    )
+
+    state.explicits = intersection(
+      state.elements,
+      union(
+        state.explicits,
+        this.explicits,
+      ),
+    )
+
+    state.final = intersection(
+      state.elements,
+      union(
+        state.final,
+        this.explicits,
+        fromConnections,
+      ),
+    )
+
+    return this.memory.update(this.postcommit(state))
+  }
+}