@likec4/language-server 1.8.1 → 1.10.0

package/src/model/model-builder.ts

@@ -1,10 +1,12 @@
+import type * as c4 from '@likec4/core'
 import {
-  type c4,
-  compareByFqnHierarchically,
+  compareRelations,
+  computeColorValues,
+  type CustomColorDefinitions,
   isElementView,
   isScopedElementView,
   parentFqn,
-  type ScopedElementView,
+  sortByFqnHierarchically,
   type ViewID
 } from '@likec4/core'
 import { deepEqual as eq } from 'fast-equals'
@@ -12,17 +14,22 @@ import type { Cancellation, LangiumDocument, LangiumDocuments, URI, WorkspaceCac
 import { Disposable, DocumentState, interruptAndCheck } from 'langium'
 import {
   filter,
-  find,
   flatMap,
   forEach,
+  groupBy,
+  indexBy,
+  isEmpty,
+  isNonNullish,
   isNullish,
   isNumber,
   isTruthy,
   map,
   mapToObj,
+  mapValues,
   pipe,
   prop,
   reduce,
+  reverse,
   sort,
   values
 } from 'remeda'
@@ -31,7 +38,8 @@ import type {
   ParsedAstRelation,
   ParsedAstSpecification,
   ParsedAstView,
-  ParsedLikeC4LangiumDocument
+  ParsedLikeC4LangiumDocument,
+  ParsedLink
 } from '../ast'
 import { isParsedLikeC4LangiumDocument } from '../ast'
 import { logError, logger, logWarnError } from '../logger'
@@ -40,26 +48,48 @@ import type { LikeC4Services } from '../module'
 import { printDocs } from '../utils/printDocs'
 import { assignNavigateTo, resolveRelativePaths, resolveRulesExtendedViews } from '../view-utils'
 
-function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[]): c4.LikeC4Model {
+function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[]): c4.ParsedLikeC4Model {
   const c4Specification: ParsedAstSpecification = {
-    kinds: {},
-    relationships: {}
+    tags: new Set(),
+    elements: {},
+    relationships: {},
+    colors: {}
   }
   forEach(map(docs, prop('c4Specification')), spec => {
-    Object.assign(c4Specification.kinds, spec.kinds)
+    spec.tags.forEach(t => c4Specification.tags.add(t))
+    Object.assign(c4Specification.elements, spec.elements)
     Object.assign(c4Specification.relationships, spec.relationships)
+    Object.assign(c4Specification.colors, spec.colors)
   })
-  const resolveLinks = (doc: LangiumDocument, links: c4.NonEmptyArray<c4.Link>) => {
-    return links.map(l => ({
-      url: services.lsp.DocumentLinkProvider.resolveLink(doc, l.url),
-      ...(l.title && { title: l.title })
-    })) as c4.NonEmptyArray<c4.Link>
+  function resolveLinks(doc: LangiumDocument, links: c4.NonEmptyArray<ParsedLink>) {
+    return map(
+      links,
+      (link): c4.Link => {
+        try {
+          const relative = services.lsp.DocumentLinkProvider.relativeLink(doc, link.url)
+          if (relative && relative !== link.url) {
+            return {
+              ...link,
+              relative
+            }
+          }
+        } catch (e) {
+          logWarnError(e)
+        }
+        return link
+      }
+    )
   }
 
-  const toModelElement = (doc: LangiumDocument) => {
+  const customColorDefinitions: CustomColorDefinitions = mapValues(
+    c4Specification.colors,
+    c => computeColorValues(c.color)
+  )
+
+  function toModelElement(doc: LangiumDocument) {
     return ({
       tags,
-      links,
+      links: unresolvedLinks,
       style: {
         color,
         shape,
@@ -75,11 +105,12 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
       metadata
     }: ParsedAstElement): c4.Element | null => {
       try {
-        const __kind = c4Specification.kinds[kind]
+        const __kind = c4Specification.elements[kind]
         if (!__kind) {
           logger.warn(`No kind '${kind}' found for ${id}`)
           return null
         }
+        const links = unresolvedLinks ? resolveLinks(doc, unresolvedLinks) : null
         color ??= __kind.style.color
         shape ??= __kind.style.shape
         icon ??= __kind.style.icon
@@ -90,13 +121,13 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
           ...(color && { color }),
           ...(shape && { shape }),
           ...(icon && { icon }),
-          ...(metadata && { metadata }),
+          ...(metadata && !isEmpty(metadata) && { metadata }),
           ...(__kind.notation && { notation: __kind.notation }),
           style: {
             ...(border && { border }),
             ...(isNumber(opacity) && { opacity })
           },
-          links: links ? resolveLinks(doc, links) : null,
+          links,
           tags: tags ?? null,
           technology: technology ?? null,
           description: description ?? null,
@@ -115,7 +146,9 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
     docs,
     flatMap(d => map(d.c4Elements, toModelElement(d))),
     filter(isTruthy),
-    sort(compareByFqnHierarchically),
+    // sort from root elements to nested, so that parent is always present
+    // Import to preserve the order from the source
+    sortByFqnHierarchically,
     reduce(
       (acc, el) => {
         const parent = parentFqn(el.id)
@@ -123,25 +156,20 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
           logWarnError(`No parent found for ${el.id}`)
           return acc
         }
-        if (el.id in acc) {
-          // should not happen, as validated
-          logWarnError(`Duplicate element id: ${el.id}`)
-          return acc
-        }
         acc[el.id] = el
         return acc
       },
-      {} as c4.LikeC4Model['elements']
+      {} as c4.ParsedLikeC4Model['elements']
     )
   )
 
-  const toModelRelation = (doc: LangiumDocument) => {
+  function toModelRelation(doc: LangiumDocument) {
     return ({
       astPath,
       source,
       target,
       kind,
-      links,
+      links: unresolvedLinks,
       id,
       ...model
     }: ParsedAstRelation): c4.Relation | null => {
@@ -151,25 +179,26 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
         )
         return null
       }
+      const links = unresolvedLinks ? resolveLinks(doc, unresolvedLinks) : null
 
-      if (!isNullish(kind) && kind in c4Specification.relationships) {
+      if (isNonNullish(kind) && kind in c4Specification.relationships) {
         return {
-          ...(links && { links: resolveLinks(doc, links) }),
           ...c4Specification.relationships[kind],
           ...model,
+          ...(links && { links }),
           source,
           target,
           kind,
           id
-        }
+        } satisfies c4.Relation
       }
       return {
-        ...(links && { links: resolveLinks(doc, links) }),
+        ...(links && { links }),
         ...model,
         source,
         target,
         id
-      }
+      } satisfies c4.Relation
     }
   }
 
@@ -177,10 +206,12 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
     docs,
     flatMap(d => map(d.c4Relations, toModelRelation(d))),
     filter(isTruthy),
-    mapToObj(r => [r.id, r])
+    sort(compareRelations),
+    reverse(),
+    indexBy(prop('id'))
   )
 
-  const toC4View = (doc: LangiumDocument) => {
+  function toC4View(doc: LangiumDocument) {
     const docUri = doc.uri.toString()
     return (parsedAstView: ParsedAstView): c4.LikeC4View => {
       let {
@@ -188,11 +219,9 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
         title,
         description,
         tags,
-        links,
-
+        links: unresolvedLinks,
         // ignore this property
         astPath: _ignore,
-
         // model should include discriminant __
         ...model
       } = parsedAstView
@@ -205,34 +234,32 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
         title = 'Landscape view'
       }
 
+      const links = unresolvedLinks ? resolveLinks(doc, unresolvedLinks) : null
+
       return {
-        id,
-        title,
-        description,
+        ...model,
         tags,
-        links: links ? resolveLinks(doc, links) : null,
+        links,
         docUri,
-        ...model
+        description,
+        title,
+        id,
+        customColorDefinitions
       }
     }
   }
 
-  const views = pipe(
-    docs,
-    flatMap(d => map(d.c4Views, toC4View(d))),
-    resolveRelativePaths,
-    mapToObj(v => [v.id, v]),
-    resolveRulesExtendedViews
-  )
-  // add index view if not present
-  if (!('index' in views)) {
-    views['index' as ViewID] = {
+  const parsedViews = docs.flatMap(d => map(d.c4Views, toC4View(d)))
+  // Add index view if not present
+  if (!parsedViews.some(v => v.id === 'index')) {
+    parsedViews.unshift({
       __: 'element',
       id: 'index' as ViewID,
-      title: 'Landscape',
+      title: 'Landscape view',
       description: null,
       tags: null,
       links: null,
+      customColorDefinitions: customColorDefinitions,
       rules: [
         {
           include: [
@@ -242,17 +269,30 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
           ]
         }
       ]
-    }
+    })
   }
 
+  const views = pipe(
+    parsedViews,
+    resolveRelativePaths,
+    indexBy(prop('id')),
+    resolveRulesExtendedViews
+  )
+
   return {
+    specification: {
+      tags: Array.from(c4Specification.tags),
+      elements: c4Specification.elements,
+      relationships: c4Specification.relationships
+    },
     elements,
     relations,
     views
   }
 }
-const RAW_MODEL_CACHE = 'LikeC4RawModel'
-const MODEL_CACHE = 'LikeC4Model'
+
+const CACHE_KEY_PARSED_MODEL = 'ParsedLikeC4Model'
+const CACHE_KEY_COMPUTED_MODEL = 'ComputedLikeC4Model'
 
 type ModelParsedListener = (docs: URI[]) => void
 
@@ -274,9 +314,13 @@ export class LikeC4ModelBuilder {
       DocumentState.Validated,
       async (docs, _cancelToken) => {
         let parsed = [] as URI[]
-        logger.debug(`[ModelBuilder] onValidated (${docs.length} docs)\n${printDocs(docs)}`)
-        for (const doc of parser.parse(docs)) {
-          parsed.push(doc.uri)
+        try {
+          logger.debug(`[ModelBuilder] onValidated (${docs.length} docs)\n${printDocs(docs)}`)
+          for (const doc of parser.parse(docs)) {
+            parsed.push(doc.uri)
+          }
+        } catch (e) {
+          logWarnError(e)
         }
         if (parsed.length > 0) {
           this.notifyListeners(parsed)
@@ -287,35 +331,82 @@ export class LikeC4ModelBuilder {
     logger.debug(`[ModelBuilder] Created`)
   }
 
-  public async buildModel(cancelToken?: Cancellation.CancellationToken): Promise<c4.LikeC4Model | null> {
-    const cache = this.services.WorkspaceCache as WorkspaceCache<string, c4.LikeC4Model | null>
-    if (cache.has(RAW_MODEL_CACHE)) {
-      return cache.get(RAW_MODEL_CACHE)!
+  /**
+   * WARNING:
+   * This method is internal and should to be called only when all documents are known to be parsed.
+   * Otherwise, the model may be incomplete.
+   */
+  public unsafeSyncBuildModel(): c4.ParsedLikeC4Model | null {
+    const cache = this.services.WorkspaceCache as WorkspaceCache<string, c4.ParsedLikeC4Model | null>
+    return cache.get(CACHE_KEY_PARSED_MODEL, () => {
+      const docs = this.documents()
+      if (docs.length === 0) {
+        logger.debug('[ModelBuilder] No documents to build model from')
+        return null
+      }
+      logger.debug(`[ModelBuilder] buildModel from ${docs.length} docs:\n${printDocs(docs)}`)
+      return buildModel(this.services, docs)
+    })
+  }
+
+  public async buildModel(cancelToken?: Cancellation.CancellationToken): Promise<c4.ParsedLikeC4Model | null> {
+    const cache = this.services.WorkspaceCache as WorkspaceCache<string, c4.ParsedLikeC4Model | null>
+    if (cache.has(CACHE_KEY_PARSED_MODEL)) {
+      return cache.get(CACHE_KEY_PARSED_MODEL)!
     }
     return await this.services.shared.workspace.WorkspaceLock.read(async () => {
       if (cancelToken) {
         await interruptAndCheck(cancelToken)
       }
-      return cache.get(RAW_MODEL_CACHE, () => {
-        const docs = this.documents()
-        if (docs.length === 0) {
-          logger.debug('[ModelBuilder] No documents to build model from')
-          return null
-        }
-        logger.debug(`[ModelBuilder] buildModel from ${docs.length} docs:\n${printDocs(docs)}`)
-        return buildModel(this.services, docs)
-      })
+      return this.unsafeSyncBuildModel()
     })
   }
 
   private previousViews: Record<ViewID, c4.ComputedView> = {}
 
+  /**
+   * WARNING:
+   * This method is internal and should to be called only when all documents are known to be parsed.
+   * Otherwise, the model may be incomplete.
+   */
+  public unsafeSyncBuildComputedModel(model: c4.ParsedLikeC4Model): c4.ComputedLikeC4Model {
+    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 index = new LikeC4ModelGraph(model)
+
+      const allViews = [] as c4.ComputedView[]
+      for (const view of values(model.views)) {
+        const result = isElementView(view) ? computeView(view, index) : computeDynamicView(view, index)
+        if (!result.isSuccess) {
+          logWarnError(result.error)
+          continue
+        }
+        allViews.push(result.view)
+      }
+      assignNavigateTo(allViews)
+      const views = mapToObj(allViews, v => {
+        const previous = this.previousViews[v.id]
+        const view = previous && eq(v, previous) ? previous : v
+        viewsCache.set(computedViewKey(v.id), view)
+        return [v.id, view] as const
+      })
+      this.previousViews = { ...views }
+      return {
+        specification: model.specification,
+        elements: model.elements,
+        relations: model.relations,
+        views
+      }
+    })
+  }
+
   public async buildComputedModel(
     cancelToken?: Cancellation.CancellationToken
-  ): Promise<c4.LikeC4ComputedModel | null> {
-    const cache = this.services.WorkspaceCache as WorkspaceCache<string, c4.LikeC4ComputedModel | null>
-    if (cache.has(MODEL_CACHE)) {
-      return cache.get(MODEL_CACHE)!
+  ): Promise<c4.ComputedLikeC4Model | null> {
+    const cache = this.services.WorkspaceCache as WorkspaceCache<string, c4.ComputedLikeC4Model | null>
+    if (cache.has(CACHE_KEY_COMPUTED_MODEL)) {
+      return cache.get(CACHE_KEY_COMPUTED_MODEL)!
     }
     const model = await this.buildModel(cancelToken)
     if (!model) {
@@ -325,33 +416,7 @@ export class LikeC4ModelBuilder {
       if (cancelToken) {
         await interruptAndCheck(cancelToken)
       }
-      const viewsCache = this.services.WorkspaceCache as WorkspaceCache<string, c4.ComputedView | null>
-      return cache.get(MODEL_CACHE, () => {
-        const index = new LikeC4ModelGraph(model)
-
-        const allViews = [] as c4.ComputedView[]
-        for (const view of values(model.views)) {
-          const result = isElementView(view) ? computeView(view, index) : computeDynamicView(view, index)
-          if (!result.isSuccess) {
-            logWarnError(result.error)
-            continue
-          }
-          allViews.push(result.view)
-        }
-        assignNavigateTo(allViews)
-        const views = mapToObj(allViews, v => {
-          const previous = this.previousViews[v.id]
-          const view = previous && eq(v, previous) ? previous : v
-          viewsCache.set(computedViewKey(v.id), view)
-          return [v.id, view] as const
-        })
-        this.previousViews = { ...views }
-        return {
-          elements: model.elements,
-          relations: model.relations,
-          views
-        }
-      })
+      return this.unsafeSyncBuildComputedModel(model)
     })
   }
 
@@ -383,19 +448,22 @@ export class LikeC4ModelBuilder {
         }
         let computedView = result.view
 
-        const allElementViews = values(model.views).filter(
-          (v): v is ScopedElementView => isScopedElementView(v) && v.id !== viewId
+        const allElementViews = pipe(
+          model.views,
+          values(),
+          filter(isScopedElementView),
+          filter(v => v.id !== viewId),
+          groupBy(v => v.viewOf)
         )
 
-        computedView.nodes.forEach(node => {
+        for (const node of computedView.nodes) {
           if (!node.navigateTo) {
-            // find first element view that is not the current one
-            const navigateTo = find(allElementViews, v => v.viewOf === node.id)
-            if (navigateTo) {
-              node.navigateTo = navigateTo.id
+            const viewsOfNode = allElementViews[node.id]
+            if (viewsOfNode) {
+              node.navigateTo = viewsOfNode[0].id
             }
           }
-        })
+        }
 
         const previous = this.previousViews[viewId]
         computedView = previous && eq(computedView, previous) ? previous : computedView

package/src/model/model-locator.ts

@@ -1,4 +1,4 @@
-import type { likec4 as c4 } from '@likec4/core'
+import type * as c4 from '@likec4/core'
 import type { LangiumDocuments } from 'langium'
 import { AstUtils, GrammarUtils } from 'langium'
 import type { Location } from 'vscode-languageserver-types'

package/src/model/model-parser-where.ts

@@ -1,5 +1,6 @@
-import { type c4, invariant, isNonEmptyArray, nonexhaustive } from '@likec4/core'
-import { isAndOperator, isOrOperator } from '@likec4/core/types'
+import { invariant, isNonEmptyArray, nonexhaustive } from '@likec4/core'
+import { isAndOperator, isOrOperator } from '@likec4/core'
+import type * as c4 from '@likec4/core'
 import { ast } from '../ast'
 
 const parseEquals = (