@likec4/language-server 1.8.0 → 1.9.0

package/src/model-graph/LikeC4ModelGraph.ts

@@ -3,14 +3,13 @@ import {
   commonAncestor,
   type Element,
   type Fqn,
-  InvalidModelError,
   invariant,
   isSameHierarchy,
-  isString,
   parentFqn,
   type Relation,
   type RelationID
 } from '@likec4/core'
+import { isArray, isString } from 'remeda'
 
 type Params = {
   elements: Record<Fqn, Element>
@@ -25,7 +24,7 @@ type RelationEdge = {
 }
 
 type FqnOrElement = Fqn | Element
-type FqnsOrElements = Fqn[] | Element[]
+type FqnsOrElements = ReadonlyArray<Fqn> | ReadonlyArray<Element>
 
 const RelationsSet = Set<Relation>
 const MapRelations = Map<Fqn, Set<Relation>>
@@ -37,9 +36,16 @@ function intersection<T>(a: Set<T>, b: Set<T>) {
   return new Set([...a].filter(value => b.has(value)))
 }
 
+/**
+ * Used only for views calculations.
+ * Subject to change.
+ */
 export class LikeC4ModelGraph {
   #elements = new Map<Fqn, Element>()
-  #children = new Map<Fqn, Fqn[]>()
+  // Parent element for given FQN
+  #parents = new Map<Fqn, Element>()
+  // Children elements for given FQN
+  #children = new Map<Fqn, Element[]>()
   #rootElements = new Set<Element>()
 
   #relations = new Map<RelationID, Relation>()
@@ -47,7 +53,7 @@ export class LikeC4ModelGraph {
   #incoming = new MapRelations()
   // Outgoing from an element or its descendants
   #outgoing = new MapRelations()
-  // Relationships inside the element descendants
+  // Relationships inside the element, among descendants
   #internal = new MapRelations()
 
   #cacheAscendingSiblings = new Map<Fqn, Element[]>()
@@ -80,7 +86,7 @@ export class LikeC4ModelGraph {
   }
 
   public children(id: Fqn) {
-    return this._childrenOf(id).flatMap(id => this.#elements.get(id) ?? [])
+    return this._childrenOf(id).slice()
   }
 
   // Get children or element itself if no children
@@ -93,19 +99,30 @@ export class LikeC4ModelGraph {
   public siblings(element: Fqn | Element) {
     const id = isString(element) ? element : element.id
     const parent = parentFqn(id)
-    const fqns = parent ? this._childrenOf(parent) : [...this.#rootElements].map(e => e.id)
-    return fqns.flatMap(fqn => (fqn !== id && this.#elements.get(fqn)) || [])
+    const siblings = parent ? this._childrenOf(parent) : this.rootElements
+    return siblings.filter(e => e.id !== id)
   }
 
-  public ancestors(element: Fqn | Element) {
-    const id = isString(element) ? element : element.id
-    return ancestorsFqn(id).flatMap(id => this.#elements.get(id) ?? [])
+  /**
+   * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+   * (from closest to root)
+   */
+  public ancestors(element: Fqn | Element): Array<Element> {
+    let id = isString(element) ? element : element.id
+    const result = [] as Element[]
+    let parent
+    while (parent = this.#parents.get(id)) {
+      result.push(parent)
+      id = parent.id
+    }
+    return result as Array<Element>
   }
 
   /**
    * Resolve siblings of the element and its ancestors
+   *  (from closest to root)
    */
-  public ascendingSiblings(element: Fqn | Element) {
+  public ascendingSiblings(element: Fqn | Element): Array<Element> {
     const id = isString(element) ? element : element.id
     let siblings = this.#cacheAscendingSiblings.get(id)
     if (!siblings) {
@@ -121,7 +138,10 @@ export class LikeC4ModelGraph {
   /**
    * Resolve all RelationEdges between element and others (any direction)
    */
-  public anyEdgesBetween(_element: Fqn | Element, others: Fqn[] | Element[]): RelationEdge[] {
+  public anyEdgesBetween(
+    _element: Fqn | Element,
+    others: ReadonlyArray<Fqn> | ReadonlyArray<Element>
+  ): Array<RelationEdge> {
     if (others.length === 0) {
       return []
     }
@@ -169,7 +189,7 @@ export class LikeC4ModelGraph {
   /**
    * Resolve all RelationEdges between elements (any direction)
    */
-  public edgesWithin<T extends Fqn[] | Element[]>(elements: T): RelationEdge[] {
+  public edgesWithin<T extends Fqn[] | Element[]>(elements: T): Array<RelationEdge> {
     if (elements.length < 2) {
       return []
     }
@@ -190,8 +210,8 @@ export class LikeC4ModelGraph {
     _sources: FqnOrElement | FqnsOrElements,
     _targets: FqnOrElement | FqnsOrElements
   ) {
-    const sources = Array.isArray(_sources) ? _sources : [_sources]
-    const targets = Array.isArray(_targets) ? _targets : [_targets]
+    const sources = isArray(_sources) ? _sources : [_sources]
+    const targets = isArray(_targets) ? _targets : [_targets]
     if (sources.length === 0 || targets.length === 0) {
       return []
     }
@@ -226,12 +246,13 @@ export class LikeC4ModelGraph {
 
   private addElement(el: Element) {
     if (this.#elements.has(el.id)) {
-      throw new InvalidModelError(`Element ${el.id} already exists`)
+      throw new Error(`Element ${el.id} already exists`)
     }
     this.#elements.set(el.id, el)
-    const parent = parentFqn(el.id)
-    if (parent) {
-      this._childrenOf(parent).push(el.id)
+    const parentId = parentFqn(el.id)
+    if (parentId) {
+      this.#parents.set(el.id, this.element(parentId))
+      this._childrenOf(parentId).push(el)
     } else {
       this.#rootElements.add(el)
     }
@@ -239,7 +260,7 @@ export class LikeC4ModelGraph {
 
   private addRelation(rel: Relation) {
     if (this.#relations.has(rel.id)) {
-      throw new InvalidModelError(`Relation ${rel.id} already exists`)
+      throw new Error(`Relation ${rel.id} already exists`)
     }
     this.#relations.set(rel.id, rel)
     this._incomingTo(rel.target).add(rel)

package/src/model-graph/compute-view/__test__/fixture.ts

@@ -1,5 +1,6 @@
 import {
   type BorderStyle,
+  type Color,
   type ComputedView,
   type CustomElementExpr as C4CustomElementExpr,
   type CustomRelationExpr as C4CustomRelationExpr,
@@ -17,7 +18,6 @@ import {
   type RelationshipLineType,
   type RelationWhereExpr,
   type Tag,
-  type ThemeColor,
   type ViewID,
   type ViewRule,
   type ViewRulePredicate,
@@ -210,28 +210,29 @@ export const fakeElements = {
 
 export type FakeElementIds = keyof typeof fakeElements
 
-const rel = ({
+const rel = <Source extends FakeElementIds, Target extends FakeElementIds>({
   source,
   target,
   title,
   ...props
 }: {
-  source: FakeElementIds
-  target: FakeElementIds
+  source: Source
+  target: Target
   title?: string
   kind?: string
-  color?: ThemeColor
+  color?: Color
   line?: RelationshipLineType
   head?: RelationshipArrowType
   tail?: RelationshipArrowType
   tags?: NonEmptyArray<TestTag>
-}): Relation => ({
-  id: `${source}:${target}` as RelationID,
-  title: title ?? '',
-  source: source as Fqn,
-  target: target as Fqn,
-  ...(props as any)
-})
+}) =>
+  ({
+    id: `${source}:${target}` as RelationID,
+    title: title ?? '',
+    source: source as Fqn,
+    target: target as Fqn,
+    ...(props as any)
+  }) as Omit<Relation, 'id'> & { id: `${Source}:${Target}` }
 
 export const fakeRelations = [
   rel({
@@ -321,7 +322,7 @@ export const fakeRelations = [
   })
 ]
 
-export type FakeRelationIds = keyof typeof fakeRelations
+export type FakeRelationIds = (typeof fakeRelations)[number]['id']
 
 export const fakeModel = new LikeC4ModelGraph({
   elements: fakeElements,
@@ -335,6 +336,7 @@ const emptyView = {
   description: null,
   tags: null,
   links: null,
+  customColorDefinitions: {},
   rules: []
 }
 
@@ -370,7 +372,7 @@ export function $custom(
     description?: string
     technology?: string
     shape?: ElementShape
-    color?: ThemeColor
+    color?: Color
     border?: BorderStyle
     icon?: string
     opacity?: number

package/src/model-graph/compute-view/compute.ts

@@ -1,4 +1,5 @@
 import type {
+  Color,
   ComputedEdge,
   ComputedElementView,
   EdgeId,
@@ -212,7 +213,7 @@ export class ComputeCtx {
           description?: string | undefined
           technology?: string | undefined
           kind?: RelationshipKind | undefined
-          color?: ThemeColor | undefined
+          color?: Color | undefined
           line?: RelationshipLineType | undefined
           head?: RelationshipArrowType | undefined
           tail?: RelationshipArrowType | undefined
@@ -273,7 +274,7 @@ export class ComputeCtx {
         edge,
         this.getEdgeLabel(relation),
         isTruthy(relation.description) && { description: relation.description },
-        isTruthy(relation.technology) && { description: relation.technology },
+        isTruthy(relation.technology) && { technology: relation.technology },
         isTruthy(relation.kind) && { kind: relation.kind },
         relation.color && { color: relation.color },
         relation.line && { line: relation.line },
@@ -537,16 +538,18 @@ export class ComputeCtx {
       return this
     }
     nonexhaustive(expr)
-  }  
+  }
 
-  protected getEdgeLabel(relation: { title: String | undefined, technology?: String | undefined }): { label: String } | false {
+  protected getEdgeLabel(
+    relation: { title: String | undefined; technology?: String | undefined }
+  ): { label: String } | false {
     const labelParts: String[] = []
 
-    if(isTruthy(relation.title)) {
+    if (isTruthy(relation.title)) {
       labelParts.push(relation.title)
     }
 
-    if(isTruthy(relation.technology)) {
+    if (isTruthy(relation.technology)) {
       labelParts.push(`[${relation.technology}]`)
     }
 

package/src/model-graph/compute-view/predicates.ts

@@ -306,15 +306,15 @@ function edgesIncomingExpr(this: ComputeCtx, expr: Expr.ElementExpression) {
   return this.graph.edgesBetween(sources, targets)
 }
 
-const filterEdges = (edges: ComputeCtx.Edge[], where?: RelationPredicateFn) => {
+const filterEdges = (edges: ReadonlyArray<ComputeCtx.Edge>, where?: RelationPredicateFn) => {
   if (!where) {
-    return edges
+    return edges as ComputeCtx.Edge[]
   }
   return pipe(
     edges,
     map(e => ({ ...e, relations: e.relations.filter(where) })),
     remedaFilter(e => e.relations.length > 0)
-  )
+  ) as ComputeCtx.Edge[]
 }
 
 const filterRelations = (edges: ComputeCtx.Edge[], where?: RelationPredicateFn) => {

package/src/model-graph/dynamic-view/__test__/fixture.ts

@@ -10,6 +10,7 @@ const emptyView = {
   description: null,
   tags: null,
   links: null,
+  customColorDefinitions: {},
   rules: []
 }
 

package/src/model-graph/dynamic-view/compute.ts

@@ -1,4 +1,5 @@
 import type {
+  Color,
   ComputedDynamicView,
   ComputedEdge,
   DynamicView,
@@ -38,7 +39,7 @@ export namespace DynamicViewComputeCtx {
     title: string | null
     description?: string
     technology?: string
-    color?: ThemeColor
+    color?: Color
     line?: RelationshipLineType
     head?: RelationshipArrowType
     tail?: RelationshipArrowType

package/src/model-graph/utils/elementExpressionToPredicate.ts

@@ -1,5 +1,5 @@
 import { Expr, nonexhaustive, parentFqn } from '@likec4/core'
-import { type Element, whereOperatorAsPredicate } from '@likec4/core/types'
+import { type Element, whereOperatorAsPredicate } from '@likec4/core'
 import { isNullish } from 'remeda'
 
 type Predicate<T> = (x: T) => boolean

package/src/model-graph/utils/sortNodes.ts

@@ -1,4 +1,3 @@
-import pkg from '@dagrejs/graphlib'
 import {
   compareByFqnHierarchically,
   compareRelations,
@@ -10,10 +9,7 @@ import {
   nonNullable
 } from '@likec4/core'
 import { difference, filter, map, pipe, sort, take } from 'remeda'
-
-// '@dagrejs/graphlib' is a CommonJS module
-// Here is a workaround to import it
-const { Graph, alg } = pkg
+import { Graph, postorder } from '../../utils/graphlib'
 
 // side effect
 function sortChildren(nodes: readonly ComputedNode[]) {
@@ -92,7 +88,7 @@ export function sortNodes({
       map(n => n.id)
     )
   }
-  const orderedIds = alg.postorder(g, sources).reverse() as Fqn[]
+  const orderedIds = postorder(g, sources).reverse() as Fqn[]
   const sorted = orderedIds.map(getNode)
   if (sorted.length < nodes.length) {
     const unsorted = difference(nodes, sorted)

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,
@@ -17,6 +17,7 @@ import {
   LikeC4DocumentLinkProvider,
   LikeC4DocumentSymbolProvider,
   LikeC4HoverProvider,
+  LikeC4RenameProvider,
   LikeC4SemanticTokenProvider
 } from './lsp'
 import { FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model'
@@ -69,6 +70,7 @@ export interface LikeC4AddedServices {
     ModelChanges: LikeC4ModelChanges
   }
   lsp: {
+    RenameProvider: LikeC4RenameProvider
     CompletionProvider: LikeC4CompletionProvider
     DocumentHighlightProvider: LikeC4DocumentHighlightProvider
     DocumentSymbolProvider: LikeC4DocumentSymbolProvider
@@ -101,6 +103,7 @@ export const LikeC4Module: Module<LikeC4Services, PartialLangiumServices & LikeC
     ModelLocator: bind(LikeC4ModelLocator)
   },
   lsp: {
+    RenameProvider: bind(LikeC4RenameProvider),
     CompletionProvider: bind(LikeC4CompletionProvider),
     DocumentHighlightProvider: bind(LikeC4DocumentHighlightProvider),
     DocumentSymbolProvider: bind(LikeC4DocumentSymbolProvider),
@@ -136,7 +139,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 +157,7 @@ export function createSharedServices(context: LanguageServicesContext = {}): Lik
     ...context
   }
   if (context.connection) {
+    logToLspConnection(context.connection)
     logErrorToTelemetry(context.connection)
   }
 
@@ -164,7 +176,15 @@ export function createLanguageServices(context: LanguageServicesContext = {}): {
   const likec4 = inject(createDefaultModule({ shared }), LikeC4GeneratedModule, LikeC4Module)
   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 }
 }
 

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 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,
@@ -7,6 +8,7 @@ import {
   DONE_RESULT,
   EMPTY_SCOPE,
   EMPTY_STREAM,
+  MapScope,
   type ReferenceInfo,
   type Scope,
   type Stream,
@@ -102,6 +104,17 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
           if (parent) {
             return new StreamScope(this.scopeElementRef(parent))
           }
+          // if we have elementRef "this" or "it" we resolve it to the closest element
+          if (context.reference.$refText === 'this' || context.reference.$refText === 'it') {
+            const closestElement = AstUtils.getContainerOfType(container, ast.isElement)
+            if (closestElement) {
+              return new MapScope([
+                this.descriptions.createDescription(closestElement, context.reference.$refText)
+              ])
+            } else {
+              return EMPTY_SCOPE
+            }
+          }
         }
         return this.computeScope(context)
       } catch (e) {
@@ -116,26 +129,26 @@ export class LikeC4ScopeProvider extends DefaultScopeProvider {
 
   protected computeScope(context: ReferenceInfo) {
     const referenceType = this.reflection.getReferenceType(context)
+    // computeScope is called only for elements
+    invariant(referenceType === ast.Element, 'Invalid reference type')
     const scopes: Stream<AstNodeDescription>[] = []
     const doc = getDocument(context.container)
     const precomputed = doc.precomputedScopes
 
     if (precomputed) {
       const byReferenceType = (desc: AstNodeDescription) => this.reflection.isSubtype(desc.type, referenceType)
-
       let container: AstNode | undefined = context.container
       while (container) {
         const elements = precomputed.get(container).filter(byReferenceType)
         if (elements.length > 0) {
           scopes.push(stream(elements))
         }
-        if (referenceType === ast.Element) {
-          if (ast.isExtendElementBody(container)) {
-            scopes.push(this.scopeExtendElement(container.$container))
-          }
-          if (ast.isElementViewBody(container)) {
-            scopes.push(this.scopeElementView(container.$container))
-          }
+
+        if (ast.isExtendElementBody(container)) {
+          scopes.push(this.scopeExtendElement(container.$container))
+        }
+        if (ast.isElementViewBody(container)) {
+          scopes.push(this.scopeElementView(container.$container))
         }
         container = container.$container
       }