@likec4/core 1.17.1 → 1.19.0

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

@@ -0,0 +1,43 @@
+import DefaultMap from 'mnemonist/default-map'
+import { Connection } from '../../model'
+import { isAncestor, sortParentsFirst } from '../../utils'
+import { toArray } from '../../utils/iterable'
+import type { AnyCtx, ComputeMemory, CtxElement } from './_types'
+
+export function treeFromMemoryState<T extends AnyCtx, M extends ComputeMemory<T> = ComputeMemory<T>>(
+  memory: M,
+  filter: 'all' | 'final' = 'final',
+) {
+  const sorted = sortParentsFirst(toArray(filter === 'final' ? memory.final : memory.elements))
+  const connected = new Set(memory.connections.flatMap(c => [c.source, c.target]))
+  const root = new Set(sorted)
+  const parents = new DefaultMap<CtxElement<T>, CtxElement<T> | null>(() => null)
+  const children = sorted.reduce((acc, parent, index, all) => {
+    acc.set(
+      parent,
+      all
+        .slice(index + 1)
+        .filter(e => isAncestor(parent, e))
+        .map(e => {
+          root.delete(e)
+          return e
+        })
+        .reduce((acc, el) => {
+          if (!acc.some(e => isAncestor(e, el))) {
+            acc.push(el)
+            parents.set(el, parent)
+          }
+          return acc
+        }, [] as CtxElement<T>[]),
+    )
+    return acc
+  }, new DefaultMap<CtxElement<T>, ReadonlyArray<CtxElement<T>>>(() => []))
+
+  return {
+    root: root as ReadonlySet<CtxElement<T>>,
+    connected: connected as ReadonlySet<CtxElement<T>>,
+    hasInOut: (el: CtxElement<T>) => memory.connections.some(Connection.isAnyInOut(el.id)),
+    parents: (el: CtxElement<T>) => children.get(el),
+    children: (el: CtxElement<T>) => children.get(el),
+  }
+}

package/src/compute-view/utils/__snapshots__/sortNodes.spec.ts.snap

@@ -0,0 +1,113 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`sortNodes > should generate valid testnodes 1`] = `
+{
+  "edges": [
+    {
+      "id": "cloud.frontend.ui:cloud.backend",
+      "parent": "cloud",
+      "source": "cloud.frontend.ui",
+      "target": "cloud.backend",
+    },
+    {
+      "id": "cloud.backend:cloud.db",
+      "parent": "cloud",
+      "source": "cloud.backend",
+      "target": "cloud.db",
+    },
+    {
+      "id": "cloud.db:amazon",
+      "parent": null,
+      "source": "cloud.db",
+      "target": "amazon",
+    },
+    {
+      "id": "customer:cloud.frontend.ui",
+      "parent": null,
+      "source": "customer",
+      "target": "cloud.frontend.ui",
+    },
+  ],
+  "nodes": [
+    {
+      "children": [],
+      "id": "customer",
+      "inEdges": [],
+      "outEdges": [
+        "customer:cloud.frontend.ui",
+      ],
+      "parent": null,
+    },
+    {
+      "children": [],
+      "id": "amazon",
+      "inEdges": [
+        "cloud.db:amazon",
+      ],
+      "outEdges": [],
+      "parent": null,
+    },
+    {
+      "children": [
+        "cloud.frontend.ui",
+      ],
+      "id": "cloud.frontend",
+      "inEdges": [
+        "customer:cloud.frontend.ui",
+      ],
+      "outEdges": [
+        "cloud.frontend.ui:cloud.backend",
+      ],
+      "parent": "cloud",
+    },
+    {
+      "children": [],
+      "id": "cloud.frontend.ui",
+      "inEdges": [
+        "customer:cloud.frontend.ui",
+      ],
+      "outEdges": [
+        "cloud.frontend.ui:cloud.backend",
+      ],
+      "parent": "cloud.frontend",
+    },
+    {
+      "children": [
+        "cloud.frontend",
+        "cloud.db",
+        "cloud.backend",
+      ],
+      "id": "cloud",
+      "inEdges": [
+        "customer:cloud.frontend.ui",
+      ],
+      "outEdges": [
+        "cloud.db:amazon",
+      ],
+      "parent": null,
+    },
+    {
+      "children": [],
+      "id": "cloud.db",
+      "inEdges": [
+        "cloud.backend:cloud.db",
+      ],
+      "outEdges": [
+        "cloud.db:amazon",
+      ],
+      "parent": "cloud",
+    },
+    {
+      "children": [],
+      "id": "cloud.backend",
+      "inEdges": [
+        "cloud.frontend.ui:cloud.backend",
+      ],
+      "outEdges": [
+        "cloud.backend:cloud.db",
+      ],
+      "parent": "cloud",
+    },
+  ],
+}
+`;

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

