@likec4/language-server 1.6.1 → 1.7.1

package/src/like-c4.langium

@@ -111,18 +111,24 @@ ExtendElementBody:  '{'
 
 //
 FqnElementRef:
-  el=[Element] ({infer FqnElementRef.parent=current} dot=StickyDot el=[Element])*;
+  el=[Element:Id] ({infer FqnElementRef.parent=current} StickyDot el=[Element:Id])*;
 
 ElementRef:
-  el=[Element] ({infer ElementRef.parent=current} dot=StickyDot el=[Element])*;
+  el=[Element:Id] ({infer ElementRef.parent=current} StickyDot el=[Element:Id])*;
 
 Tags:
-  value+=[Tag:TagId] (','? value+=[Tag:TagId])* (';')?
+  (values+=[Tag:TagId])+ ({infer Tags.prev=current} ',' (values+=[Tag:TagId])*)* ';'?
 ;
 
 Relation:
   ExplicitRelation | ImplicitRelation;
 
+ExplicitRelation:
+  source=ElementRef RelationFragment;
+
+ImplicitRelation:
+  ('this' | 'it')? RelationFragment;
+
 fragment RelationFragment:
   ('->' | '-[' kind=[RelationshipKind] ']->' | kind=[RelationshipKind:DotId] )
   target=ElementRef
@@ -131,12 +137,6 @@ fragment RelationFragment:
   body=RelationBody?
 ;
 
-ExplicitRelation:
-  source=ElementRef RelationFragment;
-
-ImplicitRelation:
-  ('this' | 'it')? RelationFragment;
-
 RelationBody: '{'
   tags=Tags?
   props+=RelationProperty*
@@ -147,7 +147,7 @@ RelationProperty:
   RelationStringProperty | RelationStyleProperty |  LinkProperty;
 
 RelationStringProperty:
-  key='title' ':'? value=String ';'?;
+  key=('title' | 'technology' | 'description') ':'? value=String ';'?;
 
 RelationStyleProperty:
   key='style' '{'
@@ -160,24 +160,23 @@ RelationStyleProperty:
 
 ModelViews:
   name='views' '{'
-    views+=(
-      DynamicView |
-      ElementView
-    )*
+    views+=LikeC4ViewRule*
   '}';
 
 type LikeC4View = ElementView | DynamicView;
+LikeC4ViewRule returns LikeC4View:
+  ElementView | DynamicView;
 
 ElementView:
   'view' name=Id? (
     'extends' extends=ElementViewRef |
     'of' viewOf=ElementRef
   )?
-  body=ElementViewBody
+  body=ElementViewBody?
 ;
 
 DynamicView:
-  'dynamic' 'view' name=Id body=DynamicViewBody
+  'dynamic' 'view' name=Id body=DynamicViewBody?
 ;
 
 ViewRef:
@@ -201,7 +200,7 @@ DynamicViewBody: '{'
 ;
 
 
-type StringProperty = ElementStringProperty| ViewStringProperty | RelationStringProperty;
+type StringProperty = ElementStringProperty | ViewStringProperty | RelationStringProperty;
 
 ViewProperty:
   ViewStringProperty | LinkProperty
@@ -220,34 +219,65 @@ ViewRule:
 ;
 
 DynamicViewRule:
-  DynamicViewRulePredicate |
+  DynamicViewIncludePredicate |
   ViewRuleStyle |
   ViewRuleAutoLayout
 ;
 
 DynamicViewStep:
-  source=ElementRef (isBackward?='<-' |  '->' | '-[' kind=[RelationshipKind] ']->' | kind=[RelationshipKind:DotId] ) target=ElementRef title=String?
+  source=ElementRef
+  (isBackward?='<-' |  '->' | '-[' kind=[RelationshipKind] ']->' | kind=[RelationshipKind:DotId] )
+  target=ElementRef
+  title=String?
+  custom=CustomRelationProperties?
 ;
 
 ViewRulePredicate:
-  {infer IncludePredicate} 'include' exprs=Expressions |
-  {infer ExcludePredicate} 'exclude' exprs=Expressions
+  {infer IncludePredicate} 'include' predicates=Predicates |
+  {infer ExcludePredicate} 'exclude' predicates=Predicates
+;
+Predicates:
+  value=Predicate ({infer Predicates.prev=current} ',' value=Predicate?)*
 ;
 
-// IncludePredicate:
-//   'include' expr=WithExpressions ({infer IncludePredicate.prev=current} ',' (expr=WithExpressions)?)*
-// ;
-// ExcludePredicate:
-//   'exclude' expr=WithExpressions ({infer ExcludePredicate.prev=current} ',' (expr=WithExpressions)?)*
-// ;
+Predicate:
+  RelationPredicate |
+  ElementPredicate
+;
 
-Expressions:
-  value=WithExpressions ({infer Expressions.prev=current} ',' (value=WithExpressions)?)*
+ElementPredicate:
+  ElementPredicates;
+
+ElementPredicates infers ElementPredicate:
+  ElementPredicateOrWhere ({infer ElementPredicateWith.subject=current} 'with' custom=CustomElementProperties?)?
 ;
 
-WithExpressions infers Expression:
-  RelationExpression ({infer CustomRelationExpression.relation=current} 'with' custom=CustomRelationProperties)? |
-  ElementExpression ({infer CustomElementExpression.target=current} 'with' custom=CustomElementProperties)?
+ElementPredicateOrWhere:
+  ElementExpression ({infer ElementPredicateWhere.subject=current} 'where' where=WhereElementExpression?)?
+;
+
+WhereElementExpression:
+  WhereElementOr
+;
+WhereElementOr infers WhereElementExpression:
+  WhereElementAnd ({infer WhereBinaryExpression.left=current} operator='or' right=WhereElementAnd)*
+;
+WhereElementAnd infers WhereElementExpression:
+  WhereElementPrimary ({infer WhereBinaryExpression.left=current} operator='and' right=WhereElementPrimary)*
+;
+
+WhereElementPrimary infers WhereElementExpression:
+  '(' WhereElementExpression ')' |
+  WhereElementNegation |
+  WhereElement
+;
+
+WhereElementNegation:
+  'not' value=WhereElementExpression;
+
+WhereElement:
+  {infer WhereElementTag} 'tag' EqOperator value=[Tag:TagId]? |
+  {infer WhereElementKind} 'kind' EqOperator value=[ElementKind]?
 ;
 
 ElementExpression:
@@ -268,6 +298,48 @@ ElementDescedantsExpression infers ElementExpression:
   )?
 ;
 
+RelationPredicate:
+  RelationPredicates
+;
+
+RelationPredicates infers RelationPredicate:
+  RelationPredicateOrWhere ({infer RelationPredicateWith.subject=current} 'with' custom=CustomRelationProperties?)?
+;
+
+RelationPredicateOrWhere:
+  RelationExpression ({infer RelationPredicateWhere.subject=current} 'where' where=WhereRelationExpression?)?
+;
+
+WhereRelationExpression:
+  WhereRelationOr
+;
+
+WhereRelationOr infers WhereRelationExpression:
+  WhereRelationAnd ({infer WhereBinaryExpression.left=current} operator='or' right=WhereRelationAnd)*
+;
+WhereRelationAnd infers WhereRelationExpression:
+  WhereRelationPrimary ({infer WhereBinaryExpression.left=current} operator='and' right=WhereRelationPrimary)*
+;
+
+WhereRelationPrimary infers WhereRelationExpression:
+  '(' WhereRelationExpression ')' |
+  WhereRelationNegation |
+  WhereRelation
+;
+
+WhereRelationNegation:
+  'not' value=WhereRelationExpression;
+
+WhereRelation:
+  {infer WhereRelationTag} 'tag' EqOperator value=[Tag:TagId]? |
+  {infer WhereRelationKind} 'kind' EqOperator value=[RelationshipKind]?
+;
+
+type WhereTagEqual = WhereElementTag | WhereRelationTag;
+type WhereKindEqual = WhereElementKind | WhereRelationKind;
+
+type WhereExpression = WhereElementExpression | WhereRelationExpression;
+
 RelationExpression:
   InOutRelationExpressions |
   DirectedRelationExpressions
@@ -294,16 +366,12 @@ ElementExpressionsIterator:
   value=ElementExpression ({infer ElementExpressionsIterator.prev=current} ',' (value=ElementExpression)?)*
 ;
 
-DynamicViewRulePredicate:
-  'include' exprs=DynamicViewRulePredicateIterator
+DynamicViewIncludePredicate:
+  'include' predicates=DynamicViewPredicateIterator
 ;
 
-DynamicViewRulePredicateIterator:
-  value=DynamicViewElementExpressions ({infer DynamicViewRulePredicateIterator.prev=current} ',' (value=DynamicViewElementExpressions)?)*
-;
-
-DynamicViewElementExpressions infers DynamicViewElementExpression:
-  ElementExpression ({infer CustomElementExpression.target=current} 'with' custom=CustomElementProperties)?
+DynamicViewPredicateIterator:
+  value=ElementPredicate ({infer DynamicViewPredicateIterator.prev=current} ',' (value=ElementPredicate)?)*
 ;
 
 ViewRuleStyle:
@@ -407,13 +475,10 @@ ElementShape returns string:
 
 IconId returns string:
   LIB_ICON;
-  // ('aws:' | 'gcp:' | 'tech:') IdTerminal;
 
 Uri returns string:
   URI_WITH_SCHEMA | URI_RELATIVE;
 
-// Percent returns string: PERCENT;
-
 TagId returns string:
   Hash Id;
 
@@ -423,6 +488,13 @@ DotId returns string:
 Id returns string:
   IdTerminal | ElementShape | ThemeColor | ArrowType | LineOptions | 'element' | 'model';
 
+fragment EqOperator:
+  (
+    operator=(Eq | NotEqual) |
+    operator="is" not?='not'?
+  )
+;
+
 fragment IsEqual:
   isEqual?=Eq | NotEqual;
 
@@ -447,7 +519,7 @@ hidden terminal WS: /\s+/;
 //terminal LineStartWithDash: /(?<=([\r?\n][^\S\r\n]*))-/;
 
 // LibIcons
-terminal LIB_ICON: /\b(aws|gcp|tech):[-\w]*/;
+terminal LIB_ICON: /(aws|gcp|tech):[-\w]*/;
 
 terminal URI_WITH_SCHEMA: /\w+:\/\/\S+/;
 terminal URI_RELATIVE: /\.{0,2}\/[^\/]\S+/;

package/src/logger.ts

@@ -1,68 +1,89 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { normalizeError } from '@likec4/core'
+import { type ConsolaReporter, LogLevels, rootLogger as root } from '@likec4/log'
+import type { Connection } from 'vscode-languageserver'
 
-/* eslint-disable @typescript-eslint/no-redundant-type-constituents */
-let isSilent = false
+export const logger = root.withTag('lsp')
 
-export const logger = {
-  trace(message: string) {
-    if (isSilent) return
-    console.trace(message)
-  },
-  debug(message: string) {
-    if (isSilent) return
-    console.debug(message)
-  },
-  info(message: string) {
-    if (isSilent) return
-    console.info(message)
-  },
-  warn(message: unknown) {
-    if (isSilent) return
-    if (typeof message === 'string' || message instanceof Error) {
-      console.warn(message)
-      return
-    }
-    const error = normalizeError(message)
-    console.warn(`${error.name}: ${error.message}`)
-  },
-  error(message: unknown) {
-    if (isSilent) return
-    if (typeof message === 'string' || message instanceof Error) {
-      console.error(message)
-      return
-    }
-    const error = normalizeError(message)
-    console.error(`${error.name}: ${error.message}`, error)
-  },
-  silent(silent = true) {
-    isSilent = silent
-  }
+export function logError(err: unknown): void {
+  logger.error(err)
 }
 
-export type Logger = typeof logger
-
-export function logError(err: unknown): void {
-  if (typeof err === 'string') {
-    logger.error(err)
-    return
-  }
+export function logWarnError(err: unknown): void {
   if (err instanceof Error) {
-    logger.error(err.stack ?? err.message)
+    logger.warn(err.stack ?? err.message)
     return
   }
-  logger.error(normalizeError(err))
+  logger.warn(err)
 }
 
-export function logWarnError(err: unknown): void {
-  if (typeof err === 'string') {
-    logger.warn(err)
-    return
+export function setLogLevel(level: keyof typeof LogLevels): void {
+  logger.level = LogLevels[level]
+}
+
+export function logErrorToTelemetry(connection: Connection): void {
+  const reporter: ConsolaReporter = {
+    log: ({ level, ...logObj }, ctx) => {
+      if (level !== LogLevels.error && level !== LogLevels.fatal) {
+        return
+      }
+      const tag = logObj.tag || ''
+      const parts = logObj.args.map((arg) => {
+        if (arg && typeof arg.stack === 'string') {
+          return arg.message + '\n' + arg.stack
+        }
+        if (typeof arg === 'string') {
+          return arg
+        }
+        return String(arg)
+      })
+      if (tag) {
+        parts.unshift(`[${tag}]`)
+      }
+      const message = parts.join(' ')
+      connection.telemetry.logEvent({ eventName: 'error', error: message })
+    }
   }
-  if (err instanceof Error) {
-    logger.warn(err.stack ?? err.message)
-    return
+  root.addReporter(reporter)
+  logger.setReporters(root.options.reporters)
+}
+
+export function logToLspConnection(connection: Connection): void {
+  const reporter: ConsolaReporter = {
+    log: ({ level, ...logObj }, ctx) => {
+      const tag = logObj.tag || ''
+      const parts = logObj.args.map((arg) => {
+        if (arg && typeof arg.stack === 'string') {
+          return arg.message + '\n' + arg.stack
+        }
+        if (typeof arg === 'string') {
+          return arg
+        }
+        return String(arg)
+      })
+      if (tag) {
+        parts.unshift(`[${tag}]`)
+      }
+      const message = parts.join(' ')
+      switch (true) {
+        case level >= LogLevels.debug: {
+          connection.console.debug(message)
+          break
+        }
+        case level >= LogLevels.log: {
+          connection.console.info(message)
+          break
+        }
+        case level >= LogLevels.warn: {
+          connection.console.warn(message)
+          break
+        }
+        case level >= LogLevels.fatal: {
+          connection.console.error(message)
+          break
+        }
+      }
+    }
   }
-  const error = normalizeError(err)
-  logger.warn(`${error.name}: ${error.message}`)
+  root.addReporter(reporter)
+  logger.setReporters(root.options.reporters)
 }

package/src/lsp/DocumentLinkProvider.ts

@@ -2,7 +2,7 @@ import type { LangiumDocument, MaybePromise } from 'langium'
 import { AstUtils, GrammarUtils } from 'langium'
 import type { DocumentLinkProvider } from 'langium/lsp'
 import { hasProtocol, isRelative, withBase } from 'ufo'
-import type { DocumentLink, DocumentLinkParams } from 'vscode-languageserver-protocol'
+import type { DocumentLink, DocumentLinkParams } from 'vscode-languageserver'
 import { ast, isParsedLikeC4LangiumDocument } from '../ast'
 import { logError } from '../logger'
 import type { LikeC4Services } from '../module'

package/src/lsp/DocumentSymbolProvider.ts

@@ -2,7 +2,7 @@ import { nonexhaustive } from '@likec4/core'
 import { type AstNode, GrammarUtils, type MaybePromise } from 'langium'
 import type { DocumentSymbolProvider, NodeKindProvider } from 'langium/lsp'
 import { filter, isEmpty, isTruthy, map, pipe } from 'remeda'
-import { type DocumentSymbol, SymbolKind } from 'vscode-languageserver-protocol'
+import { type DocumentSymbol, SymbolKind } from 'vscode-languageserver-types'
 import { ast, type LikeC4LangiumDocument } from '../ast'
 import { getFqnElementRef } from '../elementRef'
 import { logError } from '../logger'

package/src/lsp/HoverProvider.ts

@@ -2,7 +2,7 @@ import { type AstNode, type MaybePromise } from 'langium'
 import { AstNodeHoverProvider } from 'langium/lsp'
 import { isTruthy } from 'remeda'
 import stripIndent from 'strip-indent'
-import type { Hover } from 'vscode-languageserver-protocol'
+import type { Hover } from 'vscode-languageserver-types'
 import { ast } from '../ast'
 import type { LikeC4ModelLocator } from '../model'
 import type { LikeC4Services } from '../module'

package/src/lsp/SemanticTokenProvider.ts

@@ -1,7 +1,7 @@
 import type { AstNode } from 'langium'
 import { AbstractSemanticTokenProvider, type SemanticTokenAcceptor } from 'langium/lsp'
 import { isTruthy } from 'remeda'
-import { SemanticTokenModifiers, SemanticTokenTypes } from 'vscode-languageserver-protocol'
+import { SemanticTokenModifiers, SemanticTokenTypes } from 'vscode-languageserver-types'
 import { ast } from '../ast'
 
 export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
@@ -27,6 +27,14 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       return 'prune'
     }
 
+    if (ast.isOutgoingRelationExpression(node) && 'kind' in node) {
+      acceptor({
+        node,
+        property: 'kind',
+        type: SemanticTokenTypes.function
+      })
+      return
+    }
     if (ast.isRelation(node) && 'kind' in node) {
       acceptor({
         node,
@@ -60,7 +68,27 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
           SemanticTokenModifiers.readonly
         ]
       })
-      return 'prune'
+      return
+    }
+    if (ast.isWhereRelationKind(node) && isTruthy(node.value)) {
+      acceptor({
+        node,
+        property: 'value',
+        type: SemanticTokenTypes.function
+      })
+      return
+    }
+    if ((ast.isWhereElement(node) || ast.isWhereRelation(node)) && isTruthy(node.value)) {
+      acceptor({
+        node,
+        property: 'value',
+        type: SemanticTokenTypes.type,
+        modifier: [
+          SemanticTokenModifiers.definition,
+          SemanticTokenModifiers.readonly
+        ]
+      })
+      return
     }
     if (ast.isElementKindExpression(node) && isTruthy(node.kind)) {
       acceptor({
@@ -102,12 +130,11 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       })
     }
     if (ast.isTags(node)) {
-      acceptor({
+      return acceptor({
         node,
-        property: 'value',
+        property: 'values',
         type: SemanticTokenTypes.interface
       })
-      return
     }
     if (ast.isTag(node)) {
       return acceptor({
@@ -127,25 +154,6 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         type: SemanticTokenTypes.property
       })
     }
-    if (
-      ast.isColorProperty(node)
-      || ast.isShapeProperty(node)
-      || ast.isArrowProperty(node)
-      || ast.isLineProperty(node)
-      || ast.isBorderProperty(node)
-    ) {
-      acceptor({
-        node,
-        property: 'key',
-        type: SemanticTokenTypes.property
-      })
-      acceptor({
-        node,
-        property: 'value',
-        type: SemanticTokenTypes.enum
-      })
-      return 'prune'
-    }
     if (ast.isOpacityProperty(node)) {
       acceptor({
         node,
@@ -169,6 +177,13 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         property: 'key',
         type: SemanticTokenTypes.property
       })
+      if ('value' in node) {
+        acceptor({
+          node,
+          property: 'value',
+          type: SemanticTokenTypes.string
+        })
+      }
       if (ast.isIconProperty(node) && node.libicon) {
         acceptor({
           node,
@@ -176,14 +191,27 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
           type: SemanticTokenTypes.enum
         })
       }
+      return 'prune'
+    }
+    if (
+      ast.isColorProperty(node)
+      || ast.isShapeProperty(node)
+      || ast.isArrowProperty(node)
+      || ast.isLineProperty(node)
+      || ast.isBorderProperty(node)
+    ) {
+      acceptor({
+        node,
+        property: 'key',
+        type: SemanticTokenTypes.property
+      })
       if ('value' in node) {
         acceptor({
           node,
           property: 'value',
-          type: SemanticTokenTypes.string
+          type: SemanticTokenTypes.enum
         })
       }
-
       return 'prune'
     }
     if (ast.isElement(node)) {

package/src/model/model-builder.ts

@@ -8,8 +8,8 @@ import {
   type ViewID
 } from '@likec4/core'
 import { deepEqual as eq } from 'fast-equals'
-import type { URI, WorkspaceCache } from 'langium'
-import { DocumentState, interruptAndCheck, type LangiumDocument, type LangiumDocuments } from 'langium'
+import type { Cancellation, LangiumDocument, LangiumDocuments, URI, WorkspaceCache } from 'langium'
+import { Disposable, DocumentState, interruptAndCheck } from 'langium'
 import {
   filter,
   find,
@@ -26,7 +26,6 @@ import {
   sort,
   values
 } from 'remeda'
-import { type CancellationToken, Disposable } from 'vscode-languageserver-protocol'
 import type {
   ParsedAstElement,
   ParsedAstRelation,
@@ -245,7 +244,6 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
     views
   }
 }
-
 const RAW_MODEL_CACHE = 'LikeC4RawModel'
 const MODEL_CACHE = 'LikeC4Model'
 
@@ -282,7 +280,7 @@ export class LikeC4ModelBuilder {
     logger.debug(`[ModelBuilder] Created`)
   }
 
-  public async buildModel(cancelToken?: CancellationToken): Promise<c4.LikeC4Model | null> {
+  public async buildModel(cancelToken?: Cancellation.CancellationToken): Promise<c4.LikeC4Model | null> {
     return await this.services.shared.workspace.WorkspaceLock.read(async () => {
       if (cancelToken) {
         await interruptAndCheck(cancelToken)
@@ -302,7 +300,9 @@ export class LikeC4ModelBuilder {
 
   private previousViews: Record<ViewID, c4.ComputedView> = {}
 
-  public async buildComputedModel(cancelToken?: CancellationToken): Promise<c4.LikeC4ComputedModel | null> {
+  public async buildComputedModel(
+    cancelToken?: Cancellation.CancellationToken
+  ): Promise<c4.LikeC4ComputedModel | null> {
     const model = await this.buildModel(cancelToken)
     if (!model) {
       return null
@@ -342,7 +342,10 @@ export class LikeC4ModelBuilder {
     })
   }
 
-  public async computeView(viewId: ViewID, cancelToken?: CancellationToken): Promise<c4.ComputedView | null> {
+  public async computeView(
+    viewId: ViewID,
+    cancelToken?: Cancellation.CancellationToken
+  ): Promise<c4.ComputedView | null> {
     const model = await this.buildModel(cancelToken)
     const view = model?.views[viewId]
     if (!view) {
@@ -361,12 +364,12 @@ export class LikeC4ModelBuilder {
           logError(result.error)
           return null
         }
+        let computedView = result.view
 
         const allElementViews = values(model.views).filter(
           (v): v is ScopedElementView => isScopedElementView(v) && v.id !== viewId
         )
 
-        let computedView = result.view
         computedView.nodes.forEach(node => {
           if (!node.navigateTo) {
             // find first element view that is not the current one