@likec4/language-server 1.17.1 → 1.18.0

package/src/model/deployments-index.ts

@@ -0,0 +1,218 @@
+import type { Fqn } from '@likec4/core'
+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,
+  ElementOps,
+  isLikeC4LangiumDocument,
+  type LikeC4LangiumDocument
+} from '../ast'
+import { logWarnError } from '../logger'
+import type { LikeC4Services } from '../module'
+import type { LikeC4NameProvider } from '../references'
+
+const DeploymentsIndexKey = Symbol.for('DeploymentsIndex')
+
+type IndexedDocument = LangiumDocument & {
+  [DeploymentsIndexKey]?: DocumentDeploymentsIndex
+}
+
+export class DeploymentsIndex {
+  protected Names: LikeC4NameProvider
+  protected langiumDocuments: LangiumDocuments
+
+  constructor(private services: LikeC4Services) {
+    this.Names = services.references.NameProvider
+    this.langiumDocuments = services.shared.workspace.LangiumDocuments
+
+    services.shared.workspace.DocumentBuilder.onBuildPhase(
+      DocumentState.IndexedContent,
+      (docs, _cancelToken) => {
+        for (const doc of docs) {
+          delete (doc as IndexedDocument)[DeploymentsIndexKey]
+        }
+      }
+    )
+  }
+
+  private documents() {
+    return this.langiumDocuments.all.filter((d): d is LikeC4LangiumDocument =>
+      isLikeC4LangiumDocument(d) && d.state >= DocumentState.IndexedContent
+    )
+  }
+
+  public get(document: LikeC4LangiumDocument): DocumentDeploymentsIndex {
+    if (document.state < DocumentState.IndexedContent) {
+      logWarnError(`Document ${document.uri.path} is not indexed`)
+    }
+    return (document as IndexedDocument)[DeploymentsIndexKey] ??= this.createDocumentIndex(document)
+  }
+  /**
+   * Nested elements (nodes/artifacts) of the node
+   * @param nodeName Name of the deployment node
+   * @returns Stream of artifacts
+   */
+  public nested(node: ast.DeploymentNode): Stream<DeploymentAstNodeDescription> {
+    const fqnName = this.getFqnName(node)
+    return this.documents().flatMap(doc => this.get(doc).nested(fqnName))
+  }
+
+  public byFqn(fqnName: string): Stream<DeploymentAstNodeDescription> {
+    return this.documents().flatMap(doc => this.get(doc).byFqn(fqnName))
+  }
+
+  public getFqnName(node: ast.DeploymentElement): Fqn {
+    let id = ElementOps.readId(node)
+    if (isTruthy(id)) {
+      return id
+    }
+    const fqn = [
+      this.Names.getNameStrict(node)
+    ]
+    let parentNode: ast.DeploymentNode | undefined
+    while ((parentNode = AstUtils.getContainerOfType(node.$container, ast.isDeploymentNode))) {
+      fqn.push(this.Names.getNameStrict(parentNode))
+      node = parentNode
+    }
+    id = fqn.reduceRight((acc, cur) => `${acc}.${cur}`) as Fqn
+    ElementOps.writeId(node, id)
+    return id
+  }
+
+  public createDocumentIndex(document: LikeC4LangiumDocument): DocumentDeploymentsIndex {
+    const rootNodes = document.parseResult.value.deployments.flatMap(m => m.elements)
+    if (rootNodes.length === 0) {
+      return DocumentDeploymentsIndex.EMPTY
+    }
+    const _root = new Array<DeploymentAstNodeDescription>()
+    const _nested = new MultiMap<string, DeploymentAstNodeDescription>()
+    const _byfqn = new MultiMap<string, DeploymentAstNodeDescription>()
+    const Names = this.Names
+    const Descriptions = this.services.workspace.AstNodeDescriptionProvider
+
+    const createAndSaveDescription = (
+      props: { node: ast.DeploymentNode | ast.DeployedInstance; name: string; fqn: string }
+    ) => {
+      const desc = {
+        ...Descriptions.createDescription(props.node, props.name, document),
+        fqn: props.fqn
+      }
+      ElementOps.writeId(props.node, props.fqn as Fqn)
+      _byfqn.add(props.fqn, desc)
+      return desc
+    }
+
+    const traverseNode = (
+      container: ast.DeploymentNode,
+      parentFqn: string
+    ): readonly DeploymentAstNodeDescription[] => {
+      const _descedants = [] as DeploymentAstNodeDescription[]
+      const children = container.body?.elements
+      if (!children || children.length === 0) {
+        return []
+      }
+      const directChildren = new Set<string>()
+      for (const node of children) {
+        if (ast.isDeploymentRelation(node)) {
+          continue
+        }
+        try {
+          const name = Names.getName(node)
+          if (isTruthy(name)) {
+            const fqn = `${parentFqn}.${name}`
+            const desc = createAndSaveDescription({ node, name, fqn })
+            _nested.add(parentFqn, desc)
+            directChildren.add(desc.name)
+            if (ast.isDeploymentNode(node) && node.body) {
+              _descedants.push(...traverseNode(node, fqn))
+            }
+          }
+        } catch (e) {
+          logWarnError(e)
+        }
+      }
+      if (_descedants.length > 0) {
+        pipe(
+          _descedants,
+          groupBy(prop('name')),
+          forEachObj((descs, key) => {
+            if (descs.length > 1 || directChildren.has(key)) {
+              return
+            }
+            _nested.add(parentFqn, descs[0])
+          })
+        )
+      }
+      return _nested.get(parentFqn)
+    }
+
+    for (const node of rootNodes) {
+      try {
+        if (ast.isDeploymentRelation(node)) {
+          continue
+        }
+        const name = Names.getName(node)
+        if (isTruthy(name)) {
+          _root.push(createAndSaveDescription({ node, name, fqn: name }))
+          traverseNode(node, name)
+        }
+      } catch (e) {
+        logWarnError(e)
+      }
+    }
+    return new DocumentDeploymentsIndex(_root, _nested, _byfqn)
+  }
+}
+
+export class DocumentDeploymentsIndex {
+  static readonly EMPTY = new DocumentDeploymentsIndex([], new MultiMap(), new MultiMap())
+
+  constructor(
+    private _rootNodes: Array<DeploymentAstNodeDescription>,
+    /**
+     * Nested of a deployment node
+     */
+    private _nested: MultiMap<string, DeploymentAstNodeDescription>,
+    /**
+     * All elements by FQN
+     */
+    private _byfqn: MultiMap<string, DeploymentAstNodeDescription>
+  ) {}
+
+  public rootNodes(): readonly DeploymentAstNodeDescription[] {
+    return this._rootNodes
+  }
+
+  public byFqn(fqnName: string): readonly DeploymentAstNodeDescription[] {
+    return this._byfqn.get(fqnName)
+  }
+
+  /**
+   * Returns artifacts of a deployment node
+   * @param nodeName Name of the deployment node
+   * @returns Stream of artifacts
+   */
+  public nested(nodeName: string): readonly DeploymentAstNodeDescription[] {
+    return this._nested.get(nodeName)
+  }
+
+  /**
+   * Returns all deployment elements in the document,
+   * with unique combination "type and name"
+   */
+  public unique(): readonly DeploymentAstNodeDescription[] {
+    const result = [] as DeploymentAstNodeDescription[]
+    pipe(
+      [...this._byfqn.values()],
+      groupBy(prop('name')),
+      forEachObj(descs => {
+        if (descs.length === 1) {
+          result.push(descs[0])
+        }
+      })
+    )
+    return result
+  }
+}

package/src/model/fqn-computation.ts

@@ -3,9 +3,9 @@ import type * as c4 from '@likec4/core'
 import { type AstNodeDescription, type AstNodeLocator, AstUtils, CstUtils, GrammarUtils, MultiMap } from 'langium'
 import { isDefined, isEmpty } from 'remeda'
 import { ast, ElementOps, type LikeC4LangiumDocument } from '../ast'
-import { getFqnElementRef } from '../elementRef'
 import { logError } from '../logger'
 import type { LikeC4Services } from '../module'
+import { getFqnElementRef } from '../utils/elementRef'
 
 const { findNodeForProperty } = GrammarUtils
 const { toDocumentSegment } = CstUtils

package/src/model/fqn-index.ts

@@ -6,7 +6,6 @@ import type { ast, DocFqnIndexAstNodeDescription, FqnIndexedDocument } from '../
 import { ElementOps, isFqnIndexedDocument, isLikeC4LangiumDocument } from '../ast'
 import { logger, logWarnError } from '../logger'
 import type { LikeC4Services } from '../module'
-import { printDocs } from '../utils/printDocs'
 import { computeDocumentFqn } from './fqn-computation'
 
 export interface FqnIndexEntry {

package/src/model/index.ts

@@ -1,3 +1,4 @@
+export * from './deployments-index'
 export * from './fqn-computation'
 export * from './fqn-index'
 export * from './model-builder'

package/src/model/model-builder.ts

@@ -1,14 +1,14 @@
-import type * as c4 from '@likec4/core'
+import * as c4 from '@likec4/core'
 import {
   compareRelations,
   computeColorValues,
   type CustomColorDefinitions,
-  isElementView,
   isScopedElementView,
   parentFqn,
   sortByFqnHierarchically,
-  type ViewID
+  type ViewId
 } from '@likec4/core'
+import { mkComputeView, 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'
@@ -17,6 +17,7 @@ import {
   flatMap,
   groupBy,
   indexBy,
+  isDefined,
   isEmpty,
   isNonNullish,
   isNullish,
@@ -25,6 +26,7 @@ import {
   map,
   mapToObj,
   mapValues,
+  pick,
   pipe,
   prop,
   reduce,
@@ -33,6 +35,7 @@ import {
   values
 } from 'remeda'
 import type {
+  ParsedAstDeploymentRelation,
   ParsedAstElement,
   ParsedAstRelation,
   ParsedAstSpecification,
@@ -42,14 +45,14 @@ import type {
 } from '../ast'
 import { isParsedLikeC4LangiumDocument } from '../ast'
 import { logError, logger, logWarnError } from '../logger'
-import { computeDynamicView, computeView, LikeC4ModelGraph } from '../model-graph'
 import type { LikeC4Services } from '../module'
-import { assignNavigateTo, resolveRelativePaths, resolveRulesExtendedViews } from '../view-utils'
+import { assignNavigateTo, resolveRelativePaths } from '../view-utils'
 
 function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[]): c4.ParsedLikeC4Model {
   // Merge specifications and globals from all documents
   const c4Specification: ParsedAstSpecification = {
     tags: new Set(),
+    deployments: {},
     elements: {},
     relationships: {},
     colors: {}
@@ -69,7 +72,7 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
     Object.assign(c4Specification.elements, spec.elements)
     Object.assign(c4Specification.relationships, spec.relationships)
     Object.assign(c4Specification.colors, spec.colors)
-
+    Object.assign(c4Specification.deployments, spec.deployments)
     Object.assign(globals.predicates, c4Globals.predicates)
     Object.assign(globals.dynamicPredicates, c4Globals.dynamicPredicates)
     Object.assign(globals.styles, c4Globals.styles)
@@ -189,7 +192,9 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
     }: ParsedAstRelation): c4.Relation | null => {
       if (isNullish(elements[source]) || isNullish(elements[target])) {
         logger.warn(
-          `Invalid relation ${id}, source: ${source}(${!!elements[source]}), target: ${target}(${!!elements[target]})`
+          `Invalid relation ${id} at ${doc.uri.path} ${astPath}, source: ${source}(${!!elements[
+            source
+          ]}), target: ${target}(${!!elements[target]})`
         )
         return null
       }
@@ -207,7 +212,7 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
         } satisfies c4.Relation
       }
       return {
-        ...(links && { links }),
+        ...links && { links },
         ...model,
         source,
         target,
@@ -225,6 +230,128 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
     indexBy(prop('id'))
   )
 
+  function toDeploymentElement(doc: LangiumDocument) {
+    return (parsed: c4.DeploymentElement): c4.DeploymentElement | null => {
+      if (!c4.DeploymentElement.isDeploymentNode(parsed)) {
+        if (!parsed.links || parsed.links.length === 0) {
+          return parsed
+        }
+        const links = resolveLinks(doc, parsed.links)
+        return {
+          ...parsed,
+          links
+        }
+      }
+      try {
+        const __kind = c4Specification.deployments[parsed.kind]
+        if (!__kind) {
+          logger.warn(`No kind '${parsed.kind}' found for ${parsed.id}`)
+          return null
+        }
+        let {
+          technology = __kind.technology,
+          notation = __kind.notation,
+          links,
+          style
+        } = parsed
+        return {
+          ...parsed,
+          ...notation && { notation },
+          ...technology && { technology },
+          style: {
+            border: 'dashed',
+            opacity: 10,
+            ...__kind.style,
+            ...style
+          },
+          links: links ? resolveLinks(doc, links) : null
+        }
+      } catch (e) {
+        logWarnError(e)
+      }
+      return null
+    }
+  }
+
+  const deploymentElements = pipe(
+    docs,
+    flatMap(d => map(d.c4Deployments, toDeploymentElement(d))),
+    filter(isTruthy),
+    // 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)
+        if (parent && isNullish(acc[parent])) {
+          logWarnError(`No parent found for deployment element ${el.id}`)
+          return acc
+        }
+        acc[el.id] = el
+        return acc
+      },
+      {} as c4.ParsedLikeC4Model['deployments']['elements']
+    )
+  )
+
+  function toDeploymentRelation(doc: LangiumDocument) {
+    return ({
+      astPath,
+      source,
+      target,
+      kind,
+      links: unresolvedLinks,
+      id,
+      ...model
+    }: ParsedAstDeploymentRelation): c4.DeploymentRelation | null => {
+      if (isNullish(deploymentElements[source.id]) || isNullish(deploymentElements[target.id])) {
+        logger.warn(
+          `Invalid deployment relation ${id} at ${doc.uri.path} ${astPath}, source: ${source.id}(${!!deploymentElements[
+            source.id
+          ]}), target: ${target.id}(${!!deploymentElements[target.id]})`
+        )
+        return null
+      }
+      const links = unresolvedLinks ? resolveLinks(doc, unresolvedLinks) : null
+
+      if (isNonNullish(kind) && kind in c4Specification.relationships) {
+        return {
+          ...c4Specification.relationships[kind],
+          ...model,
+          ...(links && { links }),
+          source,
+          target,
+          kind,
+          id
+        } satisfies c4.DeploymentRelation
+      }
+      return {
+        ...links && { links },
+        ...model,
+        source,
+        target,
+        id
+      } satisfies c4.DeploymentRelation
+    }
+  }
+
+  const deploymentRelations = pipe(
+    docs,
+    flatMap(d => map(d.c4DeploymentRelations, toDeploymentRelation(d))),
+    filter(isTruthy),
+    reduce(
+      (acc, el) => {
+        if (isDefined(acc[el.id])) {
+          logWarnError(`Duplicate deployment relation ${el.id}`)
+          return acc
+        }
+        acc[el.id] = el
+        return acc
+      },
+      {} as c4.ParsedLikeC4Model['deployments']['relations']
+    )
+  )
+
   function toC4View(doc: LangiumDocument) {
     const docUri = doc.uri.toString()
     return (parsedAstView: ParsedAstView): c4.LikeC4View => {
@@ -273,7 +400,7 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
   if (!parsedViews.some(v => v.id === 'index')) {
     parsedViews.unshift({
       __: 'element',
-      id: 'index' as ViewID,
+      id: 'index' as ViewId,
       title: 'Landscape view',
       description: null,
       tags: null,
@@ -301,12 +428,17 @@ function buildModel(services: LikeC4Services, docs: ParsedLikeC4LangiumDocument[
     specification: {
       tags: Array.from(c4Specification.tags),
       elements: c4Specification.elements,
-      relationships: c4Specification.relationships
+      relationships: c4Specification.relationships,
+      deployments: c4Specification.deployments
     },
     elements,
     relations,
     globals,
-    views
+    views,
+    deployments: {
+      elements: deploymentElements,
+      relations: deploymentRelations
+    }
   }
 }
 
@@ -335,8 +467,8 @@ export class LikeC4ModelBuilder {
         let parsed = [] as URI[]
         try {
           logger.debug(`[ModelBuilder] onValidated (${docs.length} docs)`)
-          for (const doc of parser.parse(docs)) {
-            parsed.push(doc.uri)
+          for (const doc of docs) {
+            parsed.push(parser.parse(doc).uri)
           }
         } catch (e) {
           logWarnError(e)
@@ -356,13 +488,13 @@ export class LikeC4ModelBuilder {
    * Otherwise, the model may be incomplete.
    */
   public unsafeSyncBuildModel(): c4.ParsedLikeC4Model | null {
+    const docs = this.documents()
+    if (docs.length === 0) {
+      logger.debug('[ModelBuilder] No documents to build model from')
+      return 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 (${docs.length} docs)`)
       return buildModel(this.services, docs)
     })
@@ -370,8 +502,9 @@ export class LikeC4ModelBuilder {
 
   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)!
+    const cached = cache.get(CACHE_KEY_PARSED_MODEL)
+    if (cached) {
+      return cached
     }
     return await this.services.shared.workspace.WorkspaceLock.read(async () => {
       if (cancelToken) {
@@ -381,7 +514,7 @@ export class LikeC4ModelBuilder {
     })
   }
 
-  private previousViews: Record<ViewID, c4.ComputedView> = {}
+  private previousViews: Record<ViewId, c4.ComputedView> = {}
 
   /**
    * WARNING:
@@ -392,13 +525,10 @@ 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 index = new LikeC4ModelGraph(model)
-
+      const computeView = mkComputeView(model)
       const allViews = [] as c4.ComputedView[]
       for (const view of values(model.views)) {
-        const result = isElementView(view)
-          ? computeView(view, index)
-          : computeDynamicView(view, index)
+        const result = computeView(view)
         if (!result.isSuccess) {
           logWarnError(result.error)
           continue
@@ -414,10 +544,15 @@ export class LikeC4ModelBuilder {
       })
       this.previousViews = { ...views }
       return {
-        specification: model.specification,
-        elements: model.elements,
-        relations: model.relations,
-        globals: model.globals,
+        ...structuredClone(
+          pick(model, [
+            'specification',
+            'elements',
+            'relations',
+            'globals',
+            'deployments'
+          ])
+        ),
         views
       }
     })
@@ -443,7 +578,7 @@ export class LikeC4ModelBuilder {
   }
 
   public async computeView(
-    viewId: ViewID,
+    viewId: ViewId,
     cancelToken?: Cancellation.CancellationToken
   ): Promise<c4.ComputedView | null> {
     const cache = this.services.WorkspaceCache as WorkspaceCache<string, c4.ComputedView | null>
@@ -462,10 +597,7 @@ export class LikeC4ModelBuilder {
           logger.warn(`[ModelBuilder] Cannot find view ${viewId}`)
           return null
         }
-        const index = new LikeC4ModelGraph(model)
-        const result = isElementView(view)
-          ? computeView(view, index)
-          : computeDynamicView(view, index)
+        const result = mkComputeView(model)(view)
         if (!result.isSuccess) {
           logError(result.error)
           return null
@@ -490,8 +622,11 @@ export class LikeC4ModelBuilder {
         }
 
         const previous = this.previousViews[viewId]
-        computedView = previous && eq(computedView, previous) ? previous : computedView
-        this.previousViews[viewId] = computedView
+        if (previous && eq(computedView, previous)) {
+          computedView = previous
+        } else {
+          this.previousViews[viewId] = computedView
+        }
 
         return computedView
       })