@likec4/core 1.17.1 → 1.18.0

package/src/compute-view/LikeC4ModelGraph.ts

@@ -0,0 +1,330 @@
+import { isArray, isString, reverse } from 'remeda'
+import { invariant } from '../errors'
+import { type Element, type Fqn, type ModelGlobals, type Relation, type RelationId } from '../types'
+import { ancestorsFqn, commonAncestor, getOrCreate, isSameHierarchy, parentFqn } from '../utils'
+import { intersection } from '../utils/set'
+
+export type Params = {
+  elements: Record<Fqn, Element>
+  relations: Record<RelationId, Relation>
+  // Optional for tests
+  globals?: ModelGlobals
+}
+
+type RelationEdge = {
+  source: Element
+  target: Element
+  relations: Relation[]
+}
+
+type FqnOrElement = Fqn | Element
+type FqnsOrElements = ReadonlyArray<Fqn> | ReadonlyArray<Element>
+
+const RelationsSet = Set<Relation>
+const MapRelations = Map<Fqn, Set<Relation>>
+/**
+ * Used only for views calculations.
+ * Subject to change.
+ */
+export class LikeC4ModelGraph {
+  readonly #elements = new Map<Fqn, Element>()
+  // Parent element for given FQN
+  readonly #parents = new Map<Fqn, Element>()
+  // Children elements for given FQN
+  readonly #children = new Map<Fqn, Element[]>()
+  readonly #rootElements = new Set<Element>()
+
+  readonly #relations = new Map<RelationId, Relation>()
+  // Incoming to an element or its descendants
+  readonly #incoming = new MapRelations()
+  // Outgoing from an element or its descendants
+  readonly #outgoing = new MapRelations()
+  // Relationships inside the element, among descendants
+  readonly #internal = new MapRelations()
+
+  readonly #cacheAscendingSiblings = new Map<Fqn, Element[]>()
+
+  public readonly globals: ModelGlobals
+
+  constructor(
+    { elements, relations, globals }: Params
+  ) {
+    this.globals = globals ?? {
+      predicates: {},
+      dynamicPredicates: {},
+      styles: {}
+    }
+    for (const el of Object.values(elements)) {
+      this.addElement(el)
+    }
+    for (const rel of Object.values(relations)) {
+      this.addRelation(rel)
+    }
+  }
+
+  get rootElements() {
+    return [...this.#rootElements]
+  }
+
+  get elements() {
+    return [...this.#elements.values()]
+  }
+
+  public element(id: Fqn) {
+    const el = this.#elements.get(id)
+    invariant(el, `Element ${id} not found`)
+    return el
+  }
+
+  public connectedRelations(id: Fqn) {
+    return [...this._incomingTo(id), ...this._outgoingFrom(id), ...this._internalOf(id)]
+  }
+
+  public children(id: Fqn) {
+    return this._childrenOf(id).slice()
+  }
+
+  public descendants(id: Fqn) {
+    const result: Element[] = []
+    this.descendantsDfs(id, result)
+    return result
+  }
+
+  private descendantsDfs(id: Fqn, result: Element[]) {
+    result.push(this.element(id))
+    this.children(id).forEach(c => this.descendantsDfs(c.id, result))
+  }
+
+  // Get all sibling (i.e. same parent)
+  public siblings(element: Fqn | Element) {
+    const id = isString(element) ? element : element.id
+    const parent = parentFqn(id)
+    const siblings = parent ? this._childrenOf(parent) : this.rootElements
+    return siblings.filter(e => e.id !== id)
+  }
+
+  /**
+   * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+   * (from closest to root)
+   */
+  public ancestors(element: Fqn | Element): Array<Element> {
+    let id = isString(element) ? element : element.id
+    const result = [] as Element[]
+    let parent
+    while (parent = this.#parents.get(id)) {
+      result.push(parent)
+      id = parent.id
+    }
+    return result as Array<Element>
+  }
+
+  /**
+   * Resolve siblings of the element and its ancestors
+   *  (from closest to root)
+   */
+  public ascendingSiblings(element: Fqn | Element): ReadonlyArray<Element> {
+    const id = isString(element) ? element : element.id
+    return getOrCreate(this.#cacheAscendingSiblings, id, () => [
+      ...this.siblings(id),
+      ...this.ancestors(id).flatMap(a => this.siblings(a.id))
+    ])
+  }
+
+  public incoming(element: Fqn | Element): ReadonlySet<Relation> {
+    return this._incomingTo(isString(element) ? element : element.id)
+  }
+
+  public outgoing(element: Fqn | Element): ReadonlySet<Relation> {
+    return this._outgoingFrom(isString(element) ? element : element.id)
+  }
+
+  /**
+   * Resolve all RelationEdges between element and others (any direction)
+   */
+  public anyEdgesBetween(
+    _element: Fqn | Element,
+    others: ReadonlyArray<Fqn> | ReadonlyArray<Element>
+  ): Array<RelationEdge> {
+    if (others.length === 0) {
+      return []
+    }
+    const element = isString(_element) ? this.element(_element) : _element
+    const in_element = this._incomingTo(element.id)
+    const element_out = this._outgoingFrom(element.id)
+    if (in_element.size === 0 && element_out.size === 0) {
+      return []
+    }
+
+    const result = [] as Array<RelationEdge>
+    for (const _other of others) {
+      const other = isString(_other) ? this.element(_other) : _other
+      if (isSameHierarchy(element, other)) {
+        continue
+      }
+
+      if (element_out.size > 0) {
+        const outcoming = intersection(this._incomingTo(other.id), element_out)
+        // const outcoming = filter(in_other, isOutgoing)
+        if (outcoming.size > 0) {
+          result.push({
+            source: element,
+            target: other,
+            relations: [...outcoming]
+          })
+        }
+      }
+
+      if (in_element.size > 0) {
+        const incoming = intersection(this._outgoingFrom(other.id), in_element)
+        // const incoming = filter(other_out, isIncoming)
+        if (incoming.size > 0) {
+          result.push({
+            source: other,
+            target: element,
+            relations: [...incoming]
+          })
+        }
+      }
+    }
+    return result
+  }
+
+  /**
+   * Resolve all RelationEdges between elements (any direction)
+   */
+  public edgesWithin<T extends Fqn[] | Element[]>(elements: T): Array<RelationEdge> {
+    if (elements.length < 2) {
+      return []
+    }
+    return elements.reduce((acc, el, index, array) => {
+      // return acc if last element
+      if (index === array.length - 1) {
+        return acc
+      }
+      acc.push(...this.anyEdgesBetween(el, array.slice(index + 1) as T))
+      return acc
+    }, [] as RelationEdge[])
+  }
+
+  /**
+   * Get directed RelationEdge between source and target if exists
+   */
+  public edgesBetween(
+    _sources: FqnOrElement | FqnsOrElements,
+    _targets: FqnOrElement | FqnsOrElements
+  ) {
+    const sources = isArray(_sources) ? _sources : [_sources]
+    const targets = isArray(_targets) ? _targets : [_targets]
+    if (sources.length === 0 || targets.length === 0) {
+      return []
+    }
+
+    const result = [] as Array<RelationEdge>
+    for (const _source of sources) {
+      const source = isString(_source) ? this.element(_source) : _source
+      const outcoming = this._outgoingFrom(source.id)
+      if (outcoming.size === 0) {
+        continue
+      }
+      // const isSameAsOut = isIncludedIn(outcoming)
+
+      for (const _target of targets) {
+        const target = isString(_target) ? this.element(_target) : _target
+        if (isSameHierarchy(source, target)) {
+          continue
+        }
+        const incoming = this._incomingTo(target.id)
+        const relations = intersection(outcoming, incoming)
+        if (relations.size > 0) {
+          result.push({
+            source,
+            target,
+            relations: [...relations]
+          })
+        }
+      }
+    }
+    return result
+  }
+
+  private addElement(el: Element) {
+    if (this.#elements.has(el.id)) {
+      throw new Error(`Element ${el.id} already exists`)
+    }
+    this.#elements.set(el.id, el)
+    const parentId = parentFqn(el.id)
+    if (parentId) {
+      this.#parents.set(el.id, this.element(parentId))
+      this._childrenOf(parentId).push(el)
+    } else {
+      this.#rootElements.add(el)
+    }
+  }
+
+  private addRelation(rel: Relation) {
+    if (this.#relations.has(rel.id)) {
+      throw new Error(`Relation ${rel.id} already exists`)
+    }
+    this.#relations.set(rel.id, rel)
+    this._incomingTo(rel.target).add(rel)
+    this._outgoingFrom(rel.source).add(rel)
+
+    const relParent = commonAncestor(rel.source, rel.target)
+    // Process internal relationships
+    if (relParent) {
+      for (const ancestor of [relParent, ...ancestorsFqn(relParent)]) {
+        this._internalOf(ancestor).add(rel)
+      }
+    }
+    // Process source hierarchy
+    for (const sourceAncestor of ancestorsFqn(rel.source)) {
+      if (sourceAncestor === relParent) {
+        break
+      }
+      this._outgoingFrom(sourceAncestor).add(rel)
+    }
+    // Process target hierarchy
+    for (const targetAncestor of ancestorsFqn(rel.target)) {
+      if (targetAncestor === relParent) {
+        break
+      }
+      this._incomingTo(targetAncestor).add(rel)
+    }
+  }
+
+  private _childrenOf(id: Fqn) {
+    let children = this.#children.get(id)
+    if (!children) {
+      children = []
+      this.#children.set(id, children)
+    }
+    return children
+  }
+
+  private _incomingTo(id: Fqn) {
+    let incoming = this.#incoming.get(id)
+    if (!incoming) {
+      incoming = new RelationsSet()
+      this.#incoming.set(id, incoming)
+    }
+    return incoming
+  }
+
+  private _outgoingFrom(id: Fqn) {
+    let outgoing = this.#outgoing.get(id)
+    if (!outgoing) {
+      outgoing = new RelationsSet()
+      this.#outgoing.set(id, outgoing)
+    }
+    return outgoing
+  }
+
+  private _internalOf(id: Fqn) {
+    let internal = this.#internal.get(id)
+    if (!internal) {
+      internal = new RelationsSet()
+      this.#internal.set(id, internal)
+    }
+    return internal
+  }
+}

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

@@ -0,0 +1,92 @@
+import { mapValues } from 'remeda'
+import type { SetOptional } from 'type-fest'
+import { nonexhaustive } from '../errors'
+import { LikeC4Model } from '../model'
+import {
+  type ComputedLikeC4ModelFromParsed,
+  type ComputedView,
+  isDeploymentView,
+  isDynamicView,
+  isElementView,
+  type LikeC4View,
+  type ParsedLikeC4Model
+} from '../types'
+import { computeDeploymentView } from './deployment-view/compute'
+import { DynamicViewComputeCtx } from './dynamic-view/compute'
+import { ComputeCtx } from './element-view/compute'
+import { LikeC4ModelGraph } from './LikeC4ModelGraph'
+
+type ComputeViewResult<V extends ComputedView = ComputedView> =
+  | {
+    isSuccess: true
+    error?: undefined
+    view: V
+  }
+  | {
+    isSuccess: false
+    error: Error
+    view: undefined
+  }
+
+type ComputeViewFn = <V extends LikeC4View>(viewsource: V) => ComputeViewResult<ComputedView>
+
+type Params = SetOptional<ParsedLikeC4Model, 'views'>
+export function mkComputeView(model: Params): ComputeViewFn {
+  const index = new LikeC4ModelGraph(model)
+  let likec4model: LikeC4Model
+
+  return function computeView(viewsource) {
+    try {
+      switch (true) {
+        case isDeploymentView(viewsource): {
+          likec4model ??= LikeC4Model.create({
+            ...model,
+            views: {}
+          })
+          return {
+            isSuccess: true,
+            view: computeDeploymentView(likec4model, viewsource)
+          }
+        }
+        case isDynamicView(viewsource):
+          return {
+            isSuccess: true,
+            view: DynamicViewComputeCtx.compute(viewsource, index)
+          }
+        case isElementView(viewsource):
+          return {
+            isSuccess: true,
+            view: ComputeCtx.elementView(viewsource, index)
+          }
+
+        default:
+          nonexhaustive(viewsource)
+      }
+    } catch (e) {
+      return {
+        isSuccess: false,
+        error: e instanceof Error ? e : new Error(`Unknown error: ${e}`),
+        view: undefined
+      }
+    }
+  }
+}
+
+export function computeViews<const P extends ParsedLikeC4Model<any, any, any, any, any, any>>(
+  parsed: P
+): ComputedLikeC4ModelFromParsed<P> {
+  const _computeView = mkComputeView(parsed)
+  const computeView = (source: LikeC4View): ComputedView => {
+    const result = _computeView(source)
+    if (result.isSuccess) {
+      return result.view
+    } else {
+      throw result.error
+    }
+  }
+  return {
+    __: 'computed',
+    ...parsed,
+    views: mapValues(parsed.views, computeView)
+  } as any // TODO: fix this
+}

package/src/compute-view/deployment-view/Memory.ts

@@ -0,0 +1,108 @@
+import type { DeploymentConnectionModel } from '../../model/connection/deployment'
+import { difference } from '../../utils/set'
+import type { Connections, Elem } from './_types'
+
+export interface Memory {
+  /**
+   * All resolved elements, includes:
+   * - explicit elements (added directly, 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<Elem>
+  /**
+   * Resolved connections
+   * May contains duplicates, need to be merged before further processing
+   */
+  readonly connections: Connections
+
+  has(el: Elem): boolean
+
+  isExplicit(el: Elem): boolean
+
+  clone(): MutableMemory
+}
+
+export type Patch = (memory: Memory) => Memory
+
+export class MutableMemory implements Memory {
+  static empty(): Memory {
+    return new MutableMemory(new Set(), new Set(), [], new Set())
+  }
+  constructor(
+    public elements: Set<Elem>,
+    public explicits: Set<Elem>,
+    public connections: DeploymentConnectionModel[],
+    /**
+     * Final set of elements to be included in the view
+     * (`elements` excluding implicits)
+     * Keeps order in which elements were added
+     */
+    public finalElements: Set<Elem>
+  ) {
+  }
+
+  public has(el: Elem): boolean {
+    return this.elements.has(el)
+  }
+
+  public isExplicit(el: Elem): boolean {
+    return this.explicits.has(el)
+  }
+
+  public exclude(excluded: Set<Elem>): MutableMemory {
+    const newMemory = this.clone()
+    newMemory.elements = difference(this.elements, excluded)
+    newMemory.explicits = difference(this.explicits, excluded)
+    newMemory.finalElements = difference(this.finalElements, excluded)
+    newMemory.connections = this.connections.filter(c => !excluded.has(c.source) && !excluded.has(c.target))
+    return newMemory
+  }
+
+  public excludeConnections(excluded: Connections): MutableMemory {
+    if (excluded.length === 0) {
+      return this
+    }
+    const newMemory = this.clone()
+
+    const excludedMap = new Map(excluded.map(c => [c.id, c]))
+    let minusElements = new Set<Elem>()
+
+    newMemory.connections = newMemory.connections.reduce((acc, c) => {
+      const excluded = excludedMap.get(c.id)
+      if (excluded) {
+        minusElements.add(c.source)
+        minusElements.add(c.target)
+        const diff = c.difference(excluded)
+        if (diff.nonEmpty()) {
+          acc.push(diff)
+        }
+      } else {
+        acc.push(c)
+      }
+      return acc
+    }, [] as DeploymentConnectionModel[])
+
+    minusElements = difference(minusElements, newMemory.explicits)
+    if (minusElements.size > 0) {
+      for (const stillExists of newMemory.connections) {
+        minusElements.delete(stillExists.source)
+        minusElements.delete(stillExists.target)
+      }
+    }
+    if (minusElements.size > 0) {
+      newMemory.elements = difference(newMemory.elements, minusElements)
+      newMemory.finalElements = difference(newMemory.finalElements, minusElements)
+    }
+    return newMemory
+  }
+
+  public clone(): MutableMemory {
+    return new MutableMemory(
+      new Set(this.elements),
+      new Set(this.explicits),
+      [...this.connections],
+      new Set(this.finalElements)
+    )
+  }
+}

package/src/compute-view/deployment-view/Stage.ts

@@ -0,0 +1,145 @@
+import { isArray, partition } from 'remeda'
+import { mergeConnections } from '../../model/connection/deployment'
+import type { DeploymentConnectionModel } from '../../model/connection/DeploymentConnectionModel'
+import { union } from '../../utils/set'
+import type { Connections, Elem } from './_types'
+import { type Patch } from './Memory'
+
+const asArray = <T>(value: T | ReadonlyArray<T>): ReadonlyArray<T> => isArray(value) ? value : [value]
+
+/**
+ * Stage is a single step in the computation of the view
+ */
+export class Stage {
+  // New elements
+  readonly #explicits = new Set<Elem>()
+  readonly #implicits = new Set<Elem>()
+
+  // Removed elements
+  readonly #excluded = new Set<Elem>()
+  readonly #excludedConnections = [] as DeploymentConnectionModel[]
+
+  #connections = [] as DeploymentConnectionModel[]
+
+  constructor(
+    public readonly previous: Stage | null = null
+  ) {}
+
+  get connections(): ReadonlyArray<DeploymentConnectionModel> {
+    return this.#connections
+  }
+
+  public addExplicit(elements: Elem | ReadonlyArray<Elem>): void {
+    for (const el of asArray(elements)) {
+      this.#explicits.add(el)
+      this.#implicits.delete(el)
+    }
+  }
+
+  public addImplicit(elements: Elem | ReadonlyArray<Elem>): void {
+    for (const el of asArray(elements)) {
+      if (this.#explicits.has(el)) {
+        continue
+      }
+      this.#implicits.add(el)
+    }
+  }
+
+  public addConnections(connections: Connections): Connections {
+    for (const c of connections) {
+      this.#connections.push(c)
+      this.addImplicit([c.source, c.target])
+    }
+    return connections
+  }
+
+  public exclude(elements: Elem | ReadonlyArray<Elem>): void {
+    if (this.#explicits.size + this.#implicits.size > 0) {
+      console.warn('Excluding elements from the stage with existing elements')
+    }
+    for (const el of asArray(elements)) {
+      this.#excluded.add(el)
+      this.#explicits.delete(el)
+      this.#implicits.delete(el)
+    }
+    if (this.#connections.length > 0) {
+      console.warn('Excluding elements from the stage with existing connections')
+    }
+  }
+
+  public excludeConnections(connections: Connections): void {
+    if (this.#connections.length > 0) {
+      console.warn('Excluding connections from the stage with existing connections')
+    }
+    for (const c of connections) {
+      this.#excludedConnections.push(c)
+      this.#implicits.delete(c.source)
+      this.#implicits.delete(c.target)
+    }
+  }
+
+  public hasConnections(): boolean {
+    return this.#connections.length > 0
+  }
+
+  /**
+   * Returns patch to apply to the memory
+   */
+  public patch(): Patch {
+    return (memory) => {
+      let newMemory = memory.clone()
+
+      let fromConnections = new Set<Elem>()
+
+      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 => memory.elements.has(c.source)
+        )
+
+        newMemory.connections = mergeConnections([
+          ...memory.connections,
+          ...fromKnown,
+          ...rest
+        ])
+
+        fromConnections = new Set([
+          // we have source in memory.elements
+          ...fromKnown.map(c => c.target),
+          ...rest.flatMap(c => [c.source, c.target])
+        ])
+      }
+
+      if (this.#explicits.size > 0 || fromConnections.size > 0 || this.#implicits.size > 0) {
+        newMemory.explicits = union(
+          newMemory.explicits,
+          this.#explicits
+        )
+
+        newMemory.finalElements = union(
+          newMemory.finalElements,
+          this.#explicits,
+          fromConnections
+        )
+
+        newMemory.elements = union(
+          newMemory.elements,
+          this.#explicits,
+          fromConnections,
+          this.#implicits
+        )
+      }
+
+      if (this.#excluded.size > 0) {
+        newMemory = newMemory.exclude(this.#excluded)
+      }
+      if (this.#excludedConnections.length > 0) {
+        newMemory = newMemory.excludeConnections(this.#excludedConnections)
+      }
+
+      return newMemory
+    }
+  }
+}