@likec4/language-server 1.18.0 → 1.19.0

package/src/index.ts

@@ -1,15 +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)
 
@@ -19,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

@@ -545,7 +545,7 @@ DeploymentNodeBody: '{'
 
 DeployedInstance:
   (name=Id Eq)?
-  ('instanceOf' | 'instance' 'of')
+  'instanceOf'
   element=ElementRef
   title=String?
   body=DeployedInstanceBody?
@@ -557,18 +557,20 @@ DeployedInstanceBody: '{'
   props+=ElementProperty*
 '}';
 
-// Rules:
-// - DeployedInstance can be referenced from DeploymentNode
-// - Element can be referenced from DeployedInstance
-// Forced by scope computation
-type DeploymentReferenceable = DeploymentNode | DeployedInstance | Element;
-DeploymentRef:
-  value=[DeploymentReferenceable:Id] ({infer DeploymentRef.parent=current} StickyDot value=[DeploymentReferenceable:Id])*;
+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=DeploymentRef
+  source=FqnRef
   ('->' | '-[' kind=[RelationshipKind:Id] ']->' | kind=[RelationshipKind:DotId])
-  target=DeploymentRef
+  target=FqnRef
   (
     title=String
     technology=String?
@@ -600,7 +602,7 @@ DeploymentViewRule:
 ;
 
 DeploymentViewRuleStyle:
-  'style' target=DeploymentExpressionIterator '{'
+  'style' targets=FqnExpressions '{'
     props+=(
       StyleProperty |
       NotationProperty
@@ -614,46 +616,47 @@ DeploymentViewRulePredicate:
 ;
 
 DeploymentViewRulePredicateExpression:
-  value=DeploymentExpression ({infer DeploymentViewRulePredicateExpression.prev=current} ',' (value=DeploymentExpression)?)*
+  value=ExpressionV2 ({infer DeploymentViewRulePredicateExpression.prev=current} ',' (value=ExpressionV2)?)*
 ;
 
-DeploymentExpression:
-  DeploymentRelationExpression |
-  DeploymentElementExpression
+ExpressionV2:
+  RelationExpr |
+  FqnExpr
 ;
 
-DeploymentElementExpression:
+
+FqnExpr:
   {infer WildcardExpression} isWildcard?='*' |
-  DeploymentRefExpression
+  FqnRefExpr
 ;
 
-DeploymentRefExpression:
-  ref=DeploymentRef selector=(DotUnderscore | DotWildcard)?
+FqnRefExpr:
+  ref=FqnRef selector=(DotUnderscore | DotWildcard)?
 ;
 
-DeploymentRelationExpression:
-  InOutDeploymentRelationExpression |
-  DirectedDeploymentRelationExpression
+RelationExpr:
+  InOutRelationExpr |
+  DirectedRelationExpr
 ;
 
-InOutDeploymentRelationExpression infers DeploymentRelationExpression:
-  IncomingDeploymentRelationExpression ({infer InOutDeploymentRelationExpression.inout=current} '->')?
+InOutRelationExpr infers RelationExpr:
+  IncomingRelationExpr ({infer InOutRelationExpr.inout=current} '->')?
 ;
 
-IncomingDeploymentRelationExpression:
-  '->' to=DeploymentElementExpression;
+IncomingRelationExpr:
+  '->' to=FqnExpr;
 
-DirectedDeploymentRelationExpression infers DeploymentRelationExpression:
-  OutgoingDeploymentRelationExpression ({infer DirectedDeploymentRelationExpression.source=current} target=DeploymentElementExpression)?
+DirectedRelationExpr infers RelationExpr:
+  OutgoingRelationExpr ({infer DirectedRelationExpr.source=current} target=FqnExpr)?
 ;
 
-OutgoingDeploymentRelationExpression:
-  from=DeploymentElementExpression
+OutgoingRelationExpr:
+  from=FqnExpr
   (isBidirectional?='<->' | '->' | '-[' kind=[RelationshipKind:Id] ']->' | kind=[RelationshipKind:DotId])
 ;
 
-DeploymentExpressionIterator:
-  value=DeploymentElementExpression ({infer DeploymentExpressionIterator.prev=current} ',' (value=DeploymentElementExpression)?)*
+FqnExpressions:
+  value=FqnExpr ({infer FqnExpressions.prev=current} ',' (value=FqnExpr)?)*
 ;
 // Global -------------------------------------
 
@@ -691,7 +694,7 @@ GlobalStyleGroup:
     styles+=ViewRuleStyle*
   '}';
 
-type FqnReferenceable = DeploymentReferenceable | Element | ExtendElement;
+type FqnReferenceable = Referenceable | Element | ExtendElement;
 
 // Common properties -------------------------------------
 
@@ -783,7 +786,7 @@ CustomColorId returns string:
   IdTerminal | ElementShape | ArrowType | LineOptions | 'element' | 'model';
 
 Id returns string:
-  IdTerminal | ElementShape | ThemeColor | ArrowType | LineOptions | 'element' | 'model' | 'group' | 'node' | 'deployment';
+  IdTerminal | ElementShape | ThemeColor | ArrowType | LineOptions | 'element' | 'model' | 'group' | 'node' | 'deployment' | 'instance';
 
 fragment EqOperator:
   (

package/src/logger.ts

@@ -1,6 +1,6 @@
-import { type ConsolaReporter, LogLevels, rootLogger as root } from '@likec4/log'
+import { nonexhaustive } from '@likec4/core'
+import { type ConsolaReporter, formatLogObj, LogLevels, rootLogger as root } from '@likec4/log'
 import { BROWSER } from 'esm-env'
-import { isError } from 'remeda'
 import type { Connection } from 'vscode-languageserver'
 
 export const logger = root.withTag('lsp')
@@ -22,76 +22,55 @@ 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)

package/src/lsp/CompletionProvider.ts

@@ -32,7 +32,7 @@ export class LikeC4CompletionProvider extends DefaultCompletionProvider {
           'deployment view ${1:view_${TM_FILENAME_BASE}_${CURRENT_SECOND}} {',
           '\ttitle \'${2:Untitled}\'',
           '\t',
-          '\t$0',
+          '\tinclude $0',
           '}'
         ].join('\n')
       })
@@ -89,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]))) {
@@ -98,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, {
@@ -106,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/HoverProvider.ts

@@ -1,4 +1,4 @@
-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'
@@ -30,7 +30,8 @@ export class LikeC4HoverProvider extends AstNodeHoverProvider {
     }
 
     if (ast.isDeploymentNode(node)) {
-      const el = this.parser.parseDeploymentNode(node, () => true)
+      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}`)
@@ -45,7 +46,8 @@ export class LikeC4HoverProvider extends AstNodeHoverProvider {
     }
 
     if (ast.isDeployedInstance(node)) {
-      const instance = this.parser.parseDeployedInstance(node, () => true)
+      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) {

package/src/lsp/SemanticTokenProvider.ts

@@ -90,7 +90,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       })
       return 'prune'
     }
-    if (ast.isDeploymentRefExpression(node)) {
+    if (ast.isFqnRefExpr(node)) {
       if (node.selector) {
         acceptor({
           node,
@@ -142,7 +142,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       })
       return 'prune'
     }
-    if (ast.isDeploymentRef(node)) {
+    if (ast.isFqnRef(node)) {
       acceptor({
         node,
         property: 'value',

package/src/model/deployments-index.ts

@@ -3,11 +3,11 @@ import type { LangiumDocument, LangiumDocuments, Stream } from 'langium'
 import { AstUtils, DocumentState, MultiMap } from 'langium'
 import { forEachObj, groupBy, isTruthy, pipe, prop } from 'remeda'
 import {
-  ast,
   type DeploymentAstNodeDescription,
+  type LikeC4LangiumDocument,
+  ast,
   ElementOps,
   isLikeC4LangiumDocument,
-  type LikeC4LangiumDocument
 } from '../ast'
 import { logWarnError } from '../logger'
 import type { LikeC4Services } from '../module'
@@ -33,7 +33,7 @@ export class DeploymentsIndex {
         for (const doc of docs) {
           delete (doc as IndexedDocument)[DeploymentsIndexKey]
         }
-      }
+      },
     )
   }
 
@@ -55,7 +55,7 @@ export class DeploymentsIndex {
    * @returns Stream of artifacts
    */
   public nested(node: ast.DeploymentNode): Stream<DeploymentAstNodeDescription> {
-    const fqnName = this.getFqnName(node)
+    const fqnName = this.getFqn(node)
     return this.documents().flatMap(doc => this.get(doc).nested(fqnName))
   }
 
@@ -63,18 +63,19 @@ export class DeploymentsIndex {
     return this.documents().flatMap(doc => this.get(doc).byFqn(fqnName))
   }
 
-  public getFqnName(node: ast.DeploymentElement): Fqn {
+  public getFqn(node: ast.DeploymentElement): Fqn {
     let id = ElementOps.readId(node)
     if (isTruthy(id)) {
       return id
     }
     const fqn = [
-      this.Names.getNameStrict(node)
+      this.Names.getNameStrict(node),
     ]
+    let _node = node
     let parentNode: ast.DeploymentNode | undefined
-    while ((parentNode = AstUtils.getContainerOfType(node.$container, ast.isDeploymentNode))) {
+    while ((parentNode = AstUtils.getContainerOfType(_node.$container, ast.isDeploymentNode))) {
       fqn.push(this.Names.getNameStrict(parentNode))
-      node = parentNode
+      _node = parentNode
     }
     id = fqn.reduceRight((acc, cur) => `${acc}.${cur}`) as Fqn
     ElementOps.writeId(node, id)
@@ -93,11 +94,11 @@ export class DeploymentsIndex {
     const Descriptions = this.services.workspace.AstNodeDescriptionProvider
 
     const createAndSaveDescription = (
-      props: { node: ast.DeploymentNode | ast.DeployedInstance; name: string; fqn: string }
+      props: { node: ast.DeploymentNode | ast.DeployedInstance; name: string; fqn: string },
     ) => {
       const desc = {
         ...Descriptions.createDescription(props.node, props.name, document),
-        fqn: props.fqn
+        fqn: props.fqn,
       }
       ElementOps.writeId(props.node, props.fqn as Fqn)
       _byfqn.add(props.fqn, desc)
@@ -106,7 +107,7 @@ export class DeploymentsIndex {
 
     const traverseNode = (
       container: ast.DeploymentNode,
-      parentFqn: string
+      parentFqn: string,
     ): readonly DeploymentAstNodeDescription[] => {
       const _descedants = [] as DeploymentAstNodeDescription[]
       const children = container.body?.elements
@@ -142,7 +143,7 @@ export class DeploymentsIndex {
               return
             }
             _nested.add(parentFqn, descs[0])
-          })
+          }),
         )
       }
       return _nested.get(parentFqn)
@@ -166,6 +167,9 @@ export class DeploymentsIndex {
   }
 }
 
+/**
+ * Index of deployment elements in the document
+ */
 export class DocumentDeploymentsIndex {
   static readonly EMPTY = new DocumentDeploymentsIndex([], new MultiMap(), new MultiMap())
 
@@ -178,7 +182,7 @@ export class DocumentDeploymentsIndex {
     /**
      * All elements by FQN
      */
-    private _byfqn: MultiMap<string, DeploymentAstNodeDescription>
+    private _byfqn: MultiMap<string, DeploymentAstNodeDescription>,
   ) {}
 
   public rootNodes(): readonly DeploymentAstNodeDescription[] {
@@ -211,7 +215,7 @@ export class DocumentDeploymentsIndex {
         if (descs.length === 1) {
           result.push(descs[0])
         }
-      })
+      }),
     )
     return result
   }

package/src/model/model-builder.ts

@@ -1,14 +1,16 @@
-import * as c4 from '@likec4/core'
+import type * as c4 from '@likec4/core'
 import {
   compareRelations,
   computeColorValues,
   type CustomColorDefinitions,
+  DeploymentElement,
   isScopedElementView,
+  LikeC4Model,
   parentFqn,
   sortByFqnHierarchically,
   type ViewId
 } from '@likec4/core'
-import { mkComputeView, resolveRulesExtendedViews } from '@likec4/core/compute-view'
+import { resolveRulesExtendedViews } from '@likec4/core/compute-view'
 import { deepEqual as eq } from 'fast-equals'
 import type { Cancellation, LangiumDocument, LangiumDocuments, URI, WorkspaceCache } from 'langium'
 import { Disposable, DocumentState, interruptAndCheck } from 'langium'
@@ -189,7 +191,7 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
       links: unresolvedLinks,
       id,
       ...model
-    }: ParsedAstRelation): c4.Relation | null => {
+    }: ParsedAstRelation): c4.ModelRelation | null => {
       if (isNullish(elements[source]) || isNullish(elements[target])) {
         logger.warn(
           `Invalid relation ${id} at ${doc.uri.path} ${astPath}, source: ${source}(${!!elements[
@@ -209,7 +211,7 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
           target,
           kind,
           id
-        } satisfies c4.Relation
+        } satisfies c4.ModelRelation
       }
       return {
         ...links && { links },
@@ -217,7 +219,7 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
         source,
         target,
         id
-      } satisfies c4.Relation
+      } satisfies c4.ModelRelation
     }
   }
 
@@ -232,7 +234,7 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
 
   function toDeploymentElement(doc: LangiumDocument) {
     return (parsed: c4.DeploymentElement): c4.DeploymentElement | null => {
-      if (!c4.DeploymentElement.isDeploymentNode(parsed)) {
+      if (!DeploymentElement.isDeploymentNode(parsed)) {
         if (!parsed.links || parsed.links.length === 0) {
           return parsed
         }
@@ -525,7 +527,7 @@ export class LikeC4ModelBuilder {
     const cache = this.services.WorkspaceCache as WorkspaceCache<string, c4.ComputedLikeC4Model>
     const viewsCache = this.services.WorkspaceCache as WorkspaceCache<string, c4.ComputedView | null>
     return cache.get(CACHE_KEY_COMPUTED_MODEL, () => {
-      const computeView = mkComputeView(model)
+      const computeView = LikeC4Model.makeCompute(model)
       const allViews = [] as c4.ComputedView[]
       for (const view of values(model.views)) {
         const result = computeView(view)
@@ -597,7 +599,7 @@ export class LikeC4ModelBuilder {
           logger.warn(`[ModelBuilder] Cannot find view ${viewId}`)
           return null
         }
-        const result = mkComputeView(model)(view)
+        const result = LikeC4Model.makeCompute(model)(view)
         if (!result.isSuccess) {
           logError(result.error)
           return null