@likec4/language-server 1.6.1 → 1.7.0

package/src/model-graph/LikeC4ModelGraph.ts

@@ -11,11 +11,6 @@ import {
   type Relation,
   type RelationID
 } from '@likec4/core'
-import { filter, isIncludedIn } from 'remeda'
-
-function intersection<T>(source: ReadonlyArray<T>, other: ReadonlyArray<T>): Array<T> {
-  return filter(source, isIncludedIn(other))
-}
 
 type Params = {
   elements: Record<Fqn, Element>
@@ -32,6 +27,16 @@ type RelationEdge = {
 type FqnOrElement = Fqn | Element
 type FqnsOrElements = Fqn[] | Element[]
 
+const RelationsSet = Set<Relation>
+const MapRelations = Map<Fqn, Set<Relation>>
+
+function intersection<T>(a: Set<T>, b: Set<T>) {
+  if (a.size === 0 || b.size === 0) {
+    return new Set<T>()
+  }
+  return new Set([...a].filter(value => b.has(value)))
+}
+
 export class LikeC4ModelGraph {
   #elements = new Map<Fqn, Element>()
   #children = new Map<Fqn, Fqn[]>()
@@ -39,11 +44,13 @@ export class LikeC4ModelGraph {
 
   #relations = new Map<RelationID, Relation>()
   // Incoming to an element or its descendants
-  #incoming = new Map<Fqn, RelationID[]>()
+  #incoming = new MapRelations()
   // Outgoing from an element or its descendants
-  #outgoing = new Map<Fqn, RelationID[]>()
+  #outgoing = new MapRelations()
   // Relationships inside the element descendants
-  #internal = new Map<Fqn, RelationID[]>()
+  #internal = new MapRelations()
+
+  #cacheAscendingSiblings = new Map<Fqn, Element[]>()
 
   constructor({ elements, relations }: Params) {
     for (const el of Object.values(elements)) {
@@ -68,16 +75,8 @@ export class LikeC4ModelGraph {
     return el
   }
 
-  public incoming(id: Fqn) {
-    return this._incomingTo(id).flatMap(id => this.#relations.get(id) ?? [])
-  }
-
-  public outgoing(id: Fqn) {
-    return this._outgoingFrom(id).flatMap(id => this.#relations.get(id) ?? [])
-  }
-
-  public internal(id: Fqn) {
-    return this._internalOf(id).flatMap(id => this.#relations.get(id) ?? [])
+  public connectedRelations(id: Fqn) {
+    return [...this._incomingTo(id), ...this._outgoingFrom(id), ...this._internalOf(id)]
   }
 
   public children(id: Fqn) {
@@ -108,7 +107,15 @@ export class LikeC4ModelGraph {
    */
   public ascendingSiblings(element: Fqn | Element) {
     const id = isString(element) ? element : element.id
-    return [...this.siblings(id), ...this.ancestors(id).flatMap(a => this.siblings(a.id))]
+    let siblings = this.#cacheAscendingSiblings.get(id)
+    if (!siblings) {
+      siblings = [
+        ...this.siblings(id),
+        ...this.ancestors(id).flatMap(a => this.siblings(a.id))
+      ]
+      this.#cacheAscendingSiblings.set(id, siblings)
+    }
+    return siblings.slice()
   }
 
   /**
@@ -121,7 +128,7 @@ export class LikeC4ModelGraph {
     const element = isString(_element) ? this.element(_element) : _element
     const in_element = this._incomingTo(element.id)
     const element_out = this._outgoingFrom(element.id)
-    if (in_element.length === 0 && element_out.length === 0) {
+    if (in_element.size === 0 && element_out.size === 0) {
       return []
     }
 
@@ -132,26 +139,26 @@ export class LikeC4ModelGraph {
         continue
       }
 
-      if (element_out.length > 0) {
-        const in_other = this._incomingTo(other.id)
-        const outcoming = intersection(element_out, in_other)
-        if (outcoming.length > 0) {
+      if (element_out.size > 0) {
+        const outcoming = intersection(this._incomingTo(other.id), element_out)
+        // const outcoming = filter(in_other, isOutgoing)
+        if (outcoming.size > 0) {
           result.push({
             source: element,
             target: other,
-            relations: outcoming.flatMap(id => this.#relations.get(id) ?? [])
+            relations: [...outcoming]
           })
         }
       }
 
-      if (in_element.length > 0) {
-        const other_out = this._outgoingFrom(other.id)
-        const incoming = intersection(other_out, in_element)
-        if (incoming.length > 0) {
+      if (in_element.size > 0) {
+        const incoming = intersection(this._outgoingFrom(other.id), in_element)
+        // const incoming = filter(other_out, isIncoming)
+        if (incoming.size > 0) {
           result.push({
             source: other,
             target: element,
-            relations: incoming.flatMap(id => this.#relations.get(id) ?? [])
+            relations: [...incoming]
           })
         }
       }
@@ -193,9 +200,10 @@ export class LikeC4ModelGraph {
     for (const _source of sources) {
       const source = isString(_source) ? this.element(_source) : _source
       const outcoming = this._outgoingFrom(source.id)
-      if (outcoming.length === 0) {
+      if (outcoming.size === 0) {
         continue
       }
+      // const isSameAsOut = isIncludedIn(outcoming)
 
       for (const _target of targets) {
         const target = isString(_target) ? this.element(_target) : _target
@@ -203,18 +211,12 @@ export class LikeC4ModelGraph {
           continue
         }
         const incoming = this._incomingTo(target.id)
-        if (incoming.length === 0) {
-          continue
-        }
-
-        const relations = intersection(outcoming, incoming).flatMap(
-          id => this.#relations.get(id) ?? []
-        )
-        if (relations.length > 0) {
+        const relations = intersection(outcoming, incoming)
+        if (relations.size > 0) {
           result.push({
             source,
             target,
-            relations
+            relations: [...relations]
           })
         }
       }
@@ -240,14 +242,14 @@ export class LikeC4ModelGraph {
       throw new InvalidModelError(`Relation ${rel.id} already exists`)
     }
     this.#relations.set(rel.id, rel)
-    this._incomingTo(rel.target).push(rel.id)
-    this._outgoingFrom(rel.source).push(rel.id)
+    this._incomingTo(rel.target).add(rel)
+    this._outgoingFrom(rel.source).add(rel)
 
     const relParent = commonAncestor(rel.source, rel.target)
     // Process internal relationships
     if (relParent) {
       for (const ancestor of [relParent, ...ancestorsFqn(relParent)]) {
-        this._internalOf(ancestor).push(rel.id)
+        this._internalOf(ancestor).add(rel)
       }
     }
     // Process source hierarchy
@@ -255,14 +257,14 @@ export class LikeC4ModelGraph {
       if (sourceAncestor === relParent) {
         break
       }
-      this._outgoingFrom(sourceAncestor).push(rel.id)
+      this._outgoingFrom(sourceAncestor).add(rel)
     }
     // Process target hierarchy
     for (const targetAncestor of ancestorsFqn(rel.target)) {
       if (targetAncestor === relParent) {
         break
       }
-      this._incomingTo(targetAncestor).push(rel.id)
+      this._incomingTo(targetAncestor).add(rel)
     }
   }
 
@@ -278,7 +280,7 @@ export class LikeC4ModelGraph {
   private _incomingTo(id: Fqn) {
     let incoming = this.#incoming.get(id)
     if (!incoming) {
-      incoming = []
+      incoming = new RelationsSet()
       this.#incoming.set(id, incoming)
     }
     return incoming
@@ -287,7 +289,7 @@ export class LikeC4ModelGraph {
   private _outgoingFrom(id: Fqn) {
     let outgoing = this.#outgoing.get(id)
     if (!outgoing) {
-      outgoing = []
+      outgoing = new RelationsSet()
       this.#outgoing.set(id, outgoing)
     }
     return outgoing
@@ -296,7 +298,7 @@ export class LikeC4ModelGraph {
   private _internalOf(id: Fqn) {
     let internal = this.#internal.get(id)
     if (!internal) {
-      internal = []
+      internal = new RelationsSet()
       this.#internal.set(id, internal)
     }
     return internal

package/src/model-graph/compute-view/__test__/fixture.ts

@@ -1,23 +1,27 @@
 import type {
   BorderStyle,
   ComputedView,
+  CustomElementExpr as C4CustomElementExpr,
   CustomRelationExpr as C4CustomRelationExpr,
   Element,
   ElementExpression as C4ElementExpression,
   ElementKind,
   ElementShape,
+  ElementWhereExpr,
   Expression as C4Expression,
   Fqn,
   Relation,
   RelationID,
   RelationshipArrowType,
   RelationshipLineType,
+  RelationWhereExpr,
   Tag,
   ThemeColor,
   ViewID,
   ViewRule,
   ViewRulePredicate,
-  ViewRuleStyle
+  ViewRuleStyle,
+  WhereOperator
 } from '@likec4/core'
 import { indexBy, isString, map, prop } from 'remeda'
 import { LikeC4ModelGraph } from '../../LikeC4ModelGraph'
@@ -139,7 +143,8 @@ export const fakeElements = {
   'cloud': el({
     id: 'cloud',
     kind: 'system',
-    title: 'cloud'
+    title: 'cloud',
+    tags: ['next' as Tag, 'old' as Tag]
   }),
   'cloud.backend': el({
     id: 'cloud.backend',
@@ -177,18 +182,21 @@ export const fakeElements = {
   'cloud.frontend.dashboard': el({
     id: 'cloud.frontend.dashboard',
     kind: 'component',
-    title: 'dashboard'
+    title: 'dashboard',
+    tags: ['next' as Tag]
   }),
   'amazon': el({
     id: 'amazon',
     kind: 'system',
-    title: 'amazon'
+    title: 'amazon',
+    tags: ['aws' as Tag]
   }),
   'amazon.s3': el({
     id: 'amazon.s3',
     kind: 'component',
     title: 's3',
-    shape: 'storage'
+    shape: 'storage',
+    tags: ['aws' as Tag]
   })
 } satisfies Record<string, Element>
 
@@ -329,9 +337,18 @@ type OutgoingExpr = `${ElementRefExpr} ->`
 type RelationKeyword = '->' | '<->'
 type RelationExpr = `${ElementRefExpr} ${RelationKeyword} ${ElementRefExpr}`
 
-type CustomExpr = {
-  custom: {
-    element: FakeElementIds
+export type Expression =
+  | ElementRefExpr
+  | InOutExpr
+  | IncomingExpr
+  | OutgoingExpr
+  | RelationExpr
+  | ElementWhereExpr
+  | RelationWhereExpr
+
+export function $custom(
+  expr: ElementRefExpr,
+  props: {
     title?: string
     description?: string
     technology?: string
@@ -342,16 +359,15 @@ type CustomExpr = {
     opacity?: number
     navigateTo?: string
   }
+): C4CustomElementExpr {
+  return {
+    custom: {
+      expr: $expr(expr) as any,
+      ...props as any
+    }
+  }
 }
 
-export type Expression =
-  | ElementRefExpr
-  | InOutExpr
-  | IncomingExpr
-  | OutgoingExpr
-  | RelationExpr
-  | CustomExpr
-
 export function $customRelation(
   relation: RelationExpr,
   props: Omit<C4CustomRelationExpr['customRelation'], 'relation'>
@@ -364,6 +380,15 @@ export function $customRelation(
   }
 }
 
+export function $where(expr: Expression | C4Expression, operator: WhereOperator): ElementWhereExpr | RelationWhereExpr {
+  return {
+    where: {
+      expr: $expr(expr) as any,
+      condition: operator
+    }
+  }
+}
+
 export function $expr(expr: Expression | C4Expression): C4Expression {
   if (!isString(expr)) {
     return expr as C4Expression

package/src/model-graph/compute-view/compute.ts

@@ -3,8 +3,13 @@ import type {
   ComputedElementView,
   EdgeId,
   Element,
+  ElementPredicateExpression,
   ElementView,
   Relation,
+  RelationPredicateExpression,
+  RelationshipArrowType,
+  RelationshipLineType,
+  ThemeColor,
   ViewRulePredicate
 } from '@likec4/core'
 import {
@@ -18,9 +23,11 @@ import {
   isViewRuleAutoLayout,
   isViewRulePredicate,
   nonexhaustive,
-  parentFqn
+  parentFqn,
+  whereOperatorAsPredicate
 } from '@likec4/core'
 import { first, flatMap, hasAtLeast, isTruthy, unique } from 'remeda'
+import { calcViewLayoutHash } from '../../view-utils/view-hash'
 import type { LikeC4ModelGraph } from '../LikeC4ModelGraph'
 import { applyCustomElementProperties } from '../utils/applyCustomElementProperties'
 import { applyCustomRelationProperties } from '../utils/applyCustomRelationProperties'
@@ -28,15 +35,15 @@ import { applyViewRuleStyles } from '../utils/applyViewRuleStyles'
 import { buildComputeNodes } from '../utils/buildComputeNodes'
 import { sortNodes } from '../utils/sortNodes'
 import {
+  type ElementPredicateFn,
   excludeElementKindOrTag,
   excludeElementRef,
+  excludeExpandedElementExpr,
   excludeIncomingExpr,
   excludeInOutExpr,
   excludeOutgoingExpr,
   excludeRelationExpr,
   excludeWildcardRef,
-  includeCustomElement,
-  includeCustomRelation,
   includeElementKindOrTag,
   includeElementRef,
   includeExpandedElementExpr,
@@ -44,7 +51,8 @@ import {
   includeInOutExpr,
   includeOutgoingExpr,
   includeRelationExpr,
-  includeWildcardRef
+  includeWildcardRef,
+  type RelationPredicateFn
 } from './predicates'
 
 // eslint-disable-next-line @typescript-eslint/no-namespace
@@ -90,7 +98,11 @@ export class ComputeCtx {
   protected compute(): ComputedElementView {
     // reset ctx
     this.reset()
-    const { rules, ...view } = this.view
+    const {
+      docUri: _docUri, // exclude docUri
+      rules,
+      ...view
+    } = this.view
 
     const viewPredicates = rules.filter(isViewRulePredicate)
     if (this.root && viewPredicates.length == 0) {
@@ -102,7 +114,10 @@ export class ComputeCtx {
     const elements = [...this.includedElements]
     const nodesMap = buildComputeNodes(elements)
 
-    const edges = this.computedEdges.reduce((acc, edge) => {
+    const edgesMap = new Map<EdgeId, ComputedEdge>()
+    const edges = this.computeEdges()
+    for (const edge of edges) {
+      edgesMap.set(edge.id, edge)
       const source = nodesMap.get(edge.source)
       const target = nodesMap.get(edge.target)
       invariant(source, `Source node ${edge.source} not found`)
@@ -126,9 +141,7 @@ export class ComputeCtx {
         }
         nodesMap.get(targetAncestor)?.inEdges.push(edge.id)
       }
-      acc.push(edge)
-      return acc
-    }, [] as ComputedEdge[])
+    }
 
     // nodesMap sorted hierarchically,
     // but we need to keep the initial sort
@@ -146,27 +159,25 @@ export class ComputeCtx {
       )
     )
 
-    const edgesMap = new Map<EdgeId, ComputedEdge>(edges.map(e => [e.id, e]))
-
     const sortedEdges = new Set([
       ...nodes.flatMap(n => n.children.length === 0 ? n.outEdges.flatMap(id => edgesMap.get(id) ?? []) : []),
       ...edges
     ])
 
     const autoLayoutRule = this.view.rules.findLast(isViewRuleAutoLayout)
-    return {
+    return calcViewLayoutHash({
       ...view,
       autoLayout: autoLayoutRule?.autoLayout ?? 'TB',
       nodes,
       edges: applyCustomRelationProperties(rules, nodes, sortedEdges)
-    }
+    })
   }
 
   protected get root() {
     return isScopedElementView(this.view) ? this.view.viewOf : null
   }
 
-  protected get computedEdges(): ComputedEdge[] {
+  protected computeEdges(): ComputedEdge[] {
     return this.ctxEdges.map((e): ComputedEdge => {
       invariant(hasAtLeast(e.relations, 1), 'Edge must have at least one relation')
       const relations = e.relations.toSorted(compareRelations)
@@ -182,7 +193,16 @@ export class ComputeCtx {
         relations: relations.map(r => r.id)
       }
 
-      let relation
+      let relation: Pick<Relation, 'title' | 'description' | 'technology' | 'color' | 'line' | 'head' | 'tail'> | {
+        // TODO refactor with type-fest
+        title: string
+        description?: string | undefined
+        technology?: string | undefined
+        color?: ThemeColor | undefined
+        line?: RelationshipLineType | undefined
+        head?: RelationshipArrowType | undefined
+        tail?: RelationshipArrowType | undefined
+      } | undefined
       if (relations.length === 1) {
         relation = relations[0]
       } else {
@@ -193,7 +213,7 @@ export class ComputeCtx {
       // This edge represents mutliple relations
       // We use label if only it is the same for all relations
       if (!relation) {
-        const shared = relations.reduce((acc, r) => {
+        relation = relations.reduce((acc, r) => {
           if (r.color && acc.color !== r.color) {
             acc.color = undefined
           }
@@ -206,30 +226,42 @@ export class ComputeCtx {
           if (r.line && acc.line !== r.line) {
             acc.line = undefined
           }
+          if (r.description && acc.description !== r.description) {
+            acc.description = undefined
+          }
+          if (r.technology && acc.technology !== r.technology) {
+            acc.technology = undefined
+          }
           if (isTruthy(r.title) && acc.title !== r.title) {
             acc.title = '[...]'
           }
           return acc
         }, {
-          title: first(flatMap(relations, r => isTruthy(r.title) ? r.title : [])),
+          title: first(flatMap(relations, r => isTruthy(r.title) ? r.title : [])) ?? '[...]',
+          description: first(flatMap(relations, r => isTruthy(r.description) ? r.description : [])),
+          technology: first(flatMap(relations, r => isTruthy(r.technology) ? r.technology : [])),
           head: first(flatMap(relations, r => isTruthy(r.head) ? r.head : [])),
           tail: first(flatMap(relations, r => isTruthy(r.tail) ? r.tail : [])),
           color: first(flatMap(relations, r => isTruthy(r.color) ? r.color : [])),
           line: first(flatMap(relations, r => isTruthy(r.line) ? r.line : []))
         })
-        return Object.assign(
-          edge,
-          isTruthy(shared.title) && { label: shared.title },
-          shared.color && { color: shared.color },
-          shared.line && { line: shared.line },
-          shared.head && { head: shared.head },
-          shared.tail && { tail: shared.tail }
-        )
+        // return Object.assign(
+        //   edge,
+        //   isTruthy(shared.title) && { label: shared.title },
+        //   isTruthy(shared.description) && { description: shared.description },
+        //   isTruthy(shared.technology) && { technology: shared.technology },
+        //   shared.color && { color: shared.color },
+        //   shared.line && { line: shared.line },
+        //   shared.head && { head: shared.head },
+        //   shared.tail && { tail: shared.tail }
+        // )
       }
 
       return Object.assign(
         edge,
         isTruthy(relation.title) && { label: relation.title },
+        isTruthy(relation.description) && { description: relation.description },
+        isTruthy(relation.technology) && { description: relation.technology },
         relation.color && { color: relation.color },
         relation.line && { line: relation.line },
         relation.head && { head: relation.head },
@@ -405,52 +437,12 @@ export class ComputeCtx {
       const isInclude = 'include' in rule
       const exprs = rule.include ?? rule.exclude
       for (const expr of exprs) {
-        if (Expr.isCustomElement(expr)) {
-          if (isInclude) {
-            includeCustomElement.call(this, expr)
-          }
-          continue
-        }
-        if (Expr.isCustomRelationExpr(expr)) {
-          if (isInclude) {
-            includeCustomRelation.call(this, expr)
-          }
-          continue
-        }
-        if (Expr.isExpandedElementExpr(expr)) {
-          if (isInclude) {
-            includeExpandedElementExpr.call(this, expr)
-          }
-          continue
-        }
-        if (Expr.isElementKindExpr(expr) || Expr.isElementTagExpr(expr)) {
-          isInclude
-            ? includeElementKindOrTag.call(this, expr)
-            : excludeElementKindOrTag.call(this, expr)
-          continue
-        }
-        if (Expr.isElementRef(expr)) {
-          isInclude ? includeElementRef.call(this, expr) : excludeElementRef.call(this, expr)
-          continue
-        }
-        if (Expr.isWildcard(expr)) {
-          isInclude ? includeWildcardRef.call(this, expr) : excludeWildcardRef.call(this, expr)
-          continue
-        }
-        if (Expr.isIncoming(expr)) {
-          isInclude ? includeIncomingExpr.call(this, expr) : excludeIncomingExpr.call(this, expr)
-          continue
-        }
-        if (Expr.isOutgoing(expr)) {
-          isInclude ? includeOutgoingExpr.call(this, expr) : excludeOutgoingExpr.call(this, expr)
+        if (Expr.isElementPredicateExpr(expr)) {
+          this.processElementPredicate(expr, isInclude)
           continue
         }
-        if (Expr.isInOut(expr)) {
-          isInclude ? includeInOutExpr.call(this, expr) : excludeInOutExpr.call(this, expr)
-          continue
-        }
-        if (Expr.isRelation(expr)) {
-          isInclude ? includeRelationExpr.call(this, expr) : excludeRelationExpr.call(this, expr)
+        if (Expr.isRelationPredicateExpr(expr)) {
+          this.processRelationPredicate(expr, isInclude)
           continue
         }
         nonexhaustive(expr)
@@ -458,4 +450,78 @@ export class ComputeCtx {
     }
     return this
   }
+
+  protected processElementPredicate(
+    expr: ElementPredicateExpression,
+    isInclude: boolean,
+    where?: ElementPredicateFn
+  ): this {
+    if (Expr.isCustomElement(expr)) {
+      if (isInclude) {
+        this.processElementPredicate(expr.custom.expr, isInclude)
+      }
+      return this
+    }
+    if (Expr.isElementWhere(expr)) {
+      const where = whereOperatorAsPredicate(expr.where.condition)
+      this.processElementPredicate(expr.where.expr, isInclude, where)
+      return this
+    }
+    if (Expr.isExpandedElementExpr(expr)) {
+      isInclude
+        ? includeExpandedElementExpr.call(this, expr, where)
+        : excludeExpandedElementExpr.call(this, expr, where)
+      return this
+    }
+    if (Expr.isElementKindExpr(expr) || Expr.isElementTagExpr(expr)) {
+      isInclude
+        ? includeElementKindOrTag.call(this, expr, where)
+        : excludeElementKindOrTag.call(this, expr, where)
+      return this
+    }
+    if (Expr.isElementRef(expr)) {
+      isInclude ? includeElementRef.call(this, expr, where) : excludeElementRef.call(this, expr, where)
+      return this
+    }
+    if (Expr.isWildcard(expr)) {
+      isInclude ? includeWildcardRef.call(this, expr, where) : excludeWildcardRef.call(this, expr, where)
+      return this
+    }
+    nonexhaustive(expr)
+  }
+
+  protected processRelationPredicate(
+    expr: RelationPredicateExpression,
+    isInclude: boolean,
+    where?: RelationPredicateFn
+  ): this {
+    if (Expr.isCustomRelationExpr(expr)) {
+      if (isInclude) {
+        this.processRelationPredicate(expr.customRelation.relation, isInclude)
+      }
+      return this
+    }
+    if (Expr.isRelationWhere(expr)) {
+      const where = whereOperatorAsPredicate(expr.where.condition)
+      this.processRelationPredicate(expr.where.expr, isInclude, where)
+      return this
+    }
+    if (Expr.isIncoming(expr)) {
+      isInclude ? includeIncomingExpr.call(this, expr, where) : excludeIncomingExpr.call(this, expr, where)
+      return this
+    }
+    if (Expr.isOutgoing(expr)) {
+      isInclude ? includeOutgoingExpr.call(this, expr, where) : excludeOutgoingExpr.call(this, expr, where)
+      return this
+    }
+    if (Expr.isInOut(expr)) {
+      isInclude ? includeInOutExpr.call(this, expr, where) : excludeInOutExpr.call(this, expr, where)
+      return this
+    }
+    if (Expr.isRelation(expr)) {
+      isInclude ? includeRelationExpr.call(this, expr, where) : excludeRelationExpr.call(this, expr, where)
+      return this
+    }
+    nonexhaustive(expr)
+  }
 }