@likec4/core 1.17.1 → 1.18.0

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/compute'
+
+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?: NodesGroup[]
+): ReadonlyMap<Fqn, ComputedNode> {
+  const nodesMap = new Map<Fqn, ComputedNode>()
+
+  const elementToGroup = new Map<Fqn, NodeId>()
+
+  groups?.forEach(({ id, parent, viewRule, explicits }) => {
+    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 explicits) {
+      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/derive-edge-props-from-relationships.ts

@@ -0,0 +1,97 @@
+import { isTruthy, only, pick, pickBy, pipe, reduce, unique } from 'remeda'
+import type { Color, DeploymentRelation, Link, Tag, ViewId } from '../../types'
+import type { Relation, RelationshipArrowType, RelationshipKind, RelationshipLineType } from '../../types/relation'
+import { isNonEmptyArray } from '../../utils'
+
+export function pickRelationshipProps(relation: Relation | DeploymentRelation) {
+  return pick(relation, [
+    'title',
+    'description',
+    'technology',
+    'tags',
+    'links',
+    'kind',
+    'color',
+    'line',
+    'head',
+    'tail',
+    'navigateTo'
+  ])
+}
+type RelationshipProps = ReturnType<typeof pickRelationshipProps>
+
+export function deriveEdgePropsFromRelationships(relations: Array<Relation | DeploymentRelation>) {
+  // TODO:
+  const allprops = pipe(
+    relations,
+    reduce(
+      (acc, r) => {
+        if (isTruthy(r.title) && !acc.title.includes(r.title)) {
+          acc.title.push(r.title)
+        }
+        if (isTruthy(r.description) && !acc.description.includes(r.description)) {
+          acc.description.push(r.description)
+        }
+        if (isTruthy(r.technology) && !acc.technology.includes(r.technology)) {
+          acc.technology.push(r.technology)
+        }
+        if (isTruthy(r.kind) && !acc.kind.includes(r.kind)) {
+          acc.kind.push(r.kind)
+        }
+        if (isTruthy(r.color) && !acc.color.includes(r.color)) {
+          acc.color.push(r.color)
+        }
+        if (isTruthy(r.line) && !acc.line.includes(r.line)) {
+          acc.line.push(r.line)
+        }
+        if (isTruthy(r.head) && !acc.head.includes(r.head)) {
+          acc.head.push(r.head)
+        }
+        if (isTruthy(r.tail) && !acc.tail.includes(r.tail)) {
+          acc.tail.push(r.tail)
+        }
+        if (isTruthy(r.navigateTo) && !acc.navigateTo.includes(r.navigateTo)) {
+          acc.navigateTo.push(r.navigateTo)
+        }
+        if (r.tags) {
+          acc.tags.push(...r.tags)
+        }
+        if (r.links) {
+          acc.links.push(...r.links)
+        }
+        return acc
+      },
+      {
+        title: [] as string[],
+        description: [] as string[],
+        technology: [] as string[],
+        kind: [] as RelationshipKind[],
+        head: [] as RelationshipArrowType[],
+        tail: [] as RelationshipArrowType[],
+        color: [] as Color[],
+        tags: [] as Tag[],
+        links: [] as Link[],
+        line: [] as RelationshipLineType[],
+        navigateTo: [] as ViewId[]
+      }
+    )
+  )
+  const tags = unique(allprops.tags)
+  return pickBy(
+    {
+      title: only(allprops.title) ?? (allprops.title.length > 1 ? '[...]' : null),
+      description: only(allprops.description),
+      technology: only(allprops.technology),
+      kind: only(allprops.kind),
+      head: only(allprops.head),
+      tail: only(allprops.tail),
+      color: only(allprops.color),
+      line: only(allprops.line),
+      navigateTo: only(allprops.navigateTo),
+      ...isNonEmptyArray(allprops.links) && { links: allprops.links },
+      ...isNonEmptyArray(tags) && { tags }
+    },
+    isTruthy
+  )
+}
+export type MergedRelationshipProps = ReturnType<typeof deriveEdgePropsFromRelationships>

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

@@ -0,0 +1,52 @@
+import { isNullish } from 'remeda'
+import { nonexhaustive } from '../../errors'
+import {
+  type ComputedNode,
+  type Element,
+  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 Pick<ComputedNode, 'id' | 'kind' | 'tags'>>(
+  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,58 @@
+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)
+
+    if (edge.dir === 'both') {
+      source.inEdges.push(edge.id)
+      target.outEdges.push(edge.id)
+    }
+
+    // These ancestors are reversed: from bottom to top
+    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)
+    }
+  }
+}

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

@@ -0,0 +1,55 @@
+import { nonexhaustive } from '../../errors'
+import type { Element } from '../../types/element'
+import {
+  isIncoming,
+  isInOut,
+  isOutgoing,
+  isRelation,
+  isRelationWhere,
+  type RelationExpression,
+  type RelationWhereExpr
+} from '../../types/expression'
+import { whereOperatorAsPredicate } from '../../types/operators'
+import type { Relation } from '../../types/relation'
+import type { ComputedNode } from '../../types/view'
+import { elementExprToPredicate } from './elementExpressionToPredicate'
+
+type Predicate<T> = (x: T) => boolean
+export type FilterableEdge = Pick<Relation, 'kind' | 'tags'> & {
+  source: ComputedNode
+  target: ComputedNode
+}
+
+export function relationExpressionToPredicates<T extends FilterableEdge>(
+  expr: RelationExpression | RelationWhereExpr
+): Predicate<T> {
+  switch (true) {
+    case isRelationWhere(expr): {
+      const predicate = relationExpressionToPredicates(expr.where.expr)
+      const where = whereOperatorAsPredicate(expr.where.condition)
+      return e => predicate(e) && where(e)
+    }
+    case isRelation(expr): {
+      const isSource = elementExprToPredicate(expr.source)
+      const isTarget = elementExprToPredicate(expr.target)
+      return edge => {
+        return (isSource(edge.source) && isTarget(edge.target))
+          || (!!expr.isBidirectional && isSource(edge.target) && isTarget(edge.source))
+      }
+    }
+    case isInOut(expr): {
+      const isInOut = elementExprToPredicate(expr.inout)
+      return edge => isInOut(edge.source) || isInOut(edge.target)
+    }
+    case isIncoming(expr): {
+      const isTarget = elementExprToPredicate(expr.incoming)
+      return edge => isTarget(edge.target)
+    }
+    case isOutgoing(expr): {
+      const isSource = elementExprToPredicate(expr.outgoing)
+      return edge => isSource(edge.source)
+    }
+    default:
+      nonexhaustive(expr)
+  }
+}