@likec4/core 1.17.1 → 1.19.0

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

@@ -0,0 +1,4 @@
+export { computeView, computeViews, unsafeComputeView } from './compute-view'
+export type { ComputeViewResult } from './compute-view'
+export { resolveRulesExtendedViews } from './utils/resolve-extended-views'
+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))
+  }
+}

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

@@ -0,0 +1,147 @@
+import type { Connection } from '../../model/connection'
+import type { DeploymentElementModel } from '../../model/DeploymentElementModel'
+import type { ElementModel } from '../../model/ElementModel'
+
+type Element = ElementModel | DeploymentElementModel
+
+export interface ComputeCtx<
+  E extends Element,
+  C extends Connection<E, any>,
+  M extends ComputeMemory<any>,
+  Inc extends StageInclude<any>,
+  Exc extends StageExclude<any>,
+  Expr = unknown,
+> {
+  Element: E
+  Connection: C
+  Memory: M
+  StageInclude: Inc
+  StageExclude: Exc
+  Expr: Expr
+  MutableState: State<this>
+}
+
+// export type AnyCtx = ComputeCtx<any, any, ComputeMemory<any>, StageInclude<any>, StageExclude<any>, any>
+export type AnyCtx = GenericCtx
+
+export type GenericCtx = ComputeCtx<
+  any,
+  Connection<any, any>,
+  ComputeMemory<GenericCtx>,
+  StageInclude<GenericCtx>,
+  StageExclude<GenericCtx>,
+  unknown
+>
+
+export interface State<T extends AnyCtx> {
+  elements: Set<CtxElement<T>>
+  explicits: Set<CtxElement<T>>
+  final: Set<CtxElement<T>>
+  connections: Array<CtxConnection<T>>
+}
+
+export type MutableState<T extends AnyCtx> = T['MutableState']
+
+export type StageExpression<T extends AnyCtx> = T['Expr']
+
+export type CtxElement<T extends AnyCtx> = T['Element']
+export type CtxConnection<T extends AnyCtx> = T['Connection']
+export type CtxMemory<T extends AnyCtx> = T['Memory']
+
+export interface ComputeMemory<T extends AnyCtx> {
+  /**
+   * All resolved elements, includes:
+   * - explicit elements (included by element predicates, always appear in the view unless excluded)
+   * - elements from resolved connections (may be excluded, if connection is redundant @see excludeRedundantRelationships
+   * - implicit elements (not added directly, not included in the view, used for resolving connections)
+   */
+  readonly elements: ReadonlySet<CtxElement<T>>
+
+  /**
+   * Explicit elements
+   */
+  readonly explicits: ReadonlySet<CtxElement<T>>
+
+  /**
+   * Final set of elements to be included in the view
+   * (`elements` excluding implicits)
+   * Keeps order in which elements were added
+   */
+  readonly final: ReadonlySet<CtxElement<T>>
+
+  /**
+   * Resolved connections
+   */
+  readonly connections: ReadonlyArray<CtxConnection<T>>
+
+  isEmpty(): boolean
+
+  stageInclude(expression: T['Expr']): T['StageInclude']
+
+  stageExclude(expression: T['Expr']): T['StageExclude']
+
+  /**
+   * Returns shallow copy of state
+   */
+  mutableState(): T['MutableState']
+
+  /**
+   * Returns new memory with updated state
+   */
+  update(newstate: Partial<T['MutableState']>): T['Memory']
+}
+
+interface Stage<T extends AnyCtx> {
+  readonly memory: CtxMemory<T>
+
+  readonly expression: StageExpression<T>
+
+  /**
+   * Has changes
+   */
+  isDirty(): boolean
+
+  /**
+   * Has no changes
+   */
+  isEmpty(): boolean
+
+  commit(): T['Memory']
+}
+
+export interface StageInclude<T extends AnyCtx> extends Stage<T> {
+  readonly elements: ReadonlySet<CtxElement<T>>
+
+  readonly connections: ReadonlyArray<CtxConnection<T>>
+
+  addExplicit(element: CtxElement<T> | Iterable<CtxElement<T>> | false | undefined | null): this
+
+  addImplicit(element: CtxElement<T> | Iterable<CtxElement<T>> | false | undefined | null): this
+
+  /**
+   * Connects element with existing ones in the memory
+   *
+   * @param direction - direction of the connection
+   * @default 'both'
+   */
+  connectWithExisting(
+    element: CtxElement<T> | Iterable<CtxElement<T>>,
+    direction?: 'in' | 'out' | 'both',
+  ): boolean
+
+  addConnections(connection: CtxConnection<T> | Iterable<CtxConnection<T>>): this
+}
+
+export interface StageExclude<T extends AnyCtx> extends Stage<T> {
+  /**
+   * 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
+   */
+  excludeConnections(
+    connection: CtxConnection<T> | Iterable<CtxConnection<T>>,
+    moveExplicitToImplicit?: boolean,
+  ): this
+
+  exclude(element: CtxElement<T> | Iterable<CtxElement<T>> | false | undefined | null): this
+}

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

@@ -0,0 +1,5 @@
+export type * from './_types'
+export { AbstractMemory } from './AbstractMemory'
+export { AbstractStageExclude } from './AbstractStageExclude'
+export { AbstractStageInclude } from './AbstractStageInclude'
+export { treeFromMemoryState } from './ops'