@likec4/language-server 1.8.1 → 1.10.0

package/src/module.ts

@@ -9,7 +9,7 @@ import {
   type PartialLangiumSharedServices
 } from 'langium/lsp'
 import { LikeC4GeneratedModule, LikeC4GeneratedSharedModule } from './generated/module'
-import { logErrorToTelemetry } from './logger'
+import { logErrorToTelemetry, logToLspConnection } from './logger'
 import {
   LikeC4CodeLensProvider,
   LikeC4CompletionProvider,
@@ -25,6 +25,7 @@ import { LikeC4ScopeComputation, LikeC4ScopeProvider } from './references'
 import { Rpc } from './Rpc'
 import { LikeC4WorkspaceManager, NodeKindProvider, WorkspaceSymbolProvider } from './shared'
 import { registerValidationChecks } from './validation'
+import { LikeC4Formatter } from './formatting/LikeC4Formatter'
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type Constructor<T, Arguments extends unknown[] = any[]> = new(...arguments_: Arguments) => T
@@ -69,6 +70,7 @@ export interface LikeC4AddedServices {
     ModelChanges: LikeC4ModelChanges
   }
   lsp: {
+    // RenameProvider: LikeC4RenameProvider
     CompletionProvider: LikeC4CompletionProvider
     DocumentHighlightProvider: LikeC4DocumentHighlightProvider
     DocumentSymbolProvider: LikeC4DocumentSymbolProvider
@@ -101,13 +103,15 @@ export const LikeC4Module: Module<LikeC4Services, PartialLangiumServices & LikeC
     ModelLocator: bind(LikeC4ModelLocator)
   },
   lsp: {
+    // RenameProvider: bind(LikeC4RenameProvider),
     CompletionProvider: bind(LikeC4CompletionProvider),
     DocumentHighlightProvider: bind(LikeC4DocumentHighlightProvider),
     DocumentSymbolProvider: bind(LikeC4DocumentSymbolProvider),
     SemanticTokenProvider: bind(LikeC4SemanticTokenProvider),
     HoverProvider: bind(LikeC4HoverProvider),
     CodeLensProvider: bind(LikeC4CodeLensProvider),
-    DocumentLinkProvider: bind(LikeC4DocumentLinkProvider)
+    DocumentLinkProvider: bind(LikeC4DocumentLinkProvider),
+    Formatter: bind(LikeC4Formatter)
   },
   references: {
     ScopeComputation: bind(LikeC4ScopeComputation),
@@ -136,7 +140,15 @@ export function createCustomLanguageServices<I1, I2, I3, I extends I1 & I2 & I3
   const likec4 = inject(modules)
   shared.ServiceRegistry.register(likec4)
   registerValidationChecks(likec4)
-  likec4.Rpc.init()
+
+  if (!context.connection) {
+    // We don't run inside a language server
+    // Therefore, initialize the configuration provider instantly
+    shared.workspace.ConfigurationProvider.initialized({})
+  } else {
+    likec4.Rpc.init()
+  }
+
   return { shared, likec4 }
 }
 
@@ -146,6 +158,7 @@ export function createSharedServices(context: LanguageServicesContext = {}): Lik
     ...context
   }
   if (context.connection) {
+    logToLspConnection(context.connection)
     logErrorToTelemetry(context.connection)
   }
 
@@ -164,7 +177,11 @@ export function createLanguageServices(context: LanguageServicesContext = {}): {
   const likec4 = inject(createDefaultModule({ shared }), LikeC4GeneratedModule, LikeC4Module)
   shared.ServiceRegistry.register(likec4)
   registerValidationChecks(likec4)
-  likec4.Rpc.init()
+
+  if (context.connection) {
+    likec4.Rpc.init()
+  }
+
   return { shared, likec4 }
 }
 

package/src/protocol.ts

@@ -1,9 +1,8 @@
 import type {
-  AutoLayoutDirection,
+  ComputedLikeC4Model,
   ComputedView,
   Fqn,
-  LikeC4ComputedModel,
-  LikeC4Model,
+  ParsedLikeC4Model,
   RelationID,
   ViewChange,
   ViewID
@@ -17,12 +16,12 @@ export type OnDidChangeModelNotification = typeof onDidChangeModel
 // #endregion
 
 // #region To server
-export const fetchModel = new RequestType0<{ model: LikeC4Model | null }, void>(
+export const fetchModel = new RequestType0<{ model: ParsedLikeC4Model | null }, void>(
   'likec4/fetchModel'
 )
 export type FetchModelRequest = typeof fetchModel
 
-export const fetchComputedModel = new RequestType0<{ model: LikeC4ComputedModel | null }, void>(
+export const fetchComputedModel = new RequestType0<{ model: ComputedLikeC4Model | null }, void>(
   'likec4/fetchComputedModel'
 )
 export type FetchComputedModelRequest = typeof fetchComputedModel

package/src/references/scope-computation.ts

@@ -106,7 +106,8 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
       const spec of specifications.flatMap(s => [
         ...s.elements,
         ...s.relationships,
-        ...s.tags
+        ...s.tags,
+        ...s.colors
       ])
     ) {
       try {
@@ -136,6 +137,14 @@ export class LikeC4ScopeComputation extends DefaultScopeComputation {
             }
             continue
           }
+          case ast.isSpecificationColor(spec): {
+            if (isTruthy(spec.name.name)) {
+              docExports.push(
+                this.descriptions.createDescription(spec.name, spec.name.name, document)
+              )
+            }
+            continue
+          }
           // Thow error if not exhaustive
           default:
             nonexhaustive(spec)

package/src/references/scope-provider.ts

@@ -1,4 +1,5 @@
-import { invariant, type likec4 as c4 } from '@likec4/core'
+import { invariant } from '@likec4/core'
+import type * as c4 from '@likec4/core'
 import type { AstNode } from 'langium'
 import {
   type AstNodeDescription,

package/src/shared/NodeKindProvider.ts

@@ -1,4 +1,4 @@
-import { type AstNode, type AstNodeDescription } from 'langium'
+import { type AstNode, type AstNodeDescription, isAstNode } from 'langium'
 import type { LangiumSharedServices, NodeKindProvider as LspNodeKindProvider } from 'langium/lsp'
 import { CompletionItemKind, SymbolKind } from 'vscode-languageserver-types'
 import { ast } from '../ast'
@@ -11,32 +11,44 @@ export class NodeKindProvider implements LspNodeKindProvider {
    */
   // prettier-ignore
   getSymbolKind(node: AstNode | AstNodeDescription): SymbolKind {
-    const hasType = (type: string) => 'type' in node && this.services.AstReflection.isSubtype(node.type, type)
+    const nodeType = isAstNode(node) ? node.$type : node.type
+    const hasType = (...types: string[]) => types.some(t => this.services.AstReflection.isSubtype(nodeType, t))
     switch (true) {
-      case (ast.isElement(node) || hasType(ast.Element))
-        || (ast.isExtendElement(node) || hasType(ast.ExtendElement)): {
+      case hasType(
+        ast.Element,
+        ast.ExtendElement
+      ):
         return SymbolKind.Constructor
-      }
-      case ast.isModel(node) || ast.isModelViews(node) || ast.isSpecificationRule(node)
-        || hasType(ast.Model) || hasType(ast.ModelViews) || hasType(ast.SpecificationRule): {
+
+      case hasType(
+        ast.Model,
+        ast.ModelViews,
+        ast.SpecificationRule
+      ):
         return SymbolKind.Namespace
-      }
-      case (ast.isLikeC4View(node) || hasType(ast.LikeC4View)): {
+
+      case hasType(ast.LikeC4View):
         return SymbolKind.Class
-      }
-      case (ast.isTag(node) || hasType(ast.Tag))
-        || (ast.isLibIcon(node) || hasType(ast.LibIcon))
-        || (ast.isSpecificationTag(node) || hasType(ast.SpecificationTag)): {
+
+      case hasType(
+        ast.Tag,
+        ast.LibIcon,
+        ast.CustomColor,
+        ast.SpecificationTag
+      ):
         return SymbolKind.EnumMember
-      }
-      case (ast.isRelationshipKind(node) || hasType(ast.RelationshipKind))
-        || (ast.isSpecificationRelationshipKind(node) || hasType(ast.SpecificationRelationshipKind)): {
+
+      case hasType(
+        ast.RelationshipKind,
+        ast.SpecificationRelationshipKind
+      ):
         return SymbolKind.Event
-      }
-      case (ast.isElementKind(node) || hasType(ast.ElementKind))
-        || (ast.isSpecificationElementKind(node) || hasType(ast.SpecificationElementKind)): {
+
+      case hasType(
+        ast.ElementKind,
+        ast.SpecificationElementKind
+      ):
         return SymbolKind.TypeParameter
-      }
     }
     return SymbolKind.Field
   }
@@ -44,25 +56,52 @@ export class NodeKindProvider implements LspNodeKindProvider {
    * Returns a `CompletionItemKind` as used by the `CompletionProvider`.
    */
   getCompletionItemKind(node: AstNode | AstNodeDescription): CompletionItemKind {
-    switch (this.getSymbolKind(node)) {
-      case SymbolKind.Constructor:
+    const nodeType = isAstNode(node) ? node.$type : node.type
+    const hasType = (...types: string[]) => types.some(t => this.services.AstReflection.isSubtype(nodeType, t))
+    switch (true) {
+      case hasType(
+        ast.CustomColor
+      ):
+        return CompletionItemKind.Color
+
+      case hasType(
+        ast.Element,
+        ast.ExtendElement
+      ):
         return CompletionItemKind.Constructor
-      case SymbolKind.Namespace:
+
+      case hasType(
+        ast.Model,
+        ast.ModelViews,
+        ast.SpecificationRule
+      ):
         return CompletionItemKind.Module
-      case SymbolKind.Class:
+
+      case hasType(
+        ast.LikeC4View
+      ):
         return CompletionItemKind.Class
-      case SymbolKind.Enum:
-        return CompletionItemKind.Enum
-      case SymbolKind.EnumMember:
+
+      case hasType(
+        ast.Tag,
+        ast.LibIcon,
+        ast.CustomColor,
+        ast.SpecificationTag
+      ):
         return CompletionItemKind.EnumMember
-      case SymbolKind.TypeParameter:
-        return CompletionItemKind.TypeParameter
-      case SymbolKind.Interface:
-        return CompletionItemKind.Interface
-      case SymbolKind.Event:
+
+      case hasType(
+        ast.RelationshipKind,
+        ast.SpecificationRelationshipKind
+      ):
         return CompletionItemKind.Event
-      case SymbolKind.Constant:
-        return CompletionItemKind.Constant
+
+      case hasType(
+        ast.ElementKind,
+        ast.SpecificationElementKind
+      ):
+        return CompletionItemKind.TypeParameter
+
       default:
         return CompletionItemKind.Reference
     }

package/src/test/setup.ts

@@ -1,13 +1,8 @@
-import { beforeAll, beforeEach, vi } from 'vitest'
+import { consola } from '@likec4/log'
+import { beforeEach, vi } from 'vitest'
 import { logger } from '../logger'
-
-beforeAll(() => {
-  // Redirect std and console to consola too
-  // Calling this once is sufficient
-  logger.wrapAll()
-})
-
 beforeEach(() => {
   // Vitest
+  consola.mockTypes(() => vi.fn())
   logger.mockTypes(() => vi.fn())
 })

package/src/test/testServices.ts

@@ -1,4 +1,4 @@
-import { DocumentState, EmptyFileSystem } from 'langium'
+import { DocumentState, EmptyFileSystem, TextDocument } from 'langium'
 import * as assert from 'node:assert'
 import stripIndent from 'strip-indent'
 import { type Diagnostic, DiagnosticSeverity } from 'vscode-languageserver-types'
@@ -13,6 +13,7 @@ export function createTestServices(workspace = 'file:///test/workspace') {
   const documentBuilder = services.shared.workspace.DocumentBuilder
   const modelBuilder = services.likec4.ModelBuilder
   const workspaceUri = URI.parse(workspace)
+  const formatter = services.lsp.Formatter
   const workspaceFolder = {
     name: 'test',
     uri: workspaceUri.toString()
@@ -27,11 +28,13 @@ export function createTestServices(workspace = 'file:///test/workspace') {
           return
         }
         isInitialized = true
-        await services.shared.workspace.WorkspaceManager.initializeWorkspace([workspaceFolder])
-        // Workaround to set protected folders property
-        Object.assign(services.shared.workspace.WorkspaceManager, {
-          folders: [workspaceFolder]
+        services.shared.workspace.WorkspaceManager.initialize({
+          capabilities: {},
+          processId: null,
+          rootUri: null,
+          workspaceFolders: [workspaceFolder]
         })
+        await services.shared.workspace.WorkspaceManager.initializeWorkspace([workspaceFolder])
       })
     }
     const docUri = Utils.resolvePath(
@@ -66,12 +69,28 @@ export function createTestServices(workspace = 'file:///test/workspace') {
     }
   }
 
+  const format = async (input: string | LikeC4LangiumDocument, uri?: string) => {
+    const document = typeof input === 'string' ? await parse(input, uri) : input
+    await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
+      await documentBuilder.build([document], { validation: false })
+    })
+
+    const edits = await services.lsp.Formatter?.formatDocument(
+      document, 
+      {
+        options: {tabSize: 2, insertSpaces: true},
+        textDocument: { uri: document.uri.toString() }
+      });
+
+    return TextDocument.applyEdits(document.textDocument, edits ?? []);
+  }
+
   type ValidateAllResult = {
     diagnostics: Diagnostic[]
     errors: string[]
     warnings: string[]
   }
-  let previousPromise = Promise.resolve() as Promise<any>
+
   const validateAll = async () => {
     await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
       const docs = langiumDocuments.all.toArray()
@@ -110,7 +129,8 @@ export function createTestServices(workspace = 'file:///test/workspace') {
     validate,
     validateAll,
     buildModel,
-    resetState
+    resetState,
+    format
   }
 }
 

package/src/utils/graphlib.ts

@@ -0,0 +1,11 @@
+// '@dagrejs/graphlib' is a CommonJS module
+// Here is a workaround to import it
+
+import { Graph } from '@dagrejs/graphlib'
+import graphlib from '@dagrejs/graphlib'
+
+export { Graph }
+
+export const postorder = graphlib.alg.postorder
+export const findCycles = graphlib.alg.findCycles
+export const isAcyclic = graphlib.alg.isAcyclic

package/src/validation/index.ts

@@ -4,7 +4,7 @@ import type { LikeC4Services } from '../module'
 import { dynamicViewRulePredicate } from './dynamic-view-rule'
 import { dynamicViewStep } from './dynamic-view-step'
 import { elementChecks } from './element'
-import { iconPropertyRuleChecks, opacityPropertyRuleChecks } from './property-checks'
+import { iconPropertyRuleChecks, notesPropertyRuleChecks, opacityPropertyRuleChecks } from './property-checks'
 import { relationBodyChecks, relationChecks } from './relation'
 import {
   elementKindChecks,
@@ -27,6 +27,7 @@ export function registerValidationChecks(services: LikeC4Services) {
   logger.info('registerValidationChecks')
   const registry = services.validation.ValidationRegistry
   registry.register<ast.LikeC4AstType>({
+    NotesProperty: notesPropertyRuleChecks(services),
     OpacityProperty: opacityPropertyRuleChecks(services),
     IconProperty: iconPropertyRuleChecks(services),
     SpecificationRule: specificationRuleChecks(services),

package/src/validation/property-checks.ts

@@ -1,4 +1,4 @@
-import type { ValidationCheck } from 'langium'
+import { AstUtils, type ValidationCheck } from 'langium'
 import { ast } from '../ast'
 import type { LikeC4Services } from '../module'
 
@@ -37,3 +37,15 @@ export const iconPropertyRuleChecks = (
     }
   }
 }
+
+export const notesPropertyRuleChecks = (
+  _: LikeC4Services
+): ValidationCheck<ast.NotesProperty> => {
+  return (node, accept) => {
+    if (!AstUtils.hasContainerOfType(node, ast.isDynamicViewStep)) {
+      accept('error', `Notes can be defined only inside dynamic view`, {
+        node
+      })
+    }
+  }
+}

package/src/validation/specification.ts

@@ -8,7 +8,7 @@ export const specificationRuleChecks = (
 ): ValidationCheck<ast.SpecificationRule> => {
   return (node, accept) => {
     if (node.$containerIndex && node.$containerIndex > 0) {
-      accept('error', `Only one specification per document is allowed`, {
+      accept('warning', `Prefer one specification per document`, {
         node: node,
         property: 'name'
       })
@@ -19,7 +19,7 @@ export const specificationRuleChecks = (
 export const modelRuleChecks = (_: LikeC4Services): ValidationCheck<ast.Model> => {
   return (node, accept) => {
     if (node.$containerIndex && node.$containerIndex > 0) {
-      accept('error', `Only one model per document is allowed`, {
+      accept('warning', `Prefer one model per document`, {
         node: node,
         property: 'name'
       })
@@ -30,7 +30,7 @@ export const modelRuleChecks = (_: LikeC4Services): ValidationCheck<ast.Model> =
 export const modelViewsChecks = (_: LikeC4Services): ValidationCheck<ast.ModelViews> => {
   return (node, accept) => {
     if (node.$containerIndex && node.$containerIndex > 0) {
-      accept('error', `Only one views block per document is allowed`, {
+      accept('warning', `Prefer one views block per document`, {
         node: node,
         property: 'name'
       })

package/src/view-utils/manual-layout.ts

@@ -1,4 +1,4 @@
-import type { ViewManualLayout } from '@likec4/core/types'
+import type { ViewManualLayout } from '@likec4/core'
 import { decode, encode } from '@msgpack/msgpack'
 import { fromBase64, toBase64 } from '@smithy/util-base64'
 import { mapValues } from 'remeda'

package/src/view-utils/resolve-extended-views.ts

@@ -1,9 +1,7 @@
-import graphlib from '@dagrejs/graphlib'
 import { isExtendsElementView, type LikeC4View } from '@likec4/core'
-
-// '@dagrejs/graphlib' is a CommonJS module
-// Here is a workaround to import it
-const { Graph, alg } = graphlib
+import { logger } from '@likec4/log'
+import { first, last, values } from 'remeda'
+import { findCycles, Graph, isAcyclic, postorder } from '../utils/graphlib'
 
 /**
  * Resolve rules of extended views
@@ -18,21 +16,31 @@ export function resolveRulesExtendedViews<V extends Record<any, LikeC4View>>(
     multigraph: false,
     compound: false
   })
-  for (const view of Object.values(unresolvedViews)) {
+  for (const view of values(unresolvedViews)) {
     g.setNode(view.id)
     if (isExtendsElementView(view)) {
       // view -> parent
       g.setEdge(view.id, view.extends)
     }
   }
+  if (g.edgeCount() === 0) {
+    return unresolvedViews
+  }
 
   // Remove circular dependencies
-  const cycles = alg.findCycles(g)
-  if (cycles.length > 0) {
-    cycles.flat().forEach(id => g.removeNode(id))
+  while (!isAcyclic(g)) {
+    const firstCycle = first(findCycles(g))
+    if (!firstCycle) {
+      break
+    }
+    const cycledNode = last(firstCycle)
+    if (!cycledNode) {
+      break
+    }
+    g.removeNode(cycledNode)
   }
 
-  const ordered = alg.postorder(g, g.sources())
+  const ordered = postorder(g, g.sources())
 
   return ordered.reduce((acc, id) => {
     const view = unresolvedViews[id]
@@ -42,6 +50,7 @@ export function resolveRulesExtendedViews<V extends Record<any, LikeC4View>>(
     if (isExtendsElementView(view)) {
       const extendsFrom = acc[view.extends]
       if (!extendsFrom) {
+        logger.debug(`View "${view.id}" extends from "${view.extends}" which does not exist`)
         return acc
       }
       return Object.assign(acc, {

package/src/view-utils/resolve-relative-paths.ts

@@ -1,6 +1,7 @@
 import type { LikeC4View } from '@likec4/core'
-import { invariant } from '@likec4/core'
-import { filter, hasAtLeast, isTruthy, map, pipe, unique, zip } from 'remeda'
+import { compareNatural, invariant } from '@likec4/core'
+import { filter, hasAtLeast, isTruthy, map, pipe, unique } from 'remeda'
+import { parsePath } from 'ufo'
 
 function commonAncestorPath(views: LikeC4View[], sep = '/') {
   const uniqURIs = pipe(
@@ -10,21 +11,21 @@ function commonAncestorPath(views: LikeC4View[], sep = '/') {
     unique()
   )
   if (uniqURIs.length === 0) return ''
-  if (hasAtLeast(uniqURIs, 1) && uniqURIs.length === 1) {
-    const parts = new URL(uniqURIs[0]).pathname.split(sep)
+  if (uniqURIs.length === 1) {
+    const parts = parsePath(uniqURIs[0]).pathname.split(sep)
     if (parts.length <= 1) return sep
     parts.pop() // remove filename
     return parts.join(sep) + sep
   }
   invariant(hasAtLeast(uniqURIs, 2), 'Expected at least 2 unique URIs')
   const [baseUri, ...tail] = uniqURIs
-  const parts = new URL(baseUri).pathname.split(sep)
+  const parts = parsePath(baseUri).pathname.split(sep)
   let endOfPrefix = parts.length
   for (const uri of tail) {
     if (uri === baseUri) {
       continue
     }
-    const compare = new URL(uri).pathname.split(sep)
+    const compare = parsePath(uri).pathname.split(sep)
     for (let i = 0; i < endOfPrefix; i++) {
       if (compare[i] !== parts[i]) {
         endOfPrefix = i
@@ -46,11 +47,11 @@ export function resolveRelativePaths(views: LikeC4View[]): LikeC4View[] {
       .map(view => {
         if (!view.docUri) {
           return {
-            ...view,
+            view,
             parts: []
           }
         }
-        let path = new URL(view.docUri).pathname
+        let path = parsePath(view.docUri).pathname
         if (commonPrefix.length > 0) {
           invariant(
             path.startsWith(commonPrefix),
@@ -61,31 +62,25 @@ export function resolveRelativePaths(views: LikeC4View[]): LikeC4View[] {
           path = path.includes(sep) ? path.slice(path.lastIndexOf(sep) + 1) : path
         }
         return {
-          ...view,
+          view,
           parts: path.split(sep)
         }
       })
       // Sort views by path segments
       .sort((a, b) => {
-        if (a.parts.length === b.parts.length) {
-          if (a.parts.length === 0) {
-            return 0
-          }
-          if (a.parts.length === 1 && hasAtLeast(a.parts, 1) && hasAtLeast(b.parts, 1)) {
-            return a.parts[0].localeCompare(b.parts[0])
-          }
-          for (const [_a, _b] of zip(a.parts, b.parts)) {
-            const compare = _a.localeCompare(_b)
-            if (compare !== 0) {
-              return compare
-            }
+        if (a.parts.length !== b.parts.length) {
+          return a.parts.length - b.parts.length
+        }
+        for (let i = 0; i < a.parts.length; i++) {
+          const compare = compareNatural(a.parts[i], b.parts[i])
+          if (compare !== 0) {
+            return compare
           }
-          return 0
         }
-        return a.parts.length - b.parts.length
+        return compareNatural(a.view.title ?? a.view.id, b.view.title ?? b.view.id)
       })
       // Build relativePath from path segments
-      .map(({ parts, ...view }) => {
+      .map(({ parts, view }) => {
         return {
           ...view,
           relativePath: parts.join(sep)

package/src/view-utils/view-hash.ts

@@ -1,4 +1,4 @@
-import type { ComputedView } from '@likec4/core/types'
+import type { ComputedView } from '@likec4/core'
 import objectHash from 'object-hash'
 import { isTruthy, map, mapToObj, pick, pipe } from 'remeda'
 import type { SetOptional } from 'type-fest'

package/src/reset.d.ts

@@ -1,2 +0,0 @@
-// Do not add any other lines of code to this file!
-import '@total-typescript/ts-reset'