@likec4/core 1.40.0 → 1.42.0

package/src/compute-view/deployment-view/stages/stage-final.ts

@@ -1,245 +0,0 @@
-import { forEach, only, pipe } from 'remeda'
-import { differenceConnections } from '../../../model'
-import type { RelationshipModel } from '../../../model'
-import { isAncestor, sortByFqnHierarchically } from '../../../utils/fqn'
-import { ifilter, isome, toArray } from '../../../utils/iterable'
-import { DefaultMap } from '../../../utils/mnemonist'
-import { difference, union } from '../../../utils/set'
-import { treeFromMemoryState } from '../../memory'
-import { cleanCrossBoundary, cleanRedundantRelationships } from '../clean-connections'
-import type { Ctx, Memory } from '../memory'
-
-type Elem = Ctx['Element']
-/**
- * This patch:
- * 1. Keeps connections between leafs or having direct deployment relations
- * 2. Removes cross-boundary model relations, that already exist inside boundaries
- *    (e.g. prefer relations inside same deployment node over relations between nodes)
- * 3. Removes implicit connections between elements, if their descendants have same connection
- */
-export class StageFinal {
-  static for(memory: Memory) {
-    return new StageFinal(memory)
-  }
-
-  private constructor(
-    protected readonly memory: Memory,
-  ) {
-  }
-
-  public step1CleanConnections(memory: Memory): Memory {
-    if (memory.connections.length < 2) {
-      return memory
-    }
-
-    // const leafs = new Set<Elem>()
-
-    // for (const element of memory.final) {
-    //   // Instance is always leaf
-    //   if (element.isInstance()) {
-    //     leafs.add(element)
-    //     continue
-    //   }
-    //   // Check if element is ancestor of any element in elements
-    //   let isLeaf = true
-    //   for (const el of memory.final) {
-    //     if (isAncestor(element.id, el.id)) {
-    //       isLeaf = false
-    //       break
-    //     }
-    //   }
-    //   if (isLeaf) {
-    //     leafs.add(element)
-    //   }
-    // }
-
-    const connections = pipe(
-      memory.connections,
-      // Keep connections
-      // - between leafs
-      // - has direct deployment relation
-      // filter(c => {
-      //   return (leafs.has(c.source) && leafs.has(c.target)) || c.hasDirectDeploymentRelation()
-      // }),
-      cleanCrossBoundary,
-      cleanRedundantRelationships,
-    )
-
-    const connectionsToExclude = differenceConnections(
-      memory.connections,
-      connections,
-    )
-    if (connectionsToExclude.length === 0) {
-      return memory
-    }
-    const stage = memory.stageExclude({} as any)
-    stage.excludeConnections(connectionsToExclude, true)
-    return stage.commit()
-  }
-
-  public step2ProcessImplicits(memory: Memory): Memory {
-    const implicits = union(this.memory.elements, memory.elements)
-    const final = union(memory.final, this.memory.explicits)
-
-    // Find connections based on same relation but different boundaries
-    const groupedByRelation = new DefaultMap<RelationshipModel, Set<Elem>>(() => new Set())
-    for (const conn of memory.connections) {
-      if (conn.boundary) {
-        for (const relation of conn.relations.model) {
-          groupedByRelation.get(relation).add(conn.boundary)
-        }
-      }
-    }
-    for (const [_, boundaries] of groupedByRelation) {
-      if (boundaries.size < 2) {
-        continue
-      }
-      for (const boundary of boundaries) {
-        if (implicits.delete(boundary)) {
-          final.add(boundary)
-        }
-      }
-    }
-
-    const snapshot = new Set(final)
-    const isFinalOrHasIncludedDescendant = (el: Elem) => {
-      for (const final of snapshot) {
-        if (el === final || isAncestor(el, final)) {
-          return true
-        }
-      }
-      return false
-    }
-
-    // Pick from implicit elements
-    pipe(
-      difference(implicits, snapshot),
-      ifilter(e => e.isDeploymentNode()),
-      toArray(),
-      sortByFqnHierarchically,
-      forEach((el) => {
-        // If element has more 2 or more children included
-        // It can "box" around
-        const childrensToWrap = [...el.children()].filter(isFinalOrHasIncludedDescendant).length
-        if (childrensToWrap >= 2) {
-          final.add(el)
-          return
-        }
-        // If Element has only one child included
-        // and has "similar" sibling with included descendant
-        if (childrensToWrap === 1 && isome(el.siblings(), isFinalOrHasIncludedDescendant)) {
-          final.add(el)
-        }
-      }),
-    )
-
-    return memory.update({ final })
-  }
-
-  public step3ProcessBoundaries(memory: Memory): Memory {
-    const boundaries = new Set<Elem>()
-    for (const conn of memory.connections) {
-      if (conn.boundary) {
-        boundaries.add(conn.boundary)
-      }
-    }
-    const tree = treeFromMemoryState<Ctx>(memory, 'final')
-    const stage = memory.stageExclude({} as any)
-
-    const isRemovable = (el: Elem) =>
-      !(
-        boundaries.has(el)
-        || memory.explicits.has(el)
-        || tree.hasInOut(el)
-        || tree.root.has(el)
-      )
-
-    const singleRoot = only([...tree.root])
-    if (singleRoot && !memory.explicits.has(singleRoot)) {
-      stage.exclude(singleRoot)
-    }
-
-    for (const el of memory.final) {
-      const singleChild = only(tree.children(el))
-      if (singleChild && !tree.hasInOut(singleChild) && isRemovable(el)) {
-        stage.exclude(el)
-      }
-    }
-
-    if (stage.isDirty()) {
-      return stage.commit()
-    }
-    return memory
-  }
-
-  // TODO: Lot of corner cases to cover, skip for now
-  // public step3FlatNodes(memory: Memory): Memory {
-  //   // final implicits
-  //   const explicits = new Set<Elem>([
-  //     ...memory.explicits,
-  //     ...memory.connections.flatMap(c => [c.source, c.target]),
-  //   ])
-  //   const sorted = sortParentsFirst(toArray(memory.final))
-
-  //   const toplevel = new Set<Elem>(sorted)
-  //   const children = sorted.reduce((acc, el, index, all) => {
-  //     acc.set(
-  //       el,
-  //       new Set(
-  //         all
-  //           .slice(index + 1)
-  //           .filter(e => isAncestor(el, e))
-  //           .reduce((acc, el) => {
-  //             if (!acc.some(e => isAncestor(e, el))) {
-  //               toplevel.delete(el)
-  //               acc.push(el)
-  //             }
-  //             return acc
-  //           }, [] as Elem[]),
-  //       ),
-  //     )
-  //     return acc
-  //   }, new DefaultMap<Elem, Set<Elem>>(() => new Set()))
-
-  //   const state = memory.mutableState()
-
-  //   function flattenNode(node: Elem) {
-  //     const _children = [...children.get(node)]
-  //     if (_children.length > 1) {
-  //       for (const child of _children) {
-  //         flattenNode(child)
-  //       }
-  //       return !explicits.has(node)
-  //     }
-  //     if (hasAtLeast(_children, 1)) {
-  //       if (flattenNode(_children[0])) {
-  //         state.final.delete(_children[0])
-  //       }
-  //     }
-  //     return !explicits.has(node)
-  //   }
-
-  //   const root = [...toplevel]
-  //   for (const node of root) {
-  //     flattenNode(node)
-  //     if (!explicits.has(node) && children.get(node).size === 1) {
-  //       state.final.delete(node)
-  //     }
-  //   }
-  //   if (root.length === 1 && !explicits.has(root[0]!)) {
-  //     state.final.delete(root[0]!)
-  //   }
-
-  //   return memory.update(state)
-  // }
-
-  public commit(): Memory {
-    // return []
-    const step1 = this.step1CleanConnections(this.memory)
-    const step2 = this.step2ProcessImplicits(step1)
-    return this.step3ProcessBoundaries(step2)
-    // return step2memory
-    // const step3m?emory = this.step3FlatNodes(step2memory)
-    // return step3memory
-  }
-}

