@likec4/language-server 1.17.1 → 1.19.0

package/src/index.ts

@@ -1,14 +1,20 @@
 import { startLanguageServer as startLanguim } from 'langium/lsp'
 import { createConnection, ProposedFeatures } from 'vscode-languageserver/node'
 import { LikeC4FileSystem } from './LikeC4FileSystem'
-import { createLanguageServices } from './module'
+import { createLanguageServices, type LikeC4Services, type LikeC4SharedServices } from './module'
 
 export { logger as lspLogger, setLogLevel } from './logger'
-export type * from './model'
-export type * from './module'
+
+export type { DocumentParser, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model'
+
 export { createCustomLanguageServices, createLanguageServices, LikeC4Module } from './module'
+export type { LikeC4Services, LikeC4SharedServices } from './module'
 export { LikeC4FileSystem }
-export function startLanguageServer() {
+
+export function startLanguageServer(): {
+  shared: LikeC4SharedServices
+  likec4: LikeC4Services
+} {
   /* browser specific setup code */
   const connection = createConnection(ProposedFeatures.all)
 
@@ -18,8 +24,5 @@ export function startLanguageServer() {
   // Start the language server with the shared services
   startLanguim(services.shared)
 
-  return {
-    ...services,
-    connection
-  }
+  return services
 }

package/src/like-c4.langium

@@ -6,6 +6,7 @@ entry LikeC4Grammar:
     models+=Model  |
     views+=ModelViews |
     globals+=Globals |
+    deployments+=ModelDeployments  |
     likec4lib+=LikeC4Lib
   )*
 ;
@@ -18,22 +19,15 @@ LikeC4Lib:
     '}'
   '}';
 
-LibIcon:
-  name=IconId;
+LibIcon: name=IconId;
 
 // Specification -------------------------------------
 
-ElementKind:
-  name=Id;
-
-Tag:
-  name=Id;
-
-RelationshipKind:
-  name=Id;
-
-CustomColor:
-  name=CustomColorId;
+ElementKind: name=Id;
+Tag: name=Id;
+RelationshipKind: name=Id;
+CustomColor: name=CustomColorId;
+DeploymentNodeKind: name=Id;
 
 SpecificationRule:
   name='specification' '{'
@@ -41,7 +35,8 @@ SpecificationRule:
       elements+=SpecificationElementKind |
       tags+=SpecificationTag |
       relationships+=SpecificationRelationshipKind |
-      colors+=SpecificationColor
+      colors+=SpecificationColor |
+      deploymentNodes+=SpecificationDeploymentNodeKind
     )*
   '}';
 
@@ -56,6 +51,14 @@ SpecificationElementKind:
 SpecificationElementStringProperty:
   key=('technology' | 'notation') ':'? value=String ';'?;
 
+SpecificationDeploymentNodeKind:
+  'deploymentNode' kind=DeploymentNodeKind ('{'
+    props+=(
+      SpecificationElementStringProperty |
+      ElementStyleProperty
+    )*
+  '}')?;
+
 SpecificationTag:
   'tag' tag=Tag;
 
@@ -201,9 +204,9 @@ ModelViews:
     )*
   '}';
 
-type LikeC4View = ElementView | DynamicView;
+type LikeC4View = ElementView | DynamicView | DeploymentView;
 LikeC4ViewRule returns LikeC4View:
-  ElementView | DynamicView;
+  ElementView | DynamicView | DeploymentView;
 
 ElementView:
   'view' name=Id? (
@@ -372,7 +375,7 @@ ElementSelectorExpression infers ElementExpression:
 ElementDescedantsExpression infers ElementExpression:
   ElementRef (
     {infer ExpandElementExpression.expand=current} DotUnderscore |
-    {infer ElementDescedantsExpression.parent=current} DotWildcard
+    {infer ElementDescedantsExpression.parent=current} suffix=DotWildcard
   )?
 ;
 
@@ -410,7 +413,7 @@ WhereRelationNegation:
 
 WhereRelation:
   {infer WhereRelationTag} 'tag' EqOperator value=[Tag:TagId]? |
-  {infer WhereRelationKind} 'kind' EqOperator value=[RelationshipKind]?
+  {infer WhereRelationKind} 'kind' EqOperator value=[RelationshipKind:Id]?
 ;
 
 type WhereTagEqual = WhereElementTag | WhereRelationTag;
@@ -436,7 +439,7 @@ DirectedRelationExpressions infers RelationExpression:
 
 OutgoingRelationExpression:
   from=ElementExpression
-  (isBidirectional?='<->' | '->' | '-[' kind=[RelationshipKind] ']->' | kind=[RelationshipKind:DotId])
+  (isBidirectional?='<->' | '->' | '-[' kind=[RelationshipKind:Id] ']->' | kind=[RelationshipKind:DotId])
 ;
 
 // Comma-separated list of ElementExpressions
@@ -509,6 +512,152 @@ NavigateToProperty:
 RelationNavigateToProperty:
   key='navigateTo' value=DynamicViewRef;
 
+// Deployment -------------------------------------
+
+ModelDeployments:
+  name='deployment' '{'
+    elements+=(
+      DeploymentNode |
+      DeploymentRelation
+    )*
+  '}';
+
+type DeploymentElement = DeploymentNode | DeployedInstance;
+
+DeploymentNode:
+  (
+    kind=[DeploymentNodeKind:Id] name=Id |
+    name=Id Eq kind=[DeploymentNodeKind:Id]
+  )
+  title=String?
+  body=DeploymentNodeBody?
+;
+
+DeploymentNodeBody: '{'
+  tags=Tags?
+  props+=ElementProperty*
+  elements+=(
+    DeployedInstance |
+    DeploymentRelation |
+    DeploymentNode
+  )*
+'}';
+
+DeployedInstance:
+  (name=Id Eq)?
+  'instanceOf'
+  element=ElementRef
+  title=String?
+  body=DeployedInstanceBody?
+  ';'?
+;
+
+DeployedInstanceBody: '{'
+  tags=Tags?
+  props+=ElementProperty*
+'}';
+
+type Referenceable = DeploymentNode | DeployedInstance | Element;
+// Reference to Elements in logical or deployment model
+// Scope computation is based on the parent element:
+//  - If parent is DeploymentNode, then it can reference nested DeploymentNodes and DeployedInstances
+//  - If parent is DeployedInstance, then it can reference  nested  Element
+//  - If parent is Element, then it can reference  nested  Element
+//  Mix of DeploymentRef and ElementRef
+FqnRef:
+  value=[Referenceable:Id] ({infer FqnRef.parent=current} StickyDot value=[Referenceable:Id])*;
+
+DeploymentRelation:
+  source=FqnRef
+  ('->' | '-[' kind=[RelationshipKind:Id] ']->' | kind=[RelationshipKind:DotId])
+  target=FqnRef
+  (
+    title=String
+    technology=String?
+  )?
+  tags=Tags?
+  body=DeploymentRelationBody?
+;
+
+DeploymentRelationBody: '{'
+  tags=Tags?
+  props+=RelationProperty*
+'}'
+;
+
+DeploymentView:
+  'deployment' 'view' name=Id body=DeploymentViewBody?
+;
+
+DeploymentViewBody: '{'
+  tags=Tags?
+  props+=ViewProperty*
+  rules+=DeploymentViewRule*
+'}';
+
+DeploymentViewRule:
+  DeploymentViewRulePredicate |
+  DeploymentViewRuleStyle |
+  ViewRuleAutoLayout
+;
+
+DeploymentViewRuleStyle:
+  'style' targets=FqnExpressions '{'
+    props+=(
+      StyleProperty |
+      NotationProperty
+    )*
+  '}';
+
+
+DeploymentViewRulePredicate:
+  (isInclude?='include' | 'exclude')
+  expr=DeploymentViewRulePredicateExpression
+;
+
+DeploymentViewRulePredicateExpression:
+  value=ExpressionV2 ({infer DeploymentViewRulePredicateExpression.prev=current} ',' (value=ExpressionV2)?)*
+;
+
+ExpressionV2:
+  RelationExpr |
+  FqnExpr
+;
+
+
+FqnExpr:
+  {infer WildcardExpression} isWildcard?='*' |
+  FqnRefExpr
+;
+
+FqnRefExpr:
+  ref=FqnRef selector=(DotUnderscore | DotWildcard)?
+;
+
+RelationExpr:
+  InOutRelationExpr |
+  DirectedRelationExpr
+;
+
+InOutRelationExpr infers RelationExpr:
+  IncomingRelationExpr ({infer InOutRelationExpr.inout=current} '->')?
+;
+
+IncomingRelationExpr:
+  '->' to=FqnExpr;
+
+DirectedRelationExpr infers RelationExpr:
+  OutgoingRelationExpr ({infer DirectedRelationExpr.source=current} target=FqnExpr)?
+;
+
+OutgoingRelationExpr:
+  from=FqnExpr
+  (isBidirectional?='<->' | '->' | '-[' kind=[RelationshipKind:Id] ']->' | kind=[RelationshipKind:DotId])
+;
+
+FqnExpressions:
+  value=FqnExpr ({infer FqnExpressions.prev=current} ',' (value=FqnExpr)?)*
+;
 // Global -------------------------------------
 
 Globals:
@@ -545,6 +694,8 @@ GlobalStyleGroup:
     styles+=ViewRuleStyle*
   '}';
 
+type FqnReferenceable = Referenceable | Element | ExtendElement;
+
 // Common properties -------------------------------------
 
 LinkProperty:
@@ -635,7 +786,7 @@ CustomColorId returns string:
   IdTerminal | ElementShape | ArrowType | LineOptions | 'element' | 'model';
 
 Id returns string:
-  IdTerminal | ElementShape | ThemeColor | ArrowType | LineOptions | 'element' | 'model' | 'group';
+  IdTerminal | ElementShape | ThemeColor | ArrowType | LineOptions | 'element' | 'model' | 'group' | 'node' | 'deployment' | 'instance';
 
 fragment EqOperator:
   (
@@ -674,8 +825,8 @@ terminal LIB_ICON: /(aws|azure|gcp|tech):[-\w]*/;
 terminal URI_WITH_SCHEMA: /\w+:\/\/\S+/;
 terminal URI_RELATIVE: /\.{0,2}\/[^\/]\S+/;
 
-terminal DotUnderscore: /\b\._/;
-terminal DotWildcard: /\b\.\*/;
+terminal DotUnderscore: /\b\._(?![_a-zA-Z])/;
+terminal DotWildcard: /\b\.\*{1,2}/;
 terminal Hash: '#';
 
 // No space allowed before dot

package/src/logger.ts

@@ -1,9 +1,10 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { type ConsolaReporter, LogLevels, rootLogger as root } from '@likec4/log'
-import { isError } from 'remeda'
+import { nonexhaustive } from '@likec4/core'
+import { type ConsolaReporter, formatLogObj, LogLevels, rootLogger as root } from '@likec4/log'
+import { BROWSER } from 'esm-env'
 import type { Connection } from 'vscode-languageserver'
 
 export const logger = root.withTag('lsp')
+// export const logger = root
 
 export function logError(err: unknown): void {
   logger.error(err)
@@ -21,77 +22,60 @@ 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 (isError(arg)) {
-          return arg.stack ?? arg.message
-        }
-        if (typeof arg === 'string') {
-          return arg
-        }
-        return '' + arg
-      })
-      if (tag) {
-        parts.unshift(`[${tag}]`)
-      }
-      const message = parts.join(' ')
-      connection.telemetry.logEvent({ eventName: 'error', error: message })
-    }
-  }
-  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 (isError(arg)) {
-          return arg.stack ?? arg.message
+    log: (logObj, _ctx) => {
+      const { message, error } = formatLogObj(logObj)
+      switch (logObj.type) {
+        case 'silent': {
+          // ignore
+          break
         }
-        if (typeof arg === 'string') {
-          return arg
+        case 'verbose':
+        case 'trace': {
+          connection.tracer.log(message)
+          break
         }
-        return '' + arg
-      })
-      if (tag) {
-        parts.unshift(`[${tag}]`)
-      }
-      const message = parts.join(' ')
-      switch (true) {
-        case level >= LogLevels.debug: {
+        case 'debug': {
           connection.console.debug(message)
           break
         }
-        // case level >= LogLevels.info: {
-        //   connection.console.info(message)
-        //   break
-        // }
-        case level >= LogLevels.log: {
+        case 'log': {
+          connection.console.log(message)
+          break
+        }
+        case 'info':
+        case 'box':
+        case 'ready':
+        case 'start':
+        case 'success': {
           connection.console.info(message)
           break
         }
-        case level >= LogLevels.warn: {
+        case 'warn': {
           connection.console.warn(message)
           break
         }
-        case level >= LogLevels.fatal: {
+        case 'fail':
+        case 'error':
+        case 'fatal': {
           connection.console.error(message)
+          if (error) {
+            connection.telemetry.logEvent({ eventName: 'error', ...error })
+          } else {
+            connection.telemetry.logEvent({ eventName: 'error', message })
+          }
           break
         }
-        default: {
-          connection.console.log(message)
-        }
+        default:
+          nonexhaustive(logObj.type)
       }
-    }
+    },
+  }
+  if (BROWSER) {
+    root.addReporter(reporter)
+  } else {
+    root.setReporters([reporter])
   }
-  root.setReporters([reporter])
   logger.setReporters(root.options.reporters)
 }

package/src/lsp/CodeLensProvider.ts

@@ -7,7 +7,6 @@ import type { LikeC4Services } from '../module'
 
 export class LikeC4CodeLensProvider implements CodeLensProvider {
   constructor(private services: LikeC4Services) {
-    //
   }
 
   async provideCodeLens(

package/src/lsp/CompletionProvider.ts

@@ -22,6 +22,21 @@ export class LikeC4CompletionProvider extends DefaultCompletionProvider {
     if (!this.filterKeyword(context, keyword)) {
       return
     }
+    if (keyword.value === 'deployment' && AstUtils.hasContainerOfType(context.node, ast.isModelViews)) {
+      return acceptor(context, {
+        label: keyword.value,
+        detail: `Insert deployment view`,
+        kind: CompletionItemKind.Class,
+        insertTextFormat: InsertTextFormat.Snippet,
+        insertText: [
+          'deployment view ${1:view_${TM_FILENAME_BASE}_${CURRENT_SECOND}} {',
+          '\ttitle \'${2:Untitled}\'',
+          '\t',
+          '\tinclude $0',
+          '}'
+        ].join('\n')
+      })
+    }
     if (['title', 'description', 'technology'].includes(keyword.value)) {
       return acceptor(context, {
         label: keyword.value,
@@ -30,7 +45,7 @@ export class LikeC4CompletionProvider extends DefaultCompletionProvider {
         insertText: `${keyword.value} '\${0}'`
       })
     }
-    if (['views', 'specification', 'model', 'with'].includes(keyword.value)) {
+    if (['views', 'specification', 'model', 'deployment', 'with'].includes(keyword.value)) {
       return acceptor(context, {
         label: keyword.value,
         detail: `Insert ${keyword.value} block`,
@@ -52,7 +67,7 @@ export class LikeC4CompletionProvider extends DefaultCompletionProvider {
         ].join('\n')
       })
     }
-    if (keyword.value === 'dynamic') {
+    if (keyword.value === 'dynamic' && AstUtils.hasContainerOfType(context.node, ast.isModelViews)) {
       return acceptor(context, {
         label: keyword.value,
         detail: `Insert dynamic view`,
@@ -74,7 +89,7 @@ export class LikeC4CompletionProvider extends DefaultCompletionProvider {
           detail: `Insert ${keyword.value} block`,
           kind: CompletionItemKind.Module,
           insertTextFormat: InsertTextFormat.Snippet,
-          insertText: `${keyword.value} \${1:name} \${2:*} {\n\t\${3|color,shape,border,opacity,icon|} \$0\n}`
+          insertText: `${keyword.value} \${1:name} \${2:*} {\n\t\${3|color,shape,border,opacity,icon|} $0\n}`
         })
       }
       if (AstUtils.hasContainerOfType(context.node, anyPass([ast.isModelViews, ast.isGlobalStyleGroup]))) {
@@ -83,7 +98,7 @@ export class LikeC4CompletionProvider extends DefaultCompletionProvider {
           detail: `Insert ${keyword.value} block`,
           kind: CompletionItemKind.Module,
           insertTextFormat: InsertTextFormat.Snippet,
-          insertText: `${keyword.value} \${1:*} {\n\t\${2|color,shape,border,opacity,icon|} \$0\n}`
+          insertText: `${keyword.value} \${1:*} {\n\t\${2|color,shape,border,opacity,icon|} $0\n}`
         })
       }
       return acceptor(context, {
@@ -91,7 +106,7 @@ export class LikeC4CompletionProvider extends DefaultCompletionProvider {
         detail: `Insert ${keyword.value} block`,
         kind: CompletionItemKind.Module,
         insertTextFormat: InsertTextFormat.Snippet,
-        insertText: `${keyword.value} {\n\t\${1|color,shape,border,opacity,icon|} \$0\n}`
+        insertText: `${keyword.value} {\n\t\${1|color,shape,border,opacity,icon|} $0\n}`
       })
     }
     if (keyword.value === 'extend') {

package/src/lsp/DocumentSymbolProvider.ts

@@ -4,9 +4,9 @@ import type { DocumentSymbolProvider, NodeKindProvider } from 'langium/lsp'
 import { filter, isEmpty, isTruthy, map, pipe } from 'remeda'
 import { type DocumentSymbol, SymbolKind } from 'vscode-languageserver-types'
 import { ast, type LikeC4LangiumDocument } from '../ast'
-import { getFqnElementRef } from '../elementRef'
 import { logError } from '../logger'
 import type { LikeC4Services } from '../module'
+import { getFqnElementRef } from '../utils/elementRef'
 
 export class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
   protected readonly nodeKindProvider: NodeKindProvider
@@ -61,7 +61,10 @@ export class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
       [...astSpec.elements, ...astSpec.tags, ...astSpec.relationships],
       map(nd => {
         try {
-          if (ast.isSpecificationElementKind(nd) || ast.isSpecificationRelationshipKind(nd)) {
+          if (
+            ast.isSpecificationElementKind(nd) || ast.isSpecificationRelationshipKind(nd)
+            || ast.isSpecificationDeploymentNodeKind(nd)
+          ) {
             return this.getKindSymbol(nd)
           }
           if (ast.isSpecificationTag(nd)) {

package/src/lsp/HoverProvider.ts

@@ -1,17 +1,19 @@
-import { type AstNode, type MaybePromise } from 'langium'
+import { type AstNode, AstUtils, type MaybePromise } from 'langium'
 import { AstNodeHoverProvider } from 'langium/lsp'
 import { isTruthy } from 'remeda'
 import stripIndent from 'strip-indent'
 import type { Hover } from 'vscode-languageserver-types'
 import { ast } from '../ast'
-import type { LikeC4ModelLocator } from '../model'
+import type { LikeC4ModelLocator, LikeC4ModelParser } from '../model'
 import type { LikeC4Services } from '../module'
 
 export class LikeC4HoverProvider extends AstNodeHoverProvider {
+  private parser: LikeC4ModelParser
   private locator: LikeC4ModelLocator
 
   constructor(services: LikeC4Services) {
     super(services)
+    this.parser = services.likec4.ModelParser
     this.locator = services.likec4.ModelLocator
   }
 
@@ -27,6 +29,38 @@ export class LikeC4HoverProvider extends AstNodeHoverProvider {
       }
     }
 
+    if (ast.isDeploymentNode(node)) {
+      const doc = AstUtils.getDocument(node)
+      const el = this.parser.forDocument(doc).parseDeploymentNode(node)
+      const lines = [el.id as string + '  ']
+      if (el.title !== node.name) {
+        lines.push(`### ${el.title}`)
+      }
+      lines.push('Deployment: `' + el.kind + '` ')
+      return {
+        contents: {
+          kind: 'markdown',
+          value: lines.join('\n')
+        }
+      }
+    }
+
+    if (ast.isDeployedInstance(node)) {
+      const doc = AstUtils.getDocument(node)
+      const instance = this.parser.forDocument(doc).parseDeployedInstance(node)
+      const el = this.locator.getParsedElement(instance.element)
+      const lines = [instance.id + '  ', `instance of \`${instance.element}\``]
+      if (el) {
+        lines.push(`### ${el.title}`, 'Element: `' + el.kind + '` ')
+      }
+      return {
+        contents: {
+          kind: 'markdown',
+          value: lines.join('\n')
+        }
+      }
+    }
+
     // if (ast.isElementKind(node)) {
     //   const spec = this.specIndex.get(node.name as ElementKind)
     //   return {
@@ -45,7 +79,7 @@ export class LikeC4HoverProvider extends AstNodeHoverProvider {
       if (!el) {
         return
       }
-      const lines = [el.id, `### ${el.title}`, '`' + el.kind + '` ']
+      const lines = [el.id, `### ${el.title}`, 'Element: `' + el.kind + '` ']
       return {
         contents: {
           kind: 'markdown',