@likec4/core 1.17.1 → 1.19.0

package/src/compute-view/utils/merge-props-from-relationships.ts

@@ -0,0 +1,128 @@
+import { isTruthy, only, pickBy, pipe, reduce, unique } from 'remeda'
+import type { Color, DeploymentRelation, Link, Tag, ViewId } from '../../types'
+import type { ModelRelation, RelationshipArrowType, RelationshipKind, RelationshipLineType } from '../../types/relation'
+import { isNonEmptyArray } from '../../utils'
+
+function pickRelationshipProps(relation: ModelRelation | DeploymentRelation) {
+  const {
+    title,
+    description = null,
+    technology = null,
+    kind = null,
+    color = null,
+    line = null,
+    head = null,
+    tail = null,
+    navigateTo = null
+  } = relation
+  return {
+    // Pick description only if title is present
+    ...(title && {
+      title,
+      description
+    }),
+    technology,
+    kind,
+    color,
+    line,
+    head,
+    tail,
+    navigateTo
+  }
+}
+
+/**
+ * Merges properties from multiple relationships into a single object.
+ * @param relations - The relationships to merge.
+ * @param prefer - The relationship to prefer when merging.
+ */
+export function mergePropsFromRelationships(
+  relations: Array<ModelRelation | DeploymentRelation>,
+  prefer?: ModelRelation | DeploymentRelation
+) {
+  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[]
+      }
+    )
+  )
+
+  let technology = only(allprops.technology)
+  let title = only(allprops.title) ?? (allprops.title.length > 1 ? '[...]' : null)
+
+  const tags = unique(allprops.tags)
+  let merged = pickBy(
+    {
+      // If there is no title, but there is technology, use technology as title
+      title: title ?? (technology ? `[${technology}]` : null),
+      description: only(allprops.description),
+      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
+  )
+
+  if (prefer) {
+    return {
+      ...merged,
+      ...pickBy(pickRelationshipProps(prefer), isTruthy)
+    }
+  }
+  return merged
+}
+export type MergedRelationshipProps = ReturnType<typeof mergePropsFromRelationships>

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 { ModelRelation } from '../../types/relation'
+import type { ComputedNode } from '../../types/view'
+import { elementExprToPredicate } from './elementExpressionToPredicate'
+
+type Predicate<T> = (x: T) => boolean
+export type FilterableEdge = Pick<ModelRelation, '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)
+  }
+}

package/src/compute-view/utils/resolve-extended-views.ts

@@ -0,0 +1,69 @@
+import { values } from 'remeda'
+import { type ExtendsElementView, isElementView, isExtendsElementView, type LikeC4View } from '../../types/view'
+
+import Graph from 'graphology'
+import { topologicalSort } from 'graphology-dag/topological-sort'
+import willCreateCycle from 'graphology-dag/will-create-cycle'
+/**
+ * Resolve rules of extended views
+ * (Removes invalid views)
+ */
+export function resolveRulesExtendedViews<V extends Record<any, LikeC4View>>(
+  unresolvedViews: V
+): V {
+  const g = new Graph<{ view: LikeC4View }>({
+    type: 'directed'
+  })
+  const extendedViews = [] as ExtendsElementView<any, any>[]
+  for (const view of values(unresolvedViews)) {
+    g.addNode(view.id, { view })
+    if (isExtendsElementView(view)) {
+      extendedViews.push(view)
+    }
+  }
+
+  if (extendedViews.length === 0) {
+    return unresolvedViews
+  }
+
+  for (const view of extendedViews) {
+    if (!g.hasNode(view.extends)) {
+      console.warn(`View "${view.id}" extends from "${view.extends}" which does not exist`)
+      continue
+    }
+    if (willCreateCycle(g, view.id, view.extends)) {
+      console.warn(`View "${view.id}" extends from "${view.extends}" which creates a cycle`)
+      continue
+    }
+
+    // view -> parent
+    g.addDirectedEdge(view.id, view.extends)
+  }
+
+  const sorted = topologicalSort(g).reverse()
+  return sorted.reduce((acc, id) => {
+    const view = g.getNodeAttribute(id, 'view')
+    if (!isExtendsElementView(view)) {
+      acc[view.id] = view
+      return acc
+    }
+
+    const extendsFrom = acc[view.extends]
+    if (!extendsFrom || !isElementView(extendsFrom)) {
+      return acc
+    }
+
+    acc[view.id] = {
+      ...extendsFrom,
+      ...view,
+      rules: [...extendsFrom.rules, ...view.rules]
+    }
+    return acc
+  }, {} as Record<string, LikeC4View>) as V
+
+  // forEachNodeInTopologicalOrder(g, (_id, { view }) => {
+
+  // })
+
+  // return ordered as V
+}

package/src/compute-view/utils/resolve-global-rules.ts

@@ -0,0 +1,83 @@
+import { isNullish } from 'remeda'
+import { nonexhaustive } from '../../errors'
+import {
+  type DynamicView,
+  type DynamicViewRule,
+  type ElementView,
+  isDynamicView,
+  isElementView,
+  isViewRuleGlobalPredicateRef,
+  isViewRuleGlobalStyle,
+  type ModelGlobals,
+  type ViewRule,
+  type ViewRuleGlobalPredicateRef,
+  type ViewRuleGlobalStyle
+} from '../../types'
+
+export function resolveGlobalRules<V extends DynamicView | ElementView>(
+  view: V,
+  globals: ModelGlobals
+): V {
+  if (isElementView(view)) {
+    return {
+      ...view,
+      rules: resolveGlobalRulesInElementView(view.rules, globals)
+    }
+  } else if (isDynamicView(view)) {
+    return {
+      ...view,
+      rules: resolveGlobalRulesInDynamicView(view.rules, globals)
+    }
+  }
+  nonexhaustive(view)
+}
+
+type ViewRuleGlobal = ViewRuleGlobalPredicateRef | ViewRuleGlobalStyle
+
+export function resolveGlobalRulesInElementView(
+  rules: ViewRule[],
+  globals: ModelGlobals
+): Array<Exclude<ViewRule, ViewRuleGlobal>> {
+  return rules.reduce((acc, rule) => {
+    if (isViewRuleGlobalPredicateRef(rule)) {
+      const globalPredicates = globals.predicates[rule.predicateId]
+      if (isNullish(globalPredicates)) {
+        return acc
+      }
+      return acc.concat(globalPredicates)
+    }
+    if (isViewRuleGlobalStyle(rule)) {
+      const globalStyles = globals.styles[rule.styleId]
+      if (isNullish(globalStyles)) {
+        return acc
+      }
+      return acc.concat(globalStyles)
+    }
+    acc.push(rule)
+    return acc
+  }, [] as Array<Exclude<ViewRule, ViewRuleGlobal>>)
+}
+
+export function resolveGlobalRulesInDynamicView(
+  rules: DynamicViewRule[],
+  globals: ModelGlobals
+): Array<Exclude<DynamicViewRule, ViewRuleGlobal>> {
+  return rules.reduce((acc, rule) => {
+    if (isViewRuleGlobalPredicateRef(rule)) {
+      const globalPredicates = globals.dynamicPredicates[rule.predicateId]
+      if (isNullish(globalPredicates)) {
+        return acc
+      }
+      return acc.concat(globalPredicates)
+    }
+    if (isViewRuleGlobalStyle(rule)) {
+      const globalStyles = globals.styles[rule.styleId]
+      if (isNullish(globalStyles)) {
+        return acc
+      }
+      return acc.concat(globalStyles)
+    }
+    acc.push(rule)
+    return acc
+  }, [] as Array<Exclude<DynamicViewRule, ViewRuleGlobal>>)
+}

package/src/compute-view/utils/topological-sort.ts

@@ -0,0 +1,256 @@
+import Graph from 'graphology'
+import { topologicalSort as topsort } from 'graphology-dag/topological-sort'
+import willCreateCycle from 'graphology-dag/will-create-cycle'
+import { forEach, map, partition, pipe, takeWhile } from 'remeda'
+import { invariant, nonNullable } from '../../errors'
+import type { ComputedEdge, ComputedNode, Fqn, NodeId } from '../../types'
+import { ancestorsOfNode } from './ancestorsOfNode'
+
+/**
+ * Keeps initial order of the elements, but ensures parents are placed before children
+ */
+function ensureParentsFirst<T extends { id: string; parent: string | null }>(
+  array: ReadonlyArray<T>,
+): Array<T> {
+  const result = [] as T[]
+  const items = [...array]
+  let item
+  while ((item = items.shift())) {
+    let parent = item.parent
+    if (parent) {
+      const ancestors = [] as T[]
+      while (parent) {
+        const parentIndx = items.findIndex(i => i.id === parent)
+        if (parentIndx < 0) {
+          break
+        }
+        const [parentItem] = items.splice(parentIndx, 1)
+        if (!parentItem) {
+          throw new Error('Invalid state, should not happen')
+        }
+        ancestors.unshift(parentItem)
+        parent = parentItem.parent
+      }
+      result.push(...ancestors)
+    }
+    result.push(item)
+  }
+  return result as Array<T>
+}
+
+/**
+ * Side effect, mutates node.children field to preserve same order as in the input
+ */
+function updateChildren(nodes: ComputedNode[]) {
+  nodes.forEach(parent => {
+    if (parent.children.length > 0) {
+      parent.children = nodes.reduce((acc, n) => {
+        if (n.parent === parent.id) {
+          acc.push(n.id)
+        }
+        return acc
+      }, [] as NodeId[])
+    }
+  })
+  return nodes
+}
+
+type TopologicalSortParam = {
+  nodes: ReadonlyMap<Fqn, ComputedNode>
+  edges: Iterable<ComputedEdge>
+}
+export function topologicalSort(
+  param: TopologicalSortParam,
+): {
+  nodes: ComputedNode[]
+  edges: ComputedEdge[]
+} {
+  let nodes = ensureParentsFirst([...param.nodes.values()])
+  let edges = [...param.edges]
+  if (nodes.length < 2 || edges.length === 0) {
+    return {
+      nodes,
+      edges,
+    }
+  }
+
+  const getNode = (id: Fqn) => nonNullable(param.nodes.get(id))
+  // const nodeLevel = (id: string) => getNode(id).level + 1
+  //
+
+  const g = new Graph({
+    multi: true,
+    allowSelfLoops: true,
+    type: 'directed',
+  })
+
+  const enrichedEdges = pipe(
+    edges,
+    map((edge, __dirname) => {
+      const source = getNode(edge.source),
+        target = getNode(edge.target),
+        parent = edge.parent ? getNode(edge.parent) : null
+      return ({
+        id: edge.id,
+        edge,
+        parent,
+        source,
+        target,
+      })
+    }),
+    // sortBy(
+    //   [prop('sourceIndex'), 'asc'],
+    //   // [prop('sourceInCount'), 'asc'],
+    //   // [prop('sourceLevel'), 'asc'],
+    // ),
+  )
+
+  const [edgesBetweenLeafs, edgesWithCompounds] = partition(
+    enrichedEdges,
+    ({ source, target }) => source.children.length === 0 && target.children.length === 0,
+  )
+
+  // edgesBetweenLeafs.sort((a, b) => {
+  //   if (a.source === b.source) {
+  //     return 0
+  //   }
+  //   if (a.source.level === 0 && b.source.level === 0) {
+  //     return 0
+  //   }
+  //   if (isSameHierarchy(a.source, b.target) || isSameHierarchy(a.target, b.source)) {
+  //     return edges.indexOf(a.edge) - edges.indexOf(b.edge)
+  //   }
+  //   const aLevel = a.parent ? a.parent.level + 1 - a.source.level : a.source.level
+  //   const bLevel = b.parent ? b.parent.level + 1 - b.source.level : b.source.level
+  //   return aLevel - bLevel
+  //   // if (a.source.level === 0 && b.source.level === 0) {
+
+  //   //   // if (a.source.depth)
+  //   //   return nodes.indexOf(a.target) - nodes.indexOf(b.target)
+  //   // }
+  //   // if (a.source.level === 0 && b.source.level > 0) {
+  //   //   return -1
+  //   // }
+  //   // if (a.parent && b.parent && a.parent !== b.parent) {
+  //   //   if (a.parent.level !== b.parent.level) {
+  //   //     return b.parent.level - a.parent.level
+  //   //   } else {
+  //   //     return nodes.indexOf(a.parent) - nodes.indexOf(b.parent)
+  //   //   }
+  //   // }
+  //   // return Math.min(nodes.indexOf(a.source), nodes.indexOf(a.target)) - Math.min(nodes.indexOf(b.source), nodes.indexOf(b.target))
+  // })
+  const sortedEdges = [] as ComputedEdge[]
+
+  const addEdgeToGraph = (edge: ComputedEdge) => {
+    g.mergeNode(edge.source)
+    g.mergeNode(edge.target)
+    sortedEdges.push(edge)
+    if (!willCreateCycle(g, edge.source, edge.target)) {
+      g.mergeDirectedEdge(edge.source, edge.target)
+    }
+  }
+
+  for (const { edge, source, target } of edgesBetweenLeafs) {
+    addEdgeToGraph(edge)
+    // Strengthen the graph by adding edges to parents
+    if (target.parent && target.parent !== edge.parent) {
+      pipe(
+        ancestorsOfNode(target, param.nodes),
+        takeWhile(ancestor => ancestor.inEdges.includes(edge.id)),
+        forEach(ancestor => {
+          g.mergeNode(ancestor.id)
+          if (!willCreateCycle(g, edge.source, ancestor.id)) {
+            g.mergeDirectedEdge(edge.source, ancestor.id)
+          }
+          if (!willCreateCycle(g, ancestor.id, edge.target)) {
+            g.mergeDirectedEdge(ancestor.id, edge.target)
+          }
+        }),
+      )
+    }
+    if (source.parent) {
+      const sourceParent = getNode(source.parent)
+      g.mergeNode(sourceParent.id)
+      if (!willCreateCycle(g, sourceParent.id, source.id)) {
+        g.mergeDirectedEdge(sourceParent.id, source.id)
+      }
+      if (target.parent && target.parent !== source.parent) {
+        if (!willCreateCycle(g, sourceParent.id, target.parent)) {
+          g.mergeDirectedEdge(sourceParent.id, target.parent)
+        }
+      }
+    }
+
+    // addEdgeToGraph(edge)
+  }
+  for (const { edge } of edgesWithCompounds) {
+    addEdgeToGraph(edge)
+  }
+
+  invariant(sortedEdges.length === edges.length, 'Not all edges were added to the graph')
+
+  // for (const compound of nodes) {
+  //   if (compound.children.length === 0 || compound.inEdges.length === 0) {
+  //     continue
+  //   }
+  //   // g.mergeNode(compound.id)
+  //   for (const inEdge of compound.inEdges) {
+  //     const { edge, source } = getEdge(inEdge)
+  //     // ignore if this edge is coming from compound node
+  //     if (source.children.length > 0) {
+  //       continue
+  //     }
+  //     // if this edge is coming to the compound node directly
+  //     if (edge.target === compound.id) {
+  //       // for (const child of compound.children) {
+  //       //   // g.mergeNode(child)
+  //       //   if (!willCreateCycle(g, edge.source, child)) {
+  //       //     g.mergeDirectedEdge(edge.source, child)
+  //       //   }
+  //       // }
+  //     } else {
+  //       if (!willCreateCycle(g, edge.source, compound.id)) {
+  //         g.mergeDirectedEdge(edge.source, compound.id)
+  //       }
+  //       if (!willCreateCycle(g, compound.id, edge.target)) {
+  //         g.mergeDirectedEdge(compound.id, edge.target)
+  //       }
+  //     }
+  //   }
+  // }
+
+  const sortedIds = topsort(g)
+  let sorted = [] as ComputedNode[]
+  let unsorted = nodes.slice()
+  for (const sortedId of sortedIds) {
+    const indx = unsorted.findIndex(n => n.id === sortedId)
+    invariant(indx >= 0, `Node "${sortedId}" not found`)
+    sorted.push(...unsorted.splice(indx, 1))
+  }
+  // Merge unsorted nodes, keeping their initial order
+  if (unsorted.length > 0 && sorted.length > 0) {
+    sorted = sorted.flatMap(node => {
+      if (unsorted.length === 0) {
+        return node
+      }
+      const wereBefore = nodes
+        .slice(0, nodes.indexOf(node))
+        .filter(n => unsorted.includes(n))
+      if (wereBefore.length > 0) {
+        unsorted = unsorted.filter(n => !wereBefore.includes(n))
+        return [...wereBefore, node]
+      }
+
+      return node
+    })
+  }
+  // Add remaining unsorted nodes
+  sorted.push(...unsorted)
+  return {
+    nodes: updateChildren(
+      ensureParentsFirst(sorted),
+    ),
+    edges: sortedEdges,
+  }
+}

package/src/compute-view/utils/uniqueTags.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from 'vitest'
+import { uniqueTags } from './uniqueTags'
+
+describe('uniqueTags function', () => {
+  it('returns unique tags from an array of elements', () => {
+    const input = [
+      { tags: ['tag1', 'tag2', 'tag3'] },
+      { tags: ['tag2', 'tag3', 'tag4'] },
+      { tags: ['tag3', 'tag4', 'tag5'] }
+    ] as const
+    const result = uniqueTags(input)
+    expect(result).toEqual(['tag1', 'tag2', 'tag3', 'tag4', 'tag5'])
+  })
+
+  it('should return unique tags naturally sorted', () => {
+    const input = [
+      { tags: ['tag1', 'tag20', 'tag30'] },
+      { tags: ['tag2', 'tag23', 'tag34'] },
+      { tags: ['tag3'] }
+    ] as const
+    const result = uniqueTags(input)
+    expect(result).toEqual([
+      'tag1',
+      'tag2',
+      'tag3',
+      'tag20',
+      'tag23',
+      'tag30',
+      'tag34'
+    ])
+    // ].sort(compareNatural))
+  })
+
+  it('returns null if the tags array is null', () => {
+    const input = [
+      { tags: null },
+      {}
+    ]
+    const result = uniqueTags(input)
+    expect(result).toBeNull()
+  })
+})

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

@@ -0,0 +1,21 @@
+import { flatMap, hasAtLeast, pipe, sort, unique } from 'remeda'
+import type { LiteralUnion } from 'type-fest'
+import type { NonEmptyReadonlyArray } from '../../types/_common'
+import type { Tag } from '../../types/element'
+import { compareNatural } from '../../utils/compare-natural'
+
+/**
+ * Extracts unique tags from an array of elements.
+ * and sort in natural order; returns null if no tags are present.
+ */
+export function uniqueTags<T extends { tags?: NonEmptyReadonlyArray<LiteralUnion<Tag, string>> | null }>(
+  elements: ReadonlyArray<T>
+) {
+  const tags = pipe(
+    elements,
+    flatMap(e => e.tags ?? []),
+    unique(),
+    sort(compareNatural)
+  )
+  return hasAtLeast(tags, 1) ? tags as NonEmptyReadonlyArray<Tag> : null
+}

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

@@ -0,0 +1,27 @@
+import { isTruthy, map, mapToObj, pick, pipe } from 'remeda'
+import type { SetOptional } from 'type-fest'
+import type { ComputedView } from '../../types'
+import { objectHash } from '../../utils/object-hash'
+
+export function calcViewLayoutHash<V extends ComputedView>(view: SetOptional<V, 'hash'>): V {
+  const tohash = {
+    id: view.id,
+    __: view.__ ?? 'element',
+    autoLayout: view.autoLayout,
+    nodes: pipe(
+      view.nodes,
+      map(pick(['id', 'title', 'description', 'technology', 'shape', 'icon', 'children'])),
+      mapToObj(({ id, icon, ...node }) => [id, { ...node, icon: isTruthy(icon) ? 'Y' : 'N' }])
+    ),
+    edges: pipe(
+      view.edges,
+      map(pick(['source', 'target', 'label', 'description', 'technology', 'dir', 'head', 'tail', 'line'])),
+      mapToObj(({ source, target, ...edge }) => [`${source}:${target}`, edge])
+    )
+  }
+  view.hash = objectHash(tohash, {
+    ignoreUnknown: true,
+    respectType: false
+  })
+  return view as V
+}