package/src/compute-view/deployment-view/stages/stage-include.ts

@@ -1,95 +0,0 @@
-import { dropWhile, forEach, pipe, take, zip } from 'remeda'
-import { isIterable } from '../../../utils'
-import { toArray } from '../../../utils/iterable'
-import { type CtxConnection, type CtxElement, AbstractStageInclude } from '../../memory'
-import { cleanCrossBoundary, cleanRedundantRelationships } from '../clean-connections'
-import { type Ctx } from '../memory/memory'
-import { findConnection, findConnectionsBetween } from '../utils'
-
-type Elem = CtxElement<Ctx>
-type Connection = CtxConnection<Ctx>
-
-export class StageInclude extends AbstractStageInclude<Ctx> {
-  /**
-   * Connects elements with existing ones in the memory
-   */
-  public override connectWithExisting(
-    elements: Elem | Iterable<Elem>,
-    direction: 'in' | 'out' | 'both' = 'both',
-  ): boolean {
-    const before = this._connections.length
-    const hasChanged = () => this._connections.length > before
-    if (!isIterable(elements)) {
-      if (direction === 'in' || direction === 'both') {
-        for (const el of this.memory.elements) {
-          this.addConnections(
-            findConnection(el, elements, 'directed'),
-          )
-        }
-      }
-      if (direction === 'out' || direction === 'both') {
-        this.addConnections(
-          findConnectionsBetween(elements, this.memory.elements, 'directed'),
-        )
-      }
-      return hasChanged()
-    }
-
-    const targets = [...elements]
-    if (direction === 'in' || direction === 'both') {
-      for (const el of this.memory.elements) {
-        this.addConnections(
-          findConnectionsBetween(el, targets, 'directed'),
-        )
-      }
-    }
-    if (direction === 'out' || direction === 'both') {
-      for (const el of targets) {
-        this.addConnections(
-          findConnectionsBetween(el, this.memory.elements, 'directed'),
-        )
-      }
-    }
-    return hasChanged()
-  }
-
-  protected override processConnections(connections: Connection[]) {
-    const clean = pipe(
-      connections,
-      cleanCrossBoundary,
-      cleanRedundantRelationships,
-    )
-
-    pipe(
-      clean,
-      // Process only connection from this stage
-      // filter(c => this._connections.some(c2 => c2.id === c.id)),
-      forEach(({ source, target, boundary }) => {
-        pipe(
-          zip(
-            [...toArray(source.ancestors()).reverse(), source],
-            [...toArray(target.ancestors()).reverse(), target],
-          ),
-          // Filter out common ancestors
-          dropWhile(([sourceAncestor, targetAncestor]) => sourceAncestor === targetAncestor),
-          take(1),
-          forEach(([sourceAncestor, targetAncestor]) => {
-            if (source === sourceAncestor && target === targetAncestor) {
-              this.addImplicit(boundary)
-              return
-            }
-            if (sourceAncestor !== source && sourceAncestor.isDeploymentNode() && !sourceAncestor.onlyOneInstance()) {
-              // state.final.add(source)
-              this.addImplicit(sourceAncestor)
-            }
-            if (targetAncestor !== target && targetAncestor.isDeploymentNode() && !targetAncestor.onlyOneInstance()) {
-              // state.final.add(source)
-              this.addImplicit(targetAncestor)
-            }
-          }),
-        )
-      }),
-    )
-    return clean
-  }
-}

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