@@ -0,0 +1,19 @@
+import { nonNullable } from '../../errors'
+import type { ComputedNode, Fqn } from '../../types'
+
+/**
+ * Returns the ancestors of given computed node, starting with the direct parent and ending with the root node.
+ */
+export function ancestorsOfNode(
+  node: ComputedNode,
+  nodes: ReadonlyMap<Fqn, ComputedNode>
+): ReadonlyArray<ComputedNode> {
+  const ancestors = [] as ComputedNode[]
+  let parentId = node.parent
+  while (parentId) {
+    const parentNode = nonNullable(nodes.get(parentId), `Parent node ${parentId} not found`)
+    ancestors.push(parentNode)
+    parentId = parentNode.parent
+  }
+  return ancestors
+}

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

@@ -0,0 +1,66 @@
+import { isEmpty, isNullish, omitBy } from 'remeda'
+import { ComputedNode, isCustomElement, isViewRuleGroup, isViewRulePredicate, type ViewRule } from '../../types'
+import type { Expression } from '../../types/expression'
+import { elementExprToPredicate } from './elementExpressionToPredicate'
+
+export function flattenGroupRules<T extends Expression>(guard: (expr: Expression) => expr is T) {
+  return (rule: ViewRule): Array<T> => {
+    if (isViewRuleGroup(rule)) {
+      return rule.groupRules.flatMap(flattenGroupRules(guard))
+    }
+    if (isViewRulePredicate(rule)) {
+      return 'include' in rule ? rule.include.filter(guard) : []
+    }
+
+    return []
+  }
+}
+
+export function applyCustomElementProperties(_rules: ViewRule[], _nodes: ComputedNode[]) {
+  const rules = _rules.flatMap(flattenGroupRules(isCustomElement))
+  if (rules.length === 0) {
+    return _nodes
+  }
+  const nodes = [..._nodes]
+  for (
+    const {
+      custom: { expr, ...props }
+    } of rules
+  ) {
+    const { border, opacity, ...rest } = omitBy(props, isNullish)
+    const notEmpty = !isEmpty(rest)
+    const satisfies = elementExprToPredicate(expr)
+    nodes.forEach((node, i) => {
+      if (ComputedNode.isNodesGroup(node) || !satisfies(node)) {
+        return
+      }
+      if (notEmpty) {
+        node = {
+          ...node,
+          isCustomized: true,
+          ...rest
+        }
+      }
+
+      let styleOverride: ComputedNode['style'] | undefined
+      if (border !== undefined) {
+        styleOverride = { border }
+      }
+      if (opacity !== undefined) {
+        styleOverride = { ...styleOverride, opacity }
+      }
+      if (styleOverride) {
+        node = {
+          ...node,
+          isCustomized: true,
+          style: {
+            ...node.style,
+            ...styleOverride
+          }
+        }
+      }
+      nodes[i] = node
+    })
+  }
+  return nodes
+}

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

@@ -0,0 +1,41 @@
+import { isNullish, omitBy, pick } from 'remeda'
+import type { ComputedEdge, ComputedNode, ViewRule } from '../../types'
+import * as Expr from '../../types/expression'
+import { flattenGroupRules } from './applyCustomElementProperties'
+import { relationExpressionToPredicates } from './relationExpressionToPredicates'
+
+export function applyCustomRelationProperties(
+  _rules: ViewRule[],
+  nodes: ComputedNode[],
+  _edges: Iterable<ComputedEdge>
+): ComputedEdge[] {
+  const rules = _rules.flatMap(flattenGroupRules(Expr.isCustomRelationExpr))
+  const edges = Array.from(_edges)
+  if (rules.length === 0 || edges.length === 0) {
+    return edges
+  }
+  for (
+    const {
+      customRelation: { relation, title, ...customprops }
+    } of rules
+  ) {
+    const props = omitBy(customprops, isNullish)
+    const satisfies = relationExpressionToPredicates(relation)
+    edges.forEach((edge, i) => {
+      const source = nodes.find(n => n.id === edge.source)
+      const target = nodes.find(n => n.id === edge.target)
+      if (!source || !target) {
+        return
+      }
+      if (satisfies({ source, target, ...pick(edge, ['kind', 'tags']) })) {
+        edges[i] = {
+          ...edge,
+          ...props,
+          label: title ?? edge.label,
+          isCustomized: true
+        }
+      }
+    })
+  }
+  return edges
+}

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

