@likec4/language-server 1.14.0 → 1.15.1

package/src/model-graph/utils/buildComputeNodes.ts

@@ -1,5 +1,13 @@
-import type { ComputedNode, Element, Fqn } from '@likec4/core'
-import { compareByFqnHierarchically, DefaultElementShape, DefaultThemeColor, parentFqn } from '@likec4/core'
+import type { ComputedNode, Element, Fqn, NodeId } from '@likec4/core'
+import {
+  compareByFqnHierarchically,
+  DefaultElementShape,
+  DefaultThemeColor,
+  ElementKind,
+  nonNullable,
+  parentFqn
+} from '@likec4/core'
+import { NodesGroup } from '../compute-view/compute'
 
 function updateDepthOfAncestors(node: ComputedNode, nodes: ReadonlyMap<Fqn, ComputedNode>) {
   let parentNd
@@ -14,48 +22,92 @@ function updateDepthOfAncestors(node: ComputedNode, nodes: ReadonlyMap<Fqn, Comp
   }
 }
 
-export function buildComputeNodes(elements: Iterable<Element>) {
+export function buildComputeNodes(elements: Iterable<Element>, groups?: NodesGroup[]) {
+  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)
+    }
+  })
+
   return (
     Array.from(elements)
       // Sort from Top to Bottom
       // So we can ensure that parent nodes are created before child nodes
       .sort(compareByFqnHierarchically)
-      .reduce((map, { id, color, shape, style, ...el }) => {
+      .reduce((map, { id, color, shape, style, kind, title, ...el }) => {
         let parent = parentFqn(id)
         let level = 0
+        let parentNd: ComputedNode | undefined
         // Find the first ancestor that is already in the map
         while (parent) {
-          const parentNd = map.get(parent)
+          parentNd = map.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, map)
-            }
-            parentNd.children.push(id)
-            level = parentNd.level + 1
             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 = map.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, map)
+          }
+          parentNd.children.push(id)
+          level = parentNd.level + 1
+        }
         const node: ComputedNode = {
-          ...el,
           id,
           parent,
-          level,
+          kind,
+          title,
           color: color ?? DefaultThemeColor,
           shape: shape ?? DefaultElementShape,
           children: [],
           inEdges: [],
           outEdges: [],
+          level,
+          ...el,
           style: {
             ...style
           }
         }
         map.set(id, node)
         return map
-      }, new Map<Fqn, ComputedNode>()) as ReadonlyMap<Fqn, ComputedNode>
+      }, nodesMap) as ReadonlyMap<Fqn, ComputedNode>
   )
 }

package/src/model-graph/utils/elementExpressionToPredicate.ts

@@ -4,7 +4,9 @@ import { isNullish } from 'remeda'
 
 type Predicate<T> = (x: T) => boolean
 
-export function elementExprToPredicate(target: Expr.ElementPredicateExpression): Predicate<Element> {
+export function elementExprToPredicate<T extends Pick<Element, 'id' | 'kind' | 'tags'>>(
+  target: Expr.ElementPredicateExpression
+): Predicate<T> {
   if (Expr.isElementWhere(target)) {
     const predicate = elementExprToPredicate(target.where.expr)
     const where = whereOperatorAsPredicate(target.where.condition)

package/src/model-graph/utils/relationExpressionToPredicates.ts

@@ -0,0 +1,43 @@
+import type { Element, Relation } from '@likec4/core'
+import { Expr, nonexhaustive, whereOperatorAsPredicate } from '@likec4/core'
+import { elementExprToPredicate } from './elementExpressionToPredicate'
+
+type Predicate<T> = (x: T) => boolean
+export type FilterableEdge = Pick<Relation, 'kind' | 'tags'> & {
+  source: Element
+  target: Element
+}
+
+export function relationExpressionToPredicates<T extends FilterableEdge>(
+  expr: Expr.RelationExpression | Expr.RelationWhereExpr
+): Predicate<T> {
+  switch (true) {
+    case Expr.isRelationWhere(expr):
+      const predicate = relationExpressionToPredicates(expr.where.expr)
+      const where = whereOperatorAsPredicate(expr.where.condition)
+
+      return e => predicate(e) && where(e)
+    case Expr.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 Expr.isInOut(expr): {
+      const isInOut = elementExprToPredicate(expr.inout)
+      return edge => isInOut(edge.source) || isInOut(edge.target)
+    }
+    case Expr.isIncoming(expr): {
+      const isTarget = elementExprToPredicate(expr.incoming)
+      return edge => isTarget(edge.target)
+    }
+    case Expr.isOutgoing(expr): {
+      const isSource = elementExprToPredicate(expr.outgoing)
+      return edge => isSource(edge.source)
+    }
+    default:
+      nonexhaustive(expr)
+  }
+}

package/src/model-graph/utils/sortNodes.ts

@@ -8,7 +8,7 @@ import {
   invariant,
   nonNullable
 } from '@likec4/core'
-import { difference, filter, map, pipe, sort } from 'remeda'
+import { difference, filter, map, pipe, sort, tap } from 'remeda'
 import { Graph, postorder } from '../../utils/graphlib'
 
 // side effect
@@ -27,9 +27,16 @@ export function sortNodes({
   nodes: ComputedNode[]
   edges: ComputedEdge[]
 }): ComputedNode[] {
-  if (edges.length === 0) {
+  if (nodes.length < 2) {
     return nodes
   }
+  if (edges.length === 0) {
+    return pipe(
+      nodes,
+      sort(compareByFqnHierarchically),
+      tap(sortChildren)
+    )
+  }
 
   const g = new Graph({
     compound: false,
@@ -55,9 +62,6 @@ export function sortNodes({
   for (const n of nodes) {
     g.setNode(n.id, n.id)
     if (n.children.length > 0) {
-      // n.children.forEach(c => {
-      //   g.setEdge(n.id, c, undefined, `${n.id}:${c}`)
-      // })
       n.inEdges.forEach(e => {
         const edge = getEdge(e)
         // if this edge from leaf to the child of this node
@@ -83,15 +87,15 @@ export function sortNodes({
   if (sources.length === 0) {
     sources = pipe(
       nodes,
-      sort(compareByFqnHierarchically),
       filter(n => n.inEdges.length === 0 || n.parent === null),
+      sort(compareByFqnHierarchically),
       map(n => n.id)
     )
   }
   const orderedIds = postorder(g, sources).reverse() as Fqn[]
   const sorted = orderedIds.map(getNode)
   if (sorted.length < nodes.length) {
-    const unsorted = difference(nodes, sorted)
+    const unsorted = difference(nodes, sorted).sort(compareByFqnHierarchically)
     sorted.push(...unsorted)
   }
 

package/src/references/scope-computation.ts

@@ -71,8 +71,9 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
     }
     for (const globalStyleAst of globals.flatMap(g => g.styles)) {
       try {
-        if (isTruthy(globalStyleAst.name)) {
-          docExports.push(this.descriptions.createDescription(globalStyleAst, globalStyleAst.name, document))
+        const id = globalStyleAst.id
+        if (isTruthy(id.name)) {
+          docExports.push(this.descriptions.createDescription(id, id.name, document))
         }
       } catch (e) {
         logError(e)

package/src/validation/index.ts

@@ -9,7 +9,7 @@ import { relationBodyChecks, relationChecks } from './relation'
 import {
   elementKindChecks,
   globalsChecks,
-  globalStyleChecks,
+  globalStyleIdChecks,
   modelRuleChecks,
   relationshipChecks,
   specificationRuleChecks,
@@ -34,7 +34,7 @@ export function registerValidationChecks(services: LikeC4Services) {
     SpecificationRule: specificationRuleChecks(services),
     Model: modelRuleChecks(services),
     Globals: globalsChecks(services),
-    GlobalStyle: globalStyleChecks(services),
+    GlobalStyleId: globalStyleIdChecks(services),
     DynamicViewStep: dynamicViewStep(services),
     LikeC4View: viewChecks(services),
     Element: elementChecks(services),

package/src/validation/specification.ts

@@ -130,18 +130,18 @@ export const relationshipChecks = (
   }
 }
 
-export const globalStyleChecks = (
+export const globalStyleIdChecks = (
   services: LikeC4Services
-): ValidationCheck<ast.GlobalStyle> => {
+): ValidationCheck<ast.GlobalStyleId> => {
   const index = services.shared.workspace.IndexManager
   return (node, accept) => {
     const sameName = index
-      .allElements(ast.GlobalStyle)
+      .allElements(ast.GlobalStyleId)
       .filter(s => s.name === node.name)
       .limit(2)
       .count()
     if (sameName > 1) {
-      accept('error', `Duplicate GlobalStyle name '${node.name}'`, {
+      accept('error', `Duplicate GlobalStyleId name '${node.name}'`, {
         node: node,
         property: 'name'
       })