@@ -1,286 +0,0 @@
-import { hasAtLeast, isEmpty, unique } from 'remeda'
-import type {
-  DeployedInstanceModel,
-  DeploymentConnectionModel,
-  DeploymentElementModel,
-  DeploymentNodeModel,
-  ElementModel,
-  LikeC4DeploymentModel,
-} from '../../model'
-import { deploymentConnection } from '../../model'
-import {
-  type AnyAux,
-  type aux,
-  type ComputedEdge,
-  type ComputedNode,
-  type DeploymentViewRule,
-  type scalar,
-  type Unknown,
-  DefaultArrowType,
-  FqnExpr,
-  isViewRuleStyle,
-} from '../../types'
-import { invariant, nameFromFqn, nonexhaustive, parentFqn } from '../../utils'
-import { applyViewRuleStyle } from '../utils/applyViewRuleStyles'
-import { type ComputedNodeSource, buildComputedNodes } from '../utils/buildComputedNodes'
-import { mergePropsFromRelationships } from '../utils/merge-props-from-relationships'
-import type { Memory } from './_types'
-
-export const { findConnection, findConnectionsBetween, findConnectionsWithin } = deploymentConnection
-
-type Predicate<T> = (x: T) => boolean
-
-export function resolveElements<A extends AnyAux>(
-  model: LikeC4DeploymentModel<A>,
-  expr: FqnExpr.DeploymentRef<A>,
-): DeploymentElementModel<A>[] {
-  const ref = model.element(expr.ref.deployment)
-  if (ref.isDeploymentNode()) {
-    if (expr.selector === 'children') {
-      return [...ref.children()]
-    }
-    if (expr.selector === 'expanded') {
-      return [ref, ...ref.children()]
-    }
-    if (expr.selector === 'descendants') {
-      return [...ref.descendants()]
-    }
-  }
-  return [ref]
-}
-
-export function resolveModelElements<A extends AnyAux>(
-  model: LikeC4DeploymentModel<A>,
-  expr: FqnExpr.ModelRef<A>,
-): ElementModel<A>[] {
-  const ref = model.$model.element(expr.ref.model)
-  if (expr.selector === 'children') {
-    return [...ref.children()]
-  }
-  if (expr.selector === 'expanded') {
-    return [ref, ...ref.children()]
-  }
-  if (expr.selector === 'descendants') {
-    return [...ref.descendants()]
-  }
-  return [ref]
-}
-
-export function deploymentExpressionToPredicate<
-  A extends AnyAux,
-  N extends { id: string | aux.DeploymentFqn<A>; modelRef?: aux.Fqn<A> | undefined },
->(
-  target: FqnExpr<A>,
-): Predicate<N> {
-  if (FqnExpr.isWildcard(target)) {
-    return () => true
-  }
-  if (FqnExpr.isElementTagExpr(target) || FqnExpr.isElementKindExpr(target)) {
-    throw new Error('element kind and tag expressions are not supported in deployment view rules')
-  }
-  if (FqnExpr.isDeploymentRef(target)) {
-    const fqn = target.ref.deployment
-    if (target.selector === 'expanded') {
-      const fqnWithDot = fqn + '.'
-      return n => n.id === fqn || n.id.startsWith(fqnWithDot)
-    }
-    if (target.selector === 'descendants') {
-      const fqnWithDot = fqn + '.'
-      return n => n.id.startsWith(fqnWithDot)
-    }
-    if (target.selector === 'children') {
-      return n => parentFqn(n.id) === fqn
-    }
-    return n => n.id === fqn
-  }
-  if (FqnExpr.isModelRef(target)) {
-    const fqn = target.ref.model
-    if (target.selector === 'expanded') {
-      const fqnWithDot = fqn + '.'
-      return (n: N) => {
-        const m = n.modelRef ?? null
-        if (!m) {
-          return true
-        }
-        return m === fqn || m.startsWith(fqnWithDot)
-      }
-    }
-    if (target.selector === 'descendants') {
-      const fqnWithDot = fqn + '.'
-      return (n: N) => {
-        const m = n.modelRef ?? null
-        if (!m) {
-          return true
-        }
-        return m.startsWith(fqnWithDot)
-      }
-    }
-    if (target.selector === 'children') {
-      return (n: N) => {
-        const m = n.modelRef ?? null
-        if (!m) {
-          return true
-        }
-        return parentFqn(m) === fqn
-      }
-    }
-    return (n: N) => {
-      const m = n.modelRef ?? null
-      if (!m) {
-        return true
-      }
-      return m === fqn
-    }
-  }
-  nonexhaustive(target)
-}
-
-export function toNodeSource<A extends AnyAux>(
-  el: DeploymentNodeModel<A> | DeployedInstanceModel<A>,
-): ComputedNodeSource<A> {
-  if (el.isDeploymentNode()) {
-    const onlyOneInstance = el.onlyOneInstance()
-    let { title, kind, id, description, ...$node } = el.$node
-    const { icon, color, shape, ...style } = el.$node.style ?? {}
-    let tags = [...el.tags]
-    // let description
-    // If there is only one instance
-    if (onlyOneInstance) {
-      tags = unique([...tags, ...onlyOneInstance.tags])
-      // If title was not overriden, take title from the instance
-      if (title === nameFromFqn(el.id)) {
-        title = onlyOneInstance.title
-      }
-      description = onlyOneInstance.description.$source ?? description
-    }
-
-    return {
-      ...(onlyOneInstance && {
-        ...toNodeSource(onlyOneInstance),
-        modelRef: onlyOneInstance.element.id,
-      }),
-      title,
-      ...$node,
-      ...(icon && { icon }),
-      ...(color && { color }),
-      ...(shape && { shape }),
-      ...(description && { description }),
-      tags,
-      style: {
-        ...style,
-      },
-      deploymentRef: id,
-      kind,
-      id: id as scalar.NodeId,
-    }
-  }
-  invariant(el.isInstance(), 'Expected Instance')
-  const instance = el.$instance
-  const element = el.element
-  const { icon, color, shape, ...style } = el.style
-
-  const links = [
-    ...element.links,
-    ...(instance.links ?? []),
-  ]
-
-  const metadata = {
-    ...element.getMetadata(),
-    ...instance.metadata,
-  }
-
-  const notation = instance.notation ?? element.$element.notation
-
-  let description = el.description.$source
-  let technology = instance.technology ?? element.technology
-
-  return {
-    id: el.id as scalar.NodeId,
-    kind: 'instance' as unknown as aux.DeploymentKind<A>,
-    title: el.title,
-    ...(description && { description }),
-    ...(technology && { technology }),
-    tags: [...el.tags],
-    links: hasAtLeast(links, 1) ? links : null,
-    ...icon && { icon },
-    ...color && { color },
-    ...shape && { shape },
-    style,
-    deploymentRef: instance.id,
-    modelRef: element.id,
-    ...notation && { notation },
-    ...!isEmpty(metadata) && ({ metadata }),
-  }
-}
-
-export function toComputedEdges<A extends AnyAux>(
-  connections: ReadonlyArray<DeploymentConnectionModel<A>>,
-): ComputedEdge<A>[] {
-  return connections.reduce((acc, e) => {
-    // const modelRelations = []
-    // const deploymentRelations = []
-    const relations = [
-      ...e.relations.model,
-      ...e.relations.deployment,
-    ]
-    invariant(hasAtLeast(relations, 1), 'Edge must have at least one relation')
-
-    const source = e.source.id as scalar.NodeId
-    const target = e.target.id as scalar.NodeId
-
-    const {
-      title,
-      ...props
-    } = mergePropsFromRelationships(relations.map(r => r.$relationship)) // || relations.find(r => r.source === source && r.target === target)
-
-    const edge: ComputedEdge<A> = {
-      id: e.id,
-      parent: e.boundary?.id as scalar.NodeId ?? null,
-      source,
-      target,
-      label: title ?? null,
-      relations: relations.map((r) => r.id),
-      ...props,
-    }
-
-    // If exists same edge but in opposite direction
-    const existing = acc.find(e => e.source === target && e.target === source)
-    if (existing && edge.label === existing.label) {
-      existing.dir = 'both'
-      const head = existing.head ?? edge.head ?? DefaultArrowType
-      existing.head ??= head
-      existing.tail ??= head
-
-      if (edge.color) {
-        existing.color ??= edge.color
-      }
-      if (edge.line) {
-        existing.line ??= edge.line
-      }
-      return acc
-    }
-
-    acc.push(edge)
-    return acc
-  }, [] as ComputedEdge<A>[])
-}
-
-export function buildNodes<A extends AnyAux = Unknown>(
-  memory: Memory,
-): ReadonlyMap<aux.NodeId, ComputedNode<A>> {
-  return buildComputedNodes([...memory.final].map(toNodeSource))
-}
-
-export function applyDeploymentViewRuleStyles<A extends AnyAux>(
-  rules: DeploymentViewRule<A>[],
-  nodes: ComputedNode<A>[],
-): ComputedNode<A>[] {
-  for (const rule of rules) {
-    if (!isViewRuleStyle(rule) || rule.targets.length === 0) {
-      continue
-    }
-    const predicates = rule.targets.map(deploymentExpressionToPredicate)
-    applyViewRuleStyle(rule, predicates, nodes)
-  }
-  return nodes
-}