@@ -0,0 +1,53 @@
+import { anyPass, filter, forEach, isDefined, isNot, pipe } from 'remeda'
+import { ComputedNode, isViewRuleStyle, type ViewRule, type ViewRuleStyle } from '../../types'
+import { elementExprToPredicate } from './elementExpressionToPredicate'
+
+type Predicate<T> = (x: T) => boolean
+
+type CommonViewRuleStyle = Pick<ViewRuleStyle, 'style' | 'notation'>
+
+export function applyViewRuleStyle<Rule extends CommonViewRuleStyle>(
+  rule: Rule,
+  predicates: Predicate<ComputedNode>[],
+  nodes: ComputedNode[]
+) {
+  pipe(
+    nodes,
+    filter(isNot(ComputedNode.isNodesGroup)),
+    filter(anyPass(predicates)),
+    forEach(n => {
+      n.shape = rule.style.shape ?? n.shape
+      n.color = rule.style.color ?? n.color
+      if (isDefined(rule.style.icon)) {
+        n.icon = rule.style.icon
+      }
+      if (isDefined(rule.notation)) {
+        n.notation = rule.notation
+      }
+      let styleOverride: ComputedNode['style'] | undefined
+      if (isDefined(rule.style.border)) {
+        styleOverride = { border: rule.style.border }
+      }
+      if (isDefined(rule.style.opacity)) {
+        styleOverride = { ...styleOverride, opacity: rule.style.opacity }
+      }
+      if (styleOverride) {
+        n.style = {
+          ...n.style,
+          ...styleOverride
+        }
+      }
+    })
+  )
+}
+
+export function applyViewRuleStyles(rules: ViewRule[], nodes: ComputedNode[]) {
+  for (const rule of rules) {
+    if (!isViewRuleStyle(rule) || rule.targets.length === 0) {
+      continue
+    }
+    const predicates = rule.targets.map(elementExprToPredicate)
+    applyViewRuleStyle(rule, predicates, nodes)
+  }
+  return nodes
+}

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

@@ -0,0 +1,148 @@
+import type { Simplify } from 'type-fest'
+import { nonNullable } from '../../errors'
+import {
+  type ComputedNode,
+  DefaultElementShape,
+  DefaultThemeColor,
+  type Element,
+  ElementKind,
+  type Fqn,
+  type NodeId
+} from '../../types'
+import { compareByFqnHierarchically, parentFqn } from '../../utils/fqn'
+import { NodesGroup } from '../element-view/memory'
+
+function updateDepthOfAncestors(node: ComputedNode, nodes: ReadonlyMap<Fqn, ComputedNode>) {
+  let parentNd
+  while (!!node.parent && (parentNd = nodes.get(node.parent))) {
+    const depth = parentNd.depth ?? 1
+    parentNd.depth = Math.max(depth, (node.depth ?? 0) + 1)
+    if (parentNd.depth === depth) {
+      // stop if we didn't change depth
+      break
+    }
+    node = parentNd
+  }
+}
+
+const modelElementAsNodeSource = (element: Element): ComputedNodeSource => {
+  return {
+    ...element,
+    modelRef: 1
+  }
+}
+
+// type ComputedNodeSource = Simplify<SetRequired<Partial<Omit<ComputedNode, 'parent' | 'children' | 'inEdges' | 'outEdges' | 'level' | 'depth'>>, 'id' | 'title' | 'kind'>>
+export type ComputedNodeSource = Simplify<
+  & Pick<ComputedNode, 'id' | 'title' | 'kind' | 'deploymentRef' | 'modelRef'>
+  & Partial<Omit<Element, 'id' | 'title' | 'kind'>>
+>
+
+export function buildComputedNodesFromElements(elements: ReadonlyArray<Element>, groups?: NodesGroup[]) {
+  return buildComputedNodes(elements.map(modelElementAsNodeSource), groups)
+}
+
+export function buildComputedNodes(
+  elements: ReadonlyArray<ComputedNodeSource>,
+  groups?: ReadonlyArray<NodesGroup>
+): ReadonlyMap<Fqn, ComputedNode> {
+  const nodesMap = new Map<Fqn, ComputedNode>()
+
+  const elementToGroup = new Map<Fqn, NodeId>()
+
+  groups?.forEach(({ id, parent, viewRule, elements }) => {
+    if (parent) {
+      nonNullable(nodesMap.get(parent), `Parent group node ${parent} not found`).children.push(id)
+    }
+    nodesMap.set(id, {
+      id,
+      parent,
+      kind: ElementKind.Group,
+      title: viewRule.title ?? '',
+      color: viewRule.color ?? 'muted',
+      shape: 'rectangle',
+      children: [],
+      inEdges: [],
+      outEdges: [],
+      level: 0,
+      depth: 0,
+      description: null,
+      technology: null,
+      tags: null,
+      links: null,
+      style: {
+        border: viewRule.border ?? 'dashed',
+        opacity: viewRule.opacity ?? 0
+      }
+    })
+    for (const e of elements) {
+      elementToGroup.set(e.id, id)
+    }
+  })
+
+  // Ensure that parent nodes are created before child nodes
+  Array.from(elements)
+    .sort(compareByFqnHierarchically)
+    .forEach(({ id, style, kind, title, color, shape, ...el }) => {
+      let parent = parentFqn(id)
+      let level = 0
+      let parentNd: ComputedNode | undefined
+      // Find the first ancestor that is already in the map
+      while (parent) {
+        parentNd = nodesMap.get(parent)
+        if (parentNd) {
+          break
+        }
+        parent = parentFqn(parent)
+      }
+      // If parent is not found in the map, check if it is in a group
+      if (!parentNd && elementToGroup.has(id)) {
+        parent = elementToGroup.get(id)!
+        parentNd = nodesMap.get(parent)!
+      }
+      if (parentNd) {
+        // if parent has no children and we are about to add first one
+        // we need to set its depth to 1
+        if (parentNd.children.length == 0) {
+          parentNd.depth = 1
+          // go up the tree and update depth of all parents
+          updateDepthOfAncestors(parentNd, nodesMap)
+        }
+        parentNd.children.push(id)
+        level = parentNd.level + 1
+      }
+      const node: ComputedNode = {
+        id,
+        parent,
+        kind,
+        title,
+        level,
+        color: color ?? DefaultThemeColor,
+        shape: shape ?? DefaultElementShape,
+        description: null,
+        technology: null,
+        tags: null,
+        links: null,
+        children: [],
+        inEdges: [],
+        outEdges: [],
+        ...el,
+        style: {
+          ...style
+        }
+      }
+      nodesMap.set(id, node)
+    })
+
+  // Create new map and add elements in the same order as they were in the input
+  const orderedMap = new Map<Fqn, ComputedNode>()
+
+  groups?.forEach(({ id }) => {
+    orderedMap.set(id, nonNullable(nodesMap.get(id)))
+  })
+  elements.forEach(({ id }) => {
+    orderedMap.set(id, nonNullable(nodesMap.get(id)))
+  })
+
+  return orderedMap
+}

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

@@ -0,0 +1,63 @@
+import { entries, flatMap, groupBy, map, mapValues, pipe, piped, prop, sortBy, unique } from 'remeda'
+import type { ComputedNode, ElementNotation } from '../../types'
+
+/**
+ * Build element notations from computed nodes:
+ * 1. Group by notation
+ * 2. Group by shape
+ * 3. Group by color
+ * 4. For each group get unique kinds
+ * 5. Unwind the groups
+ */
+export function buildElementNotations(nodes: ComputedNode[]): ElementNotation[] {
+  return pipe(
+    nodes,
+    groupBy(prop('notation')),
+    mapValues(
+      piped(
+        groupBy(prop('shape')),
+        mapValues(
+          piped(
+            groupBy(prop('color')),
+            mapValues(
+              piped(
+                map(prop('kind')),
+                unique()
+              )
+            ),
+            entries(),
+            map(([color, kinds]) => ({
+              kinds,
+              color
+            }))
+          )
+        ),
+        entries(),
+        flatMap(([shape, colors]) =>
+          colors.map(({ color, kinds }) => ({
+            shape,
+            color,
+            kinds
+          }))
+        )
+      )
+    ),
+    entries(),
+    flatMap(([title, shapes]) =>
+      shapes.map(({ shape, color, kinds }) => ({
+        title,
+        shape,
+        color,
+        kinds
+      }))
+    ),
+    sortBy(
+      prop('shape'),
+      prop('title'),
+      [
+        n => n.kinds.length,
+        'desc'
+      ]
+    )
+  )
+}

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

@@ -0,0 +1,50 @@
+import { isNullish } from 'remeda'
+import { nonexhaustive } from '../../errors'
+import {
+  type ElementPredicateExpression,
+  isCustomElement,
+  isElementKindExpr,
+  isElementRef,
+  isElementTagExpr,
+  isElementWhere,
+  isExpandedElementExpr,
+  isWildcard,
+  whereOperatorAsPredicate
+} from '../../types'
+import { parentFqn } from '../../utils'
+
+type Predicate<T> = (x: T) => boolean
+
+export function elementExprToPredicate<T extends { id: string; tags?: readonly string[] | null; kind: string }>(
+  target: ElementPredicateExpression
+): Predicate<T> {
+  if (isElementWhere(target)) {
+    const predicate = elementExprToPredicate(target.where.expr)
+    const where = whereOperatorAsPredicate(target.where.condition)
+    return n => predicate(n) && where(n)
+  }
+  if (isWildcard(target)) {
+    return () => true
+  }
+  if (isElementKindExpr(target)) {
+    return target.isEqual ? n => n.kind === target.elementKind : n => n.kind !== target.elementKind
+  }
+  if (isElementTagExpr(target)) {
+    return target.isEqual
+      ? ({ tags }) => !!tags && tags.includes(target.elementTag)
+      : ({ tags }) => isNullish(tags) || !tags.includes(target.elementTag)
+  }
+  if (isExpandedElementExpr(target)) {
+    return n => n.id === target.expanded || parentFqn(n.id) === target.expanded
+  }
+  if (isElementRef(target)) {
+    const { element, isChildren, isDescendants } = target
+    return isChildren || isDescendants
+      ? n => n.id.startsWith(element + '.')
+      : n => (n.id as string) === element
+  }
+  if (isCustomElement(target)) {
+    return elementExprToPredicate(target.custom.expr)
+  }
+  nonexhaustive(target)
+}

package/src/compute-view/utils/link-nodes-with-edges.ts

@@ -0,0 +1,54 @@
+import { last, reverse } from 'remeda'
+import { invariant } from '../../errors'
+import type { Fqn } from '../../types/element'
+import type { ComputedEdge, ComputedNode } from '../../types/view'
+import { commonHead } from '../../utils/common-head'
+import { ancestorsOfNode } from './ancestorsOfNode'
+
+/**
+ * Update `inEdges` and `outEdges` props of nodes based on the edges
+ * Mutates nodes and updates their in/out edges
+ */
+export function linkNodesWithEdges(nodesMap: ReadonlyMap<Fqn, ComputedNode>, edges: ComputedEdge[]) {
+  for (const edge of edges) {
+    const source = nodesMap.get(edge.source)
+    const target = nodesMap.get(edge.target)
+    invariant(source, `Source node ${edge.source} not found`)
+    invariant(target, `Target node ${edge.target} not found`)
+
+    source.outEdges.push(edge.id)
+    target.inEdges.push(edge.id)
+
+    // These ancestors are reversed: from bottom to top
+    // Ensure that ancestors are in computed nodes
+    const sourceAncestors = ancestorsOfNode(source, nodesMap)
+    const targetAncestors = ancestorsOfNode(target, nodesMap)
+
+    const hasAncestors = sourceAncestors.length > 0 && targetAncestors.length > 0
+
+    const edgeParent = hasAncestors
+      ? last(
+        commonHead(
+          reverse(sourceAncestors),
+          reverse(targetAncestors),
+        ),
+      )
+      : null
+    edge.parent = edgeParent ? edgeParent.id : null
+
+    // Process edge source ancestors
+    for (const sourceAncestor of sourceAncestors) {
+      if (sourceAncestor === edgeParent) {
+        break
+      }
+      sourceAncestor.outEdges.push(edge.id)
+    }
+    // Process target hierarchy
+    for (const targetAncestor of targetAncestors) {
+      if (targetAncestor === edgeParent) {
+        break
+      }
+      targetAncestor.inEdges.push(edge.id)
+    }
+  }
+}