@likec4/language-server 1.8.0 → 1.9.0

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/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/_shared.ts

@@ -0,0 +1,24 @@
+import { type AstNode, interruptAndCheck, type ValidationAcceptor, type ValidationCheck } from 'langium'
+import type { CancellationToken } from 'vscode-jsonrpc'
+import { logWarnError } from '../logger'
+
+export const RESERVED_WORDS = [
+  'this',
+  'it',
+  'self',
+  'super',
+  'likec4lib'
+]
+
+export function tryOrLog<T extends AstNode>(fn: ValidationCheck<T>): ValidationCheck<T> {
+  return async (node: T, accept: ValidationAcceptor, cancelToken: CancellationToken) => {
+    if (cancelToken) {
+      await interruptAndCheck(cancelToken)
+    }
+    try {
+      await fn(node, accept, cancelToken)
+    } catch (e) {
+      logWarnError(e)
+    }
+  }
+}

package/src/validation/element.ts

@@ -1,13 +1,14 @@
 import { AstUtils, type ValidationCheck } from 'langium'
 import type { ast } from '../ast'
 import type { LikeC4Services } from '../module'
+import { RESERVED_WORDS, tryOrLog } from './_shared'
 
 const { getDocument } = AstUtils
 
 export const elementChecks = (services: LikeC4Services): ValidationCheck<ast.Element> => {
   const fqnIndex = services.likec4.FqnIndex
   const locator = services.workspace.AstNodeLocator
-  return (el, accept) => {
+  return tryOrLog((el, accept) => {
     const fqn = fqnIndex.getFqn(el)
     if (!fqn) {
       accept('error', 'Not indexed element', {
@@ -16,6 +17,12 @@ export const elementChecks = (services: LikeC4Services): ValidationCheck<ast.Ele
       })
       return
     }
+    if (RESERVED_WORDS.includes(el.name)) {
+      accept('error', `Reserved word: ${el.name}`, {
+        node: el,
+        property: 'name'
+      })
+    }
     const doc = getDocument(el)
     const docUri = doc.uri
     const elPath = locator.getAstNodePath(el)
@@ -45,12 +52,5 @@ export const elementChecks = (services: LikeC4Services): ValidationCheck<ast.Ele
         }
       )
     }
-    // for (let i = 3; i < el.props.length; i++) {
-    //   accept('error', `Too many properties, max 3 allowed`, {
-    //     node: el,
-    //     property: 'props',
-    //     index: i
-    //   })
-    // }
-  }
+  })
 }

package/src/validation/index.ts

@@ -5,7 +5,7 @@ import { dynamicViewRulePredicate } from './dynamic-view-rule'
 import { dynamicViewStep } from './dynamic-view-step'
 import { elementChecks } from './element'
 import { iconPropertyRuleChecks, opacityPropertyRuleChecks } from './property-checks'
-import { relationChecks } from './relation'
+import { relationBodyChecks, relationChecks } from './relation'
 import {
   elementKindChecks,
   modelRuleChecks,
@@ -37,6 +37,7 @@ export function registerValidationChecks(services: LikeC4Services) {
     Element: elementChecks(services),
     ElementKind: elementKindChecks(services),
     Relation: relationChecks(services),
+    RelationBody: relationBodyChecks(services),
     Tag: tagChecks(services),
     DynamicViewPredicateIterator: dynamicViewRulePredicate(services),
     ElementPredicateWith: elementPredicateWithChecks(services),

package/src/validation/relation.ts

@@ -1,57 +1,63 @@
 import { isSameHierarchy } from '@likec4/core'
 import type { ValidationCheck } from 'langium'
+import { isDefined } from 'remeda'
 import { ast } from '../ast'
 import { elementRef } from '../elementRef'
-import { logError } from '../logger'
 import type { LikeC4Services } from '../module'
+import { tryOrLog } from './_shared'
 
 export const relationChecks = (services: LikeC4Services): ValidationCheck<ast.Relation> => {
   const fqnIndex = services.likec4.FqnIndex
-  return (el, accept) => {
-    try {
-      const targetEl: ast.Element | undefined = elementRef(el.target)
-      const target = targetEl && fqnIndex.getFqn(targetEl)
-      if (!target) {
-        accept('error', 'Target not found (not parsed/indexed yet)', {
+  return tryOrLog((el, accept) => {
+    const targetEl: ast.Element | undefined = elementRef(el.target)
+    const target = targetEl && fqnIndex.getFqn(targetEl)
+    if (!target) {
+      accept('error', 'Target not resolved', {
+        node: el,
+        property: 'target'
+      })
+    }
+    let sourceEl
+    if (isDefined(el.source)) {
+      sourceEl = elementRef(el.source)
+      if (!sourceEl) {
+        return accept('error', 'Source not resolved', {
           node: el,
-          property: 'target'
+          property: 'source'
         })
       }
-      let sourceEl
-      if (ast.isExplicitRelation(el)) {
-        sourceEl = elementRef(el.source)
-        if (!sourceEl) {
-          return accept('error', 'Source not found (not parsed/indexed yet)', {
-            node: el,
-            property: 'source'
-          })
-        }
-      } else {
-        sourceEl = el.$container.$container
-      }
-
-      const source = fqnIndex.getFqn(sourceEl)
-
-      if (!source) {
-        accept('error', 'Source not found (not parsed/indexed yet)', {
+    } else {
+      if (!ast.isElementBody(el.$container)) {
+        return accept('error', 'Sourceless relation must be nested', {
           node: el
         })
       }
+      sourceEl = el.$container.$container
+    }
 
-      if (source && target && isSameHierarchy(source, target)) {
-        accept('error', 'Invalid parent-child relationship', {
-          node: el
-        })
-      }
+    const source = fqnIndex.getFqn(sourceEl)
 
-      if (el.tags?.values && el.body?.tags?.values) {
-        accept('error', 'Relation cannot have tags in both header and body', {
-          node: el,
-          property: 'tags'
-        })
-      }
-    } catch (e) {
-      logError(e)
+    if (!source) {
+      accept('error', 'Source not resolved', {
+        node: el
+      })
+    }
+
+    if (source && target && isSameHierarchy(source, target)) {
+      accept('error', 'Invalid parent-child relationship', {
+        node: el
+      })
+    }
+  })
+}
+
+export const relationBodyChecks = (_services: LikeC4Services): ValidationCheck<ast.RelationBody> => {
+  return tryOrLog((body, accept) => {
+    const relation = body.$container
+    if (relation.tags?.values && body.tags?.values) {
+      accept('error', 'Relation cannot have tags in both header and body', {
+        node: body.tags
+      })
     }
-  }
+  })
 }

package/src/validation/specification.ts

@@ -1,6 +1,7 @@
 import { AstUtils, type ValidationCheck } from 'langium'
 import { ast } from '../ast'
 import type { LikeC4Services } from '../module'
+import { RESERVED_WORDS, tryOrLog } from './_shared'
 
 export const specificationRuleChecks = (
   _: LikeC4Services
@@ -39,7 +40,13 @@ export const modelViewsChecks = (_: LikeC4Services): ValidationCheck<ast.ModelVi
 
 export const elementKindChecks = (services: LikeC4Services): ValidationCheck<ast.ElementKind> => {
   const index = services.shared.workspace.IndexManager
-  return (node, accept) => {
+  return tryOrLog((node, accept) => {
+    if (RESERVED_WORDS.includes(node.name)) {
+      accept('error', `Reserved word: ${node.name}`, {
+        node: node,
+        property: 'name'
+      })
+    }
     const sameKind = index
       .allElements(ast.ElementKind)
       .filter(n => n.name === node.name && n.node !== node)
@@ -62,7 +69,7 @@ export const elementKindChecks = (services: LikeC4Services): ValidationCheck<ast
         }
       })
     }
-  }
+  })
 }
 
 export const tagChecks = (services: LikeC4Services): ValidationCheck<ast.Tag> => {
@@ -103,6 +110,12 @@ export const relationshipChecks = (
 ): ValidationCheck<ast.RelationshipKind> => {
   const index = services.shared.workspace.IndexManager
   return (node, accept) => {
+    if (RESERVED_WORDS.includes(node.name)) {
+      accept('error', `Reserved word: ${node.name}`, {
+        node: node,
+        property: 'name'
+      })
+    }
     const sameKinds = index
       .allElements(ast.RelationshipKind)
       .filter(n => n.name === node.name)

package/src/validation/view.ts

@@ -1,6 +1,7 @@
 import { type ValidationCheck } from 'langium'
 import { ast } from '../ast'
 import type { LikeC4Services } from '../module'
+import { RESERVED_WORDS } from './_shared'
 
 export const viewChecks = (services: LikeC4Services): ValidationCheck<ast.LikeC4View> => {
   const index = services.shared.workspace.IndexManager
@@ -15,6 +16,12 @@ export const viewChecks = (services: LikeC4Services): ValidationCheck<ast.LikeC4
     if (!el.name) {
       return
     }
+    if (RESERVED_WORDS.includes(el.name)) {
+      accept('error', `Reserved word: ${el.name}`, {
+        node: el,
+        property: 'name'
+      })
+    }
     const anotherViews = index
       .allElements(ast.LikeC4View)
       .filter(n => n.name === el.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 { parsePath } from 'ufo'
 
 function commonAncestorPath(views: LikeC4View[], sep = '/') {
   const uniqURIs = pipe(
@@ -11,20 +12,20 @@ function commonAncestorPath(views: LikeC4View[], sep = '/') {
   )
   if (uniqURIs.length === 0) return ''
   if (hasAtLeast(uniqURIs, 1) && uniqURIs.length === 1) {
-    const parts = new URL(uniqURIs[0]).pathname.split(sep)
+    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
@@ -50,7 +51,7 @@ export function resolveRelativePaths(views: LikeC4View[]): LikeC4View[] {
             parts: []
           }
         }
-        let path = new URL(view.docUri).pathname
+        let path = parsePath(view.docUri).pathname
         if (commonPrefix.length > 0) {
           invariant(
             path.startsWith(commonPrefix),
@@ -71,9 +72,6 @@ export function resolveRelativePaths(views: LikeC4View[]): LikeC4View[] {
           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) {

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'