@likec4/core 1.18.0 → 1.19.0

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

@@ -0,0 +1,147 @@
+import type { Connection } from '../../model/connection'
+import type { DeploymentElementModel } from '../../model/DeploymentElementModel'
+import type { ElementModel } from '../../model/ElementModel'
+
+type Element = ElementModel | DeploymentElementModel
+
+export interface ComputeCtx<
+  E extends Element,
+  C extends Connection<E, any>,
+  M extends ComputeMemory<any>,
+  Inc extends StageInclude<any>,
+  Exc extends StageExclude<any>,
+  Expr = unknown,
+> {
+  Element: E
+  Connection: C
+  Memory: M
+  StageInclude: Inc
+  StageExclude: Exc
+  Expr: Expr
+  MutableState: State<this>
+}
+
+// export type AnyCtx = ComputeCtx<any, any, ComputeMemory<any>, StageInclude<any>, StageExclude<any>, any>
+export type AnyCtx = GenericCtx
+
+export type GenericCtx = ComputeCtx<
+  any,
+  Connection<any, any>,
+  ComputeMemory<GenericCtx>,
+  StageInclude<GenericCtx>,
+  StageExclude<GenericCtx>,
+  unknown
+>
+
+export interface State<T extends AnyCtx> {
+  elements: Set<CtxElement<T>>
+  explicits: Set<CtxElement<T>>
+  final: Set<CtxElement<T>>
+  connections: Array<CtxConnection<T>>
+}
+
+export type MutableState<T extends AnyCtx> = T['MutableState']
+
+export type StageExpression<T extends AnyCtx> = T['Expr']
+
+export type CtxElement<T extends AnyCtx> = T['Element']
+export type CtxConnection<T extends AnyCtx> = T['Connection']
+export type CtxMemory<T extends AnyCtx> = T['Memory']
+
+export interface ComputeMemory<T extends AnyCtx> {
+  /**
+   * All resolved elements, includes:
+   * - explicit elements (included by element predicates, 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<CtxElement<T>>
+
+  /**
+   * Explicit elements
+   */
+  readonly explicits: ReadonlySet<CtxElement<T>>
+
+  /**
+   * Final set of elements to be included in the view
+   * (`elements` excluding implicits)
+   * Keeps order in which elements were added
+   */
+  readonly final: ReadonlySet<CtxElement<T>>
+
+  /**
+   * Resolved connections
+   */
+  readonly connections: ReadonlyArray<CtxConnection<T>>
+
+  isEmpty(): boolean
+
+  stageInclude(expression: T['Expr']): T['StageInclude']
+
+  stageExclude(expression: T['Expr']): T['StageExclude']
+
+  /**
+   * Returns shallow copy of state
+   */
+  mutableState(): T['MutableState']
+
+  /**
+   * Returns new memory with updated state
+   */
+  update(newstate: Partial<T['MutableState']>): T['Memory']
+}
+
+interface Stage<T extends AnyCtx> {
+  readonly memory: CtxMemory<T>
+
+  readonly expression: StageExpression<T>
+
+  /**
+   * Has changes
+   */
+  isDirty(): boolean
+
+  /**
+   * Has no changes
+   */
+  isEmpty(): boolean
+
+  commit(): T['Memory']
+}
+
+export interface StageInclude<T extends AnyCtx> extends Stage<T> {
+  readonly elements: ReadonlySet<CtxElement<T>>
+
+  readonly connections: ReadonlyArray<CtxConnection<T>>
+
+  addExplicit(element: CtxElement<T> | Iterable<CtxElement<T>> | false | undefined | null): this
+
+  addImplicit(element: CtxElement<T> | Iterable<CtxElement<T>> | false | undefined | null): this
+
+  /**
+   * Connects element with existing ones in the memory
+   *
+   * @param direction - direction of the connection
+   * @default 'both'
+   */
+  connectWithExisting(
+    element: CtxElement<T> | Iterable<CtxElement<T>>,
+    direction?: 'in' | 'out' | 'both',
+  ): boolean
+
+  addConnections(connection: CtxConnection<T> | Iterable<CtxConnection<T>>): this
+}
+
+export interface StageExclude<T extends AnyCtx> extends Stage<T> {
+  /**
+   * Excludes from the memory relationships from given connections (still connection may be included, but without given relationships)
+   * @param moveExplicitToImplicit - if true, disconnected explicit elements will be moved to implicit
+   * @default false
+   */
+  excludeConnections(
+    connection: CtxConnection<T> | Iterable<CtxConnection<T>>,
+    moveExplicitToImplicit?: boolean,
+  ): this
+
+  exclude(element: CtxElement<T> | Iterable<CtxElement<T>> | false | undefined | null): this
+}

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

@@ -0,0 +1,5 @@
+export type * from './_types'
+export { AbstractMemory } from './AbstractMemory'
+export { AbstractStageExclude } from './AbstractStageExclude'
+export { AbstractStageInclude } from './AbstractStageInclude'
+export { treeFromMemoryState } from './ops'

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/buildComputedNodes.ts

@@ -10,7 +10,7 @@ import {
   type NodeId
 } from '../../types'
 import { compareByFqnHierarchically, parentFqn } from '../../utils/fqn'
-import { NodesGroup } from '../element-view/compute'
+import { NodesGroup } from '../element-view/memory'
 
 function updateDepthOfAncestors(node: ComputedNode, nodes: ReadonlyMap<Fqn, ComputedNode>) {
   let parentNd
@@ -44,13 +44,13 @@ export function buildComputedNodesFromElements(elements: ReadonlyArray<Element>,
 
 export function buildComputedNodes(
   elements: ReadonlyArray<ComputedNodeSource>,
-  groups?: NodesGroup[]
+  groups?: ReadonlyArray<NodesGroup>
 ): ReadonlyMap<Fqn, ComputedNode> {
   const nodesMap = new Map<Fqn, ComputedNode>()
 
   const elementToGroup = new Map<Fqn, NodeId>()
 
-  groups?.forEach(({ id, parent, viewRule, explicits }) => {
+  groups?.forEach(({ id, parent, viewRule, elements }) => {
     if (parent) {
       nonNullable(nodesMap.get(parent), `Parent group node ${parent} not found`).children.push(id)
     }
@@ -75,7 +75,7 @@ export function buildComputedNodes(
         opacity: viewRule.opacity ?? 0
       }
     })
-    for (const e of explicits) {
+    for (const e of elements) {
       elementToGroup.set(e.id, id)
     }
   })

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

@@ -1,8 +1,6 @@
 import { isNullish } from 'remeda'
 import { nonexhaustive } from '../../errors'
 import {
-  type ComputedNode,
-  type Element,
   type ElementPredicateExpression,
   isCustomElement,
   isElementKindExpr,
@@ -17,7 +15,7 @@ import { parentFqn } from '../../utils'
 
 type Predicate<T> = (x: T) => boolean
 
-export function elementExprToPredicate<T extends Pick<ComputedNode, 'id' | 'kind' | 'tags'>>(
+export function elementExprToPredicate<T extends { id: string; tags?: readonly string[] | null; kind: string }>(
   target: ElementPredicateExpression
 ): Predicate<T> {
   if (isElementWhere(target)) {

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

@@ -19,12 +19,8 @@ export function linkNodesWithEdges(nodesMap: ReadonlyMap<Fqn, ComputedNode>, edg
     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
+    // Ensure that ancestors are in computed nodes
     const sourceAncestors = ancestorsOfNode(source, nodesMap)
     const targetAncestors = ancestorsOfNode(target, nodesMap)
 
@@ -34,8 +30,8 @@ export function linkNodesWithEdges(nodesMap: ReadonlyMap<Fqn, ComputedNode>, edg
       ? last(
         commonHead(
           reverse(sourceAncestors),
-          reverse(targetAncestors)
-        )
+          reverse(targetAncestors),
+        ),
       )
       : null
     edge.parent = edgeParent ? edgeParent.id : null

package/src/compute-view/utils/{derive-edge-props-from-relationships.ts → merge-props-from-relationships.ts}

@@ -1,27 +1,45 @@
-import { isTruthy, only, pick, pickBy, pipe, reduce, unique } from 'remeda'
+import { isTruthy, only, 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 type { ModelRelation, 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'
-  ])
+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
+  }
 }
-type RelationshipProps = ReturnType<typeof pickRelationshipProps>
 
-export function deriveEdgePropsFromRelationships(relations: Array<Relation | DeploymentRelation>) {
-  // TODO:
+/**
+ * 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(
@@ -76,12 +94,17 @@ export function deriveEdgePropsFromRelationships(relations: Array<Relation | Dep
       }
     )
   )
+
+  let technology = only(allprops.technology)
+  let title = only(allprops.title) ?? (allprops.title.length > 1 ? '[...]' : null)
+
   const tags = unique(allprops.tags)
-  return pickBy(
+  let merged = pickBy(
     {
-      title: only(allprops.title) ?? (allprops.title.length > 1 ? '[...]' : null),
+      // If there is no title, but there is technology, use technology as title
+      title: title ?? (technology ? `[${technology}]` : null),
       description: only(allprops.description),
-      technology: only(allprops.technology),
+      technology,
       kind: only(allprops.kind),
       head: only(allprops.head),
       tail: only(allprops.tail),
@@ -93,5 +116,13 @@ export function deriveEdgePropsFromRelationships(relations: Array<Relation | Dep
     },
     isTruthy
   )
+
+  if (prefer) {
+    return {
+      ...merged,
+      ...pickBy(pickRelationshipProps(prefer), isTruthy)
+    }
+  }
+  return merged
 }
-export type MergedRelationshipProps = ReturnType<typeof deriveEdgePropsFromRelationships>
+export type MergedRelationshipProps = ReturnType<typeof mergePropsFromRelationships>

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

@@ -10,12 +10,12 @@ import {
   type RelationWhereExpr
 } from '../../types/expression'
 import { whereOperatorAsPredicate } from '../../types/operators'
-import type { Relation } from '../../types/relation'
+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<Relation, 'kind' | 'tags'> & {
+export type FilterableEdge = Pick<ModelRelation, 'kind' | 'tags'> & {
   source: ComputedNode
   target: ComputedNode
 }

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

@@ -1,65 +1,69 @@
-import { first, last, values } from 'remeda'
-import { isExtendsElementView, type LikeC4View } from '../../types/view'
-import { findCycles, Graph, isAcyclic, postorder } from '../../utils/graphlib'
+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)
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function resolveRulesExtendedViews<V extends Record<any, LikeC4View>>(
   unresolvedViews: V
 ): V {
-  const g = new Graph({
-    directed: true,
-    multigraph: false,
-    compound: false
+  const g = new Graph<{ view: LikeC4View }>({
+    type: 'directed'
   })
+  const extendedViews = [] as ExtendsElementView<any, any>[]
   for (const view of values(unresolvedViews)) {
-    g.setNode(view.id, view.id)
+    g.addNode(view.id, { view })
     if (isExtendsElementView(view)) {
-      // view -> parent
-      g.setEdge(view.id, view.extends)
+      extendedViews.push(view)
     }
   }
-  if (g.edgeCount() === 0) {
+
+  if (extendedViews.length === 0) {
     return unresolvedViews
   }
 
-  // Remove circular dependencies
-  while (!isAcyclic(g)) {
-    const firstCycle = first(findCycles(g))
-    if (!firstCycle) {
-      break
+  for (const view of extendedViews) {
+    if (!g.hasNode(view.extends)) {
+      console.warn(`View "${view.id}" extends from "${view.extends}" which does not exist`)
+      continue
     }
-    const cycledNode = last(firstCycle)
-    if (!cycledNode) {
-      break
+    if (willCreateCycle(g, view.id, view.extends)) {
+      console.warn(`View "${view.id}" extends from "${view.extends}" which creates a cycle`)
+      continue
     }
-    g.removeNode(cycledNode)
+
+    // view -> parent
+    g.addDirectedEdge(view.id, view.extends)
   }
 
-  const ordered = postorder(g, g.sources() as unknown as string[])
+  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
+    }
 
-  return ordered.reduce((acc, id) => {
-    const view = unresolvedViews[id]
-    if (!view) {
+    const extendsFrom = acc[view.extends]
+    if (!extendsFrom || !isElementView(extendsFrom)) {
       return acc
     }
-    if (isExtendsElementView(view)) {
-      const extendsFrom = acc[view.extends]
-      if (!extendsFrom) {
-        console.warn(`View "${view.id}" extends from "${view.extends}" which does not exist`)
-        return acc
-      }
-      return Object.assign(acc, {
-        [view.id]: {
-          ...extendsFrom,
-          ...view,
-          rules: [...extendsFrom.rules, ...view.rules]
-        }
-      })
+
+    acc[view.id] = {
+      ...extendsFrom,
+      ...view,
+      rules: [...extendsFrom.rules, ...view.rules]
     }
-    return Object.assign(acc, { [view.id]: view })
-  }, {} as V)
+    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

@@ -21,12 +21,12 @@ export function resolveGlobalRules<V extends DynamicView | ElementView>(
   if (isElementView(view)) {
     return {
       ...view,
-      rules: resolveGlobalRulesInElementView(view, globals)
+      rules: resolveGlobalRulesInElementView(view.rules, globals)
     }
   } else if (isDynamicView(view)) {
     return {
       ...view,
-      rules: resolveGlobalRulesInDynamicView(view, globals)
+      rules: resolveGlobalRulesInDynamicView(view.rules, globals)
     }
   }
   nonexhaustive(view)
@@ -35,10 +35,10 @@ export function resolveGlobalRules<V extends DynamicView | ElementView>(
 type ViewRuleGlobal = ViewRuleGlobalPredicateRef | ViewRuleGlobalStyle
 
 export function resolveGlobalRulesInElementView(
-  view: ElementView,
+  rules: ViewRule[],
   globals: ModelGlobals
 ): Array<Exclude<ViewRule, ViewRuleGlobal>> {
-  return view.rules.reduce((acc, rule) => {
+  return rules.reduce((acc, rule) => {
     if (isViewRuleGlobalPredicateRef(rule)) {
       const globalPredicates = globals.predicates[rule.predicateId]
       if (isNullish(globalPredicates)) {
@@ -59,10 +59,10 @@ export function resolveGlobalRulesInElementView(
 }
 
 export function resolveGlobalRulesInDynamicView(
-  view: DynamicView,
+  rules: DynamicViewRule[],
   globals: ModelGlobals
 ): Array<Exclude<DynamicViewRule, ViewRuleGlobal>> {
-  return view.rules.reduce((acc, rule) => {
+  return rules.reduce((acc, rule) => {
     if (isViewRuleGlobalPredicateRef(rule)) {
       const globalPredicates = globals.dynamicPredicates[rule.predicateId]
       if (isNullish(globalPredicates)) {