@likec4/language-server 1.19.1 → 1.20.0

package/src/like-c4.langium

@@ -413,11 +413,13 @@ WhereRelationNegation:
 
 WhereRelation:
   {infer WhereRelationTag} 'tag' EqOperator value=[Tag:TagId]? |
-  {infer WhereRelationKind} 'kind' EqOperator value=[RelationshipKind:Id]?
+  {infer WhereRelationKind} 'kind' EqOperator value=[RelationshipKind:Id]? |
+  {infer WhereRelationParticipantTag} participant=Participant StickyDot 'tag' EqOperator value=[Tag:TagId]? |
+  {infer WhereRelationParticipantKind} participant=Participant StickyDot 'kind' EqOperator value=[DeploymentNodeOrElementKind:Id]?
 ;
-
-type WhereTagEqual = WhereElementTag | WhereRelationTag;
-type WhereKindEqual = WhereElementKind | WhereRelationKind;
+type DeploymentNodeOrElementKind = ElementKind | DeploymentNodeKind
+type WhereTagEqual = WhereElementTag | WhereRelationTag | WhereRelationParticipantTag;
+type WhereKindEqual = WhereElementKind | WhereRelationKind | WhereRelationParticipantKind;
 
 type WhereExpression = WhereElementExpression | WhereRelationExpression;
 
@@ -620,10 +622,13 @@ DeploymentViewRulePredicateExpression:
 ;
 
 ExpressionV2:
-  RelationExpr |
+  RelationPredicateOrWhereV2 |
   FqnExpr
 ;
 
+RelationPredicateOrWhereV2:
+  RelationExpr ({infer RelationPredicateWhereV2.subject=current} 'where' where=WhereRelationExpression?)?
+;
 
 FqnExpr:
   {infer WildcardExpression} isWildcard?='*' |
@@ -766,6 +771,8 @@ ThemeColor returns string:
   'primary' | 'secondary' | 'muted' | 'slate' | 'blue' | 'indigo' | 'sky' | 'red' | 'gray' | 'green' | 'amber';
 ElementShape returns string:
   'rectangle' | 'person' | 'browser' | 'mobile' | 'cylinder' | 'storage' | 'queue';
+Participant returns string:
+  'source' | 'target';
 
 CustomColorValue returns string:
   Hash (Id | Hex | Number);
@@ -786,7 +793,7 @@ CustomColorId returns string:
   IdTerminal | ElementShape | ArrowType | LineOptions | 'element' | 'model';
 
 Id returns string:
-  IdTerminal | ElementShape | ThemeColor | ArrowType | LineOptions | 'element' | 'model' | 'group' | 'node' | 'deployment' | 'instance';
+  IdTerminal | ElementShape | ThemeColor | ArrowType | LineOptions | Participant | 'element' | 'model' | 'group' | 'node' | 'deployment' | 'instance';
 
 fragment EqOperator:
   (

package/src/lsp/SemanticTokenProvider.ts

@@ -1,5 +1,5 @@
 import type { AstNode } from 'langium'
-import { AbstractSemanticTokenProvider, type SemanticTokenAcceptor } from 'langium/lsp'
+import { type SemanticTokenAcceptor, AbstractSemanticTokenProvider } from 'langium/lsp'
 import { isTruthy } from 'remeda'
 import { SemanticTokenModifiers, SemanticTokenTypes } from 'vscode-languageserver-types'
 import { ast } from '../ast'
@@ -8,7 +8,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
   // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
   protected override highlightElement(
     node: AstNode,
-    acceptor: SemanticTokenAcceptor
+    acceptor: SemanticTokenAcceptor,
   ): void | undefined | 'prune' {
     if (ast.isElement(node) || ast.isDeploymentNode(node)) {
       return this.highlightNameAndKind(node, acceptor)
@@ -21,8 +21,8 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
           type: SemanticTokenTypes.variable,
           modifier: [
             SemanticTokenModifiers.definition,
-            SemanticTokenModifiers.readonly
-          ]
+            SemanticTokenModifiers.readonly,
+          ],
         })
       }
       return
@@ -34,7 +34,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       return acceptor({
         node,
         property: 'name',
-        type: SemanticTokenTypes.function
+        type: SemanticTokenTypes.function,
       })
     }
     if (ast.isLibIcon(node)) {
@@ -42,7 +42,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         node,
         property: 'name',
         type: SemanticTokenTypes.type,
-        modifier: [SemanticTokenModifiers.definition]
+        modifier: [SemanticTokenModifiers.definition],
       })
       return 'prune'
     }
@@ -51,7 +51,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       acceptor({
         node,
         property: 'kind',
-        type: SemanticTokenTypes.function
+        type: SemanticTokenTypes.function,
       })
       return
     }
@@ -59,14 +59,14 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       acceptor({
         node,
         property: 'kind',
-        type: SemanticTokenTypes.function
+        type: SemanticTokenTypes.function,
       })
     }
     if (ast.isNavigateToProperty(node) || ast.isRelationNavigateToProperty(node)) {
       acceptor({
         node,
         property: 'key',
-        type: SemanticTokenTypes.property
+        type: SemanticTokenTypes.property,
       })
       acceptor({
         node,
@@ -74,8 +74,8 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         type: SemanticTokenTypes.variable,
         modifier: [
           SemanticTokenModifiers.definition,
-          SemanticTokenModifiers.readonly
-        ]
+          SemanticTokenModifiers.readonly,
+        ],
       })
       return 'prune'
     }
@@ -85,8 +85,8 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         type: SemanticTokenTypes.variable,
         modifier: [
           SemanticTokenModifiers.definition,
-          SemanticTokenModifiers.readonly
-        ]
+          SemanticTokenModifiers.readonly,
+        ],
       })
       return 'prune'
     }
@@ -98,8 +98,8 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
           type: SemanticTokenTypes.variable,
           modifier: [
             SemanticTokenModifiers.definition,
-            SemanticTokenModifiers.readonly
-          ]
+            SemanticTokenModifiers.readonly,
+          ],
         })
       }
       return
@@ -108,7 +108,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       acceptor({
         node,
         property: 'value',
-        type: SemanticTokenTypes.function
+        type: SemanticTokenTypes.function,
       })
       return
     }
@@ -119,17 +119,24 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         type: SemanticTokenTypes.type,
         modifier: [
           SemanticTokenModifiers.definition,
-          SemanticTokenModifiers.readonly
-        ]
+          SemanticTokenModifiers.readonly,
+        ],
       })
       return
     }
+    if ((ast.isWhereRelationParticipantKind(node) || ast.isWhereRelationParticipantTag(node))) {
+      acceptor({
+        node,
+        property: 'participant',
+        type: SemanticTokenTypes.keyword,
+      })
+    }
     if (ast.isElementKindExpression(node) && isTruthy(node.kind)) {
       acceptor({
         node,
         property: 'kind',
         type: SemanticTokenTypes.type,
-        modifier: [SemanticTokenModifiers.definition]
+        modifier: [SemanticTokenModifiers.definition],
       })
       return 'prune'
     }
@@ -138,7 +145,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         node,
         property: 'tag',
         type: SemanticTokenTypes.type,
-        modifier: [SemanticTokenModifiers.definition]
+        modifier: [SemanticTokenModifiers.definition],
       })
       return 'prune'
     }
@@ -149,8 +156,8 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         type: node.parent ? SemanticTokenTypes.property : SemanticTokenTypes.variable,
         modifier: [
           SemanticTokenModifiers.definition,
-          SemanticTokenModifiers.readonly
-        ]
+          SemanticTokenModifiers.readonly,
+        ],
       })
       return !node.parent ? 'prune' : undefined
     }
@@ -161,8 +168,8 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         type: node.parent ? SemanticTokenTypes.property : SemanticTokenTypes.variable,
         modifier: [
           SemanticTokenModifiers.definition,
-          SemanticTokenModifiers.readonly
-        ]
+          SemanticTokenModifiers.readonly,
+        ],
       })
       return !node.parent ? 'prune' : undefined
     }
@@ -170,7 +177,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       acceptor({
         node,
         keyword: 'color',
-        type: SemanticTokenTypes.keyword
+        type: SemanticTokenTypes.keyword,
       })
       acceptor({
         node,
@@ -178,8 +185,8 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         type: SemanticTokenTypes.type,
         modifier: [
           SemanticTokenModifiers.declaration,
-          SemanticTokenModifiers.readonly
-        ]
+          SemanticTokenModifiers.readonly,
+        ],
       })
       return
     }
@@ -193,15 +200,15 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         type: SemanticTokenTypes.type,
         modifier: [
           SemanticTokenModifiers.declaration,
-          SemanticTokenModifiers.readonly
-        ]
+          SemanticTokenModifiers.readonly,
+        ],
       })
     }
     if (ast.isTags(node)) {
       return acceptor({
         node,
         property: 'values',
-        type: SemanticTokenTypes.interface
+        type: SemanticTokenTypes.interface,
       })
     }
     if (ast.isTag(node)) {
@@ -209,7 +216,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         node,
         property: 'name',
         type: SemanticTokenTypes.type,
-        modifier: [SemanticTokenModifiers.definition]
+        modifier: [SemanticTokenModifiers.definition],
       })
     }
     if (
@@ -219,19 +226,19 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       acceptor({
         node,
         property: 'key',
-        type: SemanticTokenTypes.property
+        type: SemanticTokenTypes.property,
       })
     }
     if (ast.isOpacityProperty(node)) {
       acceptor({
         node,
         property: 'key',
-        type: SemanticTokenTypes.property
+        type: SemanticTokenTypes.property,
       })
       acceptor({
         node,
         property: 'value',
-        type: SemanticTokenTypes.number
+        type: SemanticTokenTypes.number,
       })
       return 'prune'
     }
@@ -243,14 +250,14 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       acceptor({
         node,
         property: 'key',
-        type: SemanticTokenTypes.property
+        type: SemanticTokenTypes.property,
       })
       if (ast.isIconProperty(node) && (node.libicon || node.value === 'none')) {
         acceptor({
           node,
           property: node.libicon ? 'libicon' : 'value',
           type: SemanticTokenTypes.enum,
-          modifier: [SemanticTokenModifiers.defaultLibrary]
+          modifier: [SemanticTokenModifiers.defaultLibrary],
         })
         return 'prune'
       }
@@ -258,7 +265,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         acceptor({
           node,
           property: 'value',
-          type: SemanticTokenTypes.string
+          type: SemanticTokenTypes.string,
         })
       }
       return 'prune'
@@ -273,13 +280,13 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       acceptor({
         node,
         property: 'key',
-        type: SemanticTokenTypes.property
+        type: SemanticTokenTypes.property,
       })
       if ('value' in node) {
         acceptor({
           node,
           property: 'value',
-          type: SemanticTokenTypes.enum
+          type: SemanticTokenTypes.enum,
         })
       }
       return 'prune'
@@ -293,14 +300,14 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       type: SemanticTokenTypes.variable,
       modifier: [
         SemanticTokenModifiers.declaration,
-        SemanticTokenModifiers.readonly
-      ]
+        SemanticTokenModifiers.readonly,
+      ],
     })
     acceptor({
       node,
       property: 'kind',
       type: SemanticTokenTypes.keyword,
-      modifier: []
+      modifier: [],
     })
   }
 
@@ -313,8 +320,8 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         modifier: [
           SemanticTokenModifiers.declaration,
           SemanticTokenModifiers.readonly,
-          'local'
-        ]
+          'local',
+        ],
       })
     }
   }

package/src/model/model-parser-where.ts

@@ -5,40 +5,48 @@ import { ast } from '../ast'
 
 const parseEquals = (
   { operator, not }: ast.WhereKindEqual | ast.WhereTagEqual,
-  value: string
+  value: string,
 ): c4.EqualOperator<string> => {
   if (operator.startsWith('!=')) {
     return {
-      neq: value
+      neq: value,
     }
   }
   if (operator.startsWith('=')) {
     return {
-      eq: value
+      eq: value,
     }
   }
   return not ? { neq: value } : { eq: value }
 }
 
+function parseParticipant(astNode: ast.WhereExpression): ast.Participant | null {
+  if (!ast.isWhereRelationParticipantKind(astNode) && !ast.isWhereRelationParticipantTag(astNode)) {
+    return null
+  }
+
+  return astNode.participant
+}
+
 export function parseWhereClause(astNode: ast.WhereExpression): c4.WhereOperator<string, string> {
   switch (true) {
     case ast.isWhereTagEqual(astNode): {
       const tag = astNode.value?.ref?.name
+      const participant = parseParticipant(astNode)
       invariant(tag, 'Expected tag name')
-      return {
-        tag: parseEquals(astNode, tag)
-      }
+      const tagOperator = { tag: parseEquals(astNode, tag) }
+      return participant ? { participant, operator: tagOperator } : tagOperator
     }
     case ast.isWhereKindEqual(astNode): {
       const kind = astNode.value?.ref?.name
+      const participant = parseParticipant(astNode)
       invariant(kind, 'Expected kind name')
-      return {
-        kind: parseEquals(astNode, kind)
-      }
+      const kindOperator = { kind: parseEquals(astNode, kind) }
+      return participant ? { participant, operator: kindOperator } : kindOperator
     }
     case ast.isWhereElementNegation(astNode) || ast.isWhereRelationNegation(astNode): {
       return {
-        not: parseWhereClause(astNode.value)
+        not: parseWhereClause(astNode.value),
       }
     }
     case ast.isWhereBinaryExpression(astNode): {
@@ -49,21 +57,21 @@ export function parseWhereClause(astNode: ast.WhereExpression): c4.WhereOperator
         case 'and': {
           const operands = [
             isAndOperator(left) ? left.and : left,
-            isAndOperator(right) ? right.and : right
+            isAndOperator(right) ? right.and : right,
           ].flat()
           invariant(isNonEmptyArray(operands), 'Expected non-empty array')
           return {
-            and: operands
+            and: operands,
           }
         }
         case 'or': {
           const operands = [
             isOrOperator(left) ? left.or : left,
-            isOrOperator(right) ? right.or : right
+            isOrOperator(right) ? right.or : right,
           ].flat()
           invariant(isNonEmptyArray(operands), 'Expected non-empty array')
           return {
-            or: operands
+            or: operands,
           }
         }
         default:

package/src/model/parser/DeploymentViewParser.ts

@@ -1,7 +1,7 @@
 import type * as c4 from '@likec4/core'
-import { FqnExpr, invariant, isNonEmptyArray, nonexhaustive } from '@likec4/core'
+import { invariant, isNonEmptyArray, nonexhaustive } from '@likec4/core'
 import { isNonNullish } from 'remeda'
-import { ast, type ParsedAstDeploymentView, toAutoLayout, toElementStyle, ViewOps } from '../../ast'
+import { type ParsedAstDeploymentView, ast, toAutoLayout, toElementStyle, ViewOps } from '../../ast'
 import { logWarnError } from '../../logger'
 import { stringHash } from '../../utils'
 import { parseViewManualLayout } from '../../view-utils/manual-layout'
@@ -14,7 +14,7 @@ export type WithDeploymentView = ReturnType<typeof DeploymentViewParser>
 export function DeploymentViewParser<TBase extends WithExpressionV2 & WithDeploymentModel>(B: TBase) {
   return class DeploymentViewParser extends B {
     parseDeploymentView(
-      astNode: ast.DeploymentView
+      astNode: ast.DeploymentView,
     ): ParsedAstDeploymentView {
       const body = astNode.body
       invariant(body, 'DynamicElementView body is not defined')
@@ -26,7 +26,7 @@ export function DeploymentViewParser<TBase extends WithExpressionV2 & WithDeploy
       if (!id) {
         id = 'deployment_' + stringHash(
           this.doc.uri.toString(),
-          astPath
+          astPath,
         ) as c4.ViewId
       }
 
@@ -56,7 +56,7 @@ export function DeploymentViewParser<TBase extends WithExpressionV2 & WithDeploy
             return []
           }
         }),
-        ...(manualLayout && { manualLayout })
+        ...(manualLayout && { manualLayout }),
       }
     }
 
@@ -87,6 +87,9 @@ export function DeploymentViewParser<TBase extends WithExpressionV2 & WithDeploy
               case ast.isRelationExpr(expr):
                 exprs.unshift(this.parseRelationExpr(expr))
                 break
+              case ast.isRelationPredicateWhereV2(expr):
+                exprs.unshift(this.parseRelationWhereExpr(expr))
+                break
               default:
                 nonexhaustive(expr)
             }
@@ -108,8 +111,8 @@ export function DeploymentViewParser<TBase extends WithExpressionV2 & WithDeploy
         targets,
         ...(notation && { notation }),
         style: {
-          ...toElementStyle(styleProps, this.isValid)
-        }
+          ...toElementStyle(styleProps, this.isValid),
+        },
       }
     }
   }

package/src/model/parser/FqnRefParser.ts

@@ -4,6 +4,7 @@ import { isNonNullish } from 'remeda'
 import { ast } from '../../ast'
 import { logWarnError } from '../../logger'
 import { instanceRef } from '../../utils/fqnRef'
+import { parseWhereClause } from '../model-parser-where'
 import type { Base } from './Base'
 
 export type WithExpressionV2 = ReturnType<typeof ExpressionV2Parser>
@@ -89,7 +90,20 @@ export function ExpressionV2Parser<TBase extends Base>(B: TBase) {
       return exprs.reverse()
     }
 
+    parseRelationWhereExpr(astNode: ast.RelationPredicateWhereV2): c4.RelationExpr {
+      return {
+        where: {
+          expr: this.parseRelationExpr(astNode.subject as ast.RelationExpr),
+          condition: astNode.where ? parseWhereClause(astNode.where) : {
+            kind: { neq: '--always-true--' },
+          },
+        },
+      }
+    }
+
     parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr {
+      if (ast.isRelationPredicateWhere(astNode)) {
+      }
       if (ast.isDirectedRelationExpr(astNode)) {
         return {
           source: this.parseFqnExpr(astNode.source.from),