@likec4/language-server 1.31.0 → 1.32.1

package/dist/model/builder/buildModel.js

@@ -1,6 +1,7 @@
+import * as c4 from "@likec4/core";
 import {
   computeColorValues,
-  DeploymentElement,
+  isDeploymentNode,
   isGlobalFqn,
   parentFqn,
   sortByFqnHierarchically
@@ -9,10 +10,12 @@ import { resolveRulesExtendedViews } from "@likec4/core/compute-view";
 import {
   filter,
   flatMap,
+  forEach,
   indexBy,
   isDefined,
   isNullish,
   isTruthy,
+  keys,
   map,
   mapValues,
   pipe,
@@ -23,14 +26,20 @@ import { logger } from "../../logger.js";
 import { resolveRelativePaths } from "../../view-utils/index.js";
 import { MergedExtends } from "./MergedExtends.js";
 import { MergedSpecification } from "./MergedSpecification.js";
-export function buildModelData(docs) {
+export function buildModelData(projectId, docs) {
   const c4Specification = new MergedSpecification(docs);
-  const customColorDefinitions = mapValues(
+  const customColors = mapValues(
     c4Specification.specs.colors,
     (c) => computeColorValues(c.color)
   );
+  const metadataKeys = /* @__PURE__ */ new Set();
   const elementExtends = new MergedExtends();
   const deploymentExtends = new MergedExtends();
+  const scanMetadataKeys = (obj) => {
+    if (obj?.metadata) {
+      keys(obj.metadata).forEach((key) => metadataKeys.add(key));
+    }
+  };
   const elements = pipe(
     docs,
     flatMap((d) => {
@@ -48,7 +57,8 @@ export function buildModelData(docs) {
           logger.debug`No parent found for ${el.id}`;
           return acc;
         }
-        acc[el.id] = elementExtends.apply(el);
+        acc[el.id] = elementExtends.applyExtended(el);
+        scanMetadataKeys(acc[el.id]);
         return acc;
       },
       {}
@@ -59,14 +69,16 @@ export function buildModelData(docs) {
     flatMap((d) => map(d.c4Relations, c4Specification.toModelRelation)),
     filter((rel) => {
       if (!rel) return false;
-      if (isNullish(elements[rel.source]) && !isGlobalFqn(rel.source) || isNullish(elements[rel.target]) && !isGlobalFqn(rel.target)) {
+      const source = c4.FqnRef.flatten(rel.source), target = c4.FqnRef.flatten(rel.target);
+      if (isNullish(elements[source]) && !isGlobalFqn(source) || isNullish(elements[target]) && !isGlobalFqn(target)) {
         logger.debug`Invalid relation ${rel.id}
-  source: ${rel.source} resolved: ${!!elements[rel.source]}
-  target: ${rel.target} resolved: ${!!elements[rel.target]}\n`;
+  source: ${source} resolved: ${!!elements[source]}
+  target: ${target} resolved: ${!!elements[target]}\n`;
         return false;
       }
       return true;
     }),
+    forEach(scanMetadataKeys),
     indexBy(prop("id"))
   );
   const deploymentElements = pipe(
@@ -86,7 +98,8 @@ export function buildModelData(docs) {
           logger.debug`No parent found for deployment element ${el.id}`;
           return acc;
         }
-        acc[el.id] = DeploymentElement.isDeploymentNode(el) ? deploymentExtends.apply(el) : el;
+        acc[el.id] = isDeploymentNode(el) ? deploymentExtends.applyExtended(el) : el;
+        scanMetadataKeys(acc[el.id]);
         return acc;
       },
       {}
@@ -97,10 +110,10 @@ export function buildModelData(docs) {
     flatMap((d) => map(d.c4DeploymentRelations, c4Specification.toDeploymentRelation)),
     filter((rel) => {
       if (!rel) return false;
-      if (isNullish(deploymentElements[rel.source.id]) || isNullish(deploymentElements[rel.target.id])) {
+      if (isNullish(deploymentElements[rel.source.deployment]) || isNullish(deploymentElements[rel.target.deployment])) {
         logger.debug`Invalid deployment relation ${rel.id}
-  source: ${rel.source.id} resolved: ${!!deploymentElements[rel.source.id]}
-  target: ${rel.target.id} resolved: ${!!deploymentElements[rel.target.id]}\n`;
+  source: ${rel.source.deployment} resolved: ${!!deploymentElements[rel.source.deployment]}
+  target: ${rel.target.deployment} resolved: ${!!deploymentElements[rel.target.deployment]}\n`;
         return false;
       }
       return true;
@@ -111,6 +124,7 @@ export function buildModelData(docs) {
           logger.debug`Duplicate deployment relation ${el.id}`;
           return acc;
         }
+        scanMetadataKeys(el);
         acc[el.id] = el;
         return acc;
       },
@@ -129,7 +143,7 @@ export function buildModelData(docs) {
         // model should include discriminant __
         ...model
       } = parsedAstView;
-      if (parsedAstView.__ === "element" && isNullish(title) && "viewOf" in parsedAstView) {
+      if (parsedAstView[c4._type] === "element" && isNullish(title) && "viewOf" in parsedAstView) {
         title = elements[parsedAstView.viewOf]?.title ?? null;
       }
       if (isNullish(title) && id === "index") {
@@ -137,7 +151,7 @@ export function buildModelData(docs) {
       }
       return {
         ...model,
-        customColorDefinitions,
+        [c4._stage]: "parsed",
         docUri,
         description,
         title,
@@ -153,13 +167,13 @@ export function buildModelData(docs) {
   );
   if (!parsedViews.some((v) => v.id === "index")) {
     parsedViews.unshift({
-      __: "element",
+      [c4._stage]: "parsed",
+      [c4._type]: "element",
       id: "index",
       title: "Landscape view",
       description: null,
       tags: null,
       links: null,
-      customColorDefinitions,
       rules: [
         {
           include: [
@@ -178,11 +192,19 @@ export function buildModelData(docs) {
   );
   return {
     data: {
+      [c4._stage]: "parsed",
+      projectId,
       specification: {
-        tags: Array.from(c4Specification.specs.tags),
+        tags: c4Specification.tags,
         elements: c4Specification.specs.elements,
-        relationships: c4Specification.specs.relationships,
-        deployments: c4Specification.specs.deployments
+        relationships: mapValues(c4Specification.specs.relationships, ({ notation, technology, ...style }) => ({
+          ...notation && { notation },
+          ...technology && { technology },
+          style
+        })),
+        deployments: c4Specification.specs.deployments,
+        ...metadataKeys.size > 0 && { metadataKeys: [...metadataKeys].sort(c4.compareNatural) },
+        customColors
       },
       elements,
       relations,

package/dist/model/deployments-index.js

@@ -1,4 +1,4 @@
-import { ancestorsFqn, AsFqn } from "@likec4/core";
+import { ancestorsFqn, Fqn } from "@likec4/core";
 import { MultiMap } from "@likec4/core/utils";
 import { isDefined, isTruthy } from "remeda";
 import {
@@ -46,7 +46,7 @@ export class DeploymentsIndex extends FqnIndex {
         if (!isTruthy(name)) {
           return [];
         }
-        thisFqn = AsFqn(name, parentFqn);
+        thisFqn = Fqn(name, parentFqn);
         const desc = createAndSaveDescription(node, name, thisFqn);
         if (!parentFqn) {
           root.push(desc);

package/dist/model/fqn-index.d.ts

@@ -1,4 +1,4 @@
-import { type Fqn, type ProjectId } from '@likec4/core/types';
+import { type ProjectId, Fqn } from '@likec4/core/types';
 import { DefaultWeakMap, MultiMap } from '@likec4/core/utils';
 import { type Stream, WorkspaceCache } from 'langium';
 import { type AstNodeDescriptionWithFqn, type LikeC4LangiumDocument, ast } from '../ast';

package/dist/model/fqn-index.js

@@ -1,5 +1,5 @@
 import { invariant, nonNullable } from "@likec4/core";
-import { AsFqn } from "@likec4/core/types";
+import { Fqn } from "@likec4/core/types";
 import { ancestorsFqn, compareNatural, DefaultWeakMap, MultiMap, sortNaturalByFqn } from "@likec4/core/utils";
 import {
   AstUtils,
@@ -89,7 +89,7 @@ export class FqnIndex extends ADisposable {
           });
           return map;
         }, new MultiMap());
-        return uniqueByName(allchildren).sort((a, b) => compareNatural(a.name, b.name));
+        return uniqueByName(allchildren);
       })
     );
   }
@@ -102,7 +102,7 @@ export class FqnIndex extends ADisposable {
           });
           return map;
         }, new MultiMap());
-        return uniqueByName(allchildren).sort((a, b) => compareNatural(a.name, b.name));
+        return uniqueByName(allchildren);
       })
     );
   }
@@ -125,7 +125,7 @@ export class FqnIndex extends ADisposable {
           children: new MultiMap(),
           descendants: new MultiMap()
         });
-        const uniqueChildren = uniqueByName(children).sort((a, b) => compareNatural(a.name, b.name));
+        const uniqueChildren = uniqueByName(children);
         const uniqueDescendants = [...descendants.associations()].flatMap(([_name, descs]) => descs.length === 1 && !children.has(_name) ? descs : []);
         return [
           ...uniqueChildren,
@@ -158,7 +158,7 @@ export class FqnIndex extends ADisposable {
     const traverseNode = (el, parentFqn) => {
       let thisFqn;
       if (ast.isElement(el)) {
-        thisFqn = AsFqn(el.name, parentFqn);
+        thisFqn = Fqn(el.name, parentFqn);
         const desc = createAndSaveDescription(el, el.name, thisFqn);
         if (!parentFqn) {
           root.push(desc);
@@ -211,7 +211,7 @@ export class FqnIndex extends ADisposable {
   }
 }
 function uniqueByName(multimap) {
-  return [...multimap.associations()].flatMap(([_name, descs]) => descs.length === 1 ? descs : []);
+  return [...multimap.associations()].flatMap(([_name, descs]) => descs.length === 1 ? descs : []).sort((a, b) => compareNatural(a.name, b.name));
 }
 export class DocumentFqnIndex {
   constructor(_rootElements, _children, _descendants, _byfqn, projectId) {

package/dist/model/model-builder.d.ts

@@ -1,12 +1,13 @@
-import type * as c4 from '@likec4/core';
-import { type ViewId, LikeC4Model } from '@likec4/core';
+import * as c4 from '@likec4/core';
+import { type ViewId } from '@likec4/core';
+import { LikeC4Model } from '@likec4/core/model';
 import { type URI, Disposable } from 'langium';
 import { CancellationToken } from 'vscode-jsonrpc';
 import type { LikeC4Services } from '../module';
 import { ADisposable } from '../utils';
 type ModelParsedListener = (docs: URI[]) => void;
 export interface LikeC4ModelBuilder {
-    parseModel(projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<c4.ParsedLikeC4ModelData | null>;
+    parseModel(projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model.Parsed | null>;
     unsafeSyncBuildModel(projectId: c4.ProjectId): LikeC4Model.Computed;
     buildLikeC4Model(projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model.Computed>;
     computeView(viewId: ViewId, projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<c4.ComputedView | null>;
@@ -24,10 +25,15 @@ export declare class DefaultLikeC4ModelBuilder extends ADisposable implements Li
      * 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.
+     *
+     * To avoid circular dependencies, we do not resolve imports here.
      */
     private unsafeSyncParseModelData;
+    /**
+     * To avoid circular dependencies, first we parse all documents and then we join them.
+     */
     private unsafeSyncJoinedModelData;
-    parseModel(projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<c4.ParsedLikeC4ModelData | null>;
+    parseModel(projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model.Parsed | null>;
     private previousViews;
     /**
      * WARNING:

package/dist/model/model-builder.js

@@ -1,7 +1,9 @@
+import * as c4 from "@likec4/core";
 import {
-  isScopedElementView,
-  LikeC4Model
+  isScopedElementView
 } from "@likec4/core";
+import { computeView } from "@likec4/core/compute-view";
+import { LikeC4Model } from "@likec4/core/model";
 import { loggable } from "@likec4/log";
 import { deepEqual as eq } from "fast-equals";
 import {
@@ -69,6 +71,8 @@ export class DefaultLikeC4ModelBuilder extends ADisposable {
    * 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.
+   *
+   * To avoid circular dependencies, we do not resolve imports here.
    */
   unsafeSyncParseModelData(projectId) {
     const cache = this.cache;
@@ -85,13 +89,16 @@ export class DefaultLikeC4ModelBuilder extends ADisposable {
           return null;
         }
         log.debug`unsafeSyncBuildModelData, project ${projectId}`;
-        return buildModelData(docs);
+        return buildModelData(projectId, docs);
       } catch (e) {
         logWarnError(e);
         return null;
       }
     });
   }
+  /**
+   * To avoid circular dependencies, first we parse all documents and then we join them.
+   */
   unsafeSyncJoinedModelData(projectId) {
     const cache = this.cache;
     const key = parsedModelCacheKey(projectId);
@@ -100,6 +107,7 @@ export class DefaultLikeC4ModelBuilder extends ADisposable {
       if (!result) {
         return null;
       }
+      let parsedData = result.data;
       if (result.imports.size > 0) {
         logger.debug`processing imports of ${projectId}`;
         const imports = [...result.imports.associations()].reduce((acc, [projectId2, fqns]) => {
@@ -115,12 +123,12 @@ export class DefaultLikeC4ModelBuilder extends ADisposable {
           }
           return acc;
         }, {});
-        return {
+        parsedData = {
           ...result.data,
           imports
         };
       }
-      return result.data;
+      return LikeC4Model.create(parsedData);
     });
   }
   async parseModel(projectId, cancelToken = CancellationToken.None) {
@@ -150,18 +158,13 @@ export class DefaultLikeC4ModelBuilder extends ADisposable {
     const cache = this.cache;
     const viewsCache = this.cache;
     return cache.get(computedModelCacheKey(projectId), () => {
-      const parsed = this.unsafeSyncJoinedModelData(projectId);
-      if (!parsed) {
+      const parsedModel = this.unsafeSyncJoinedModelData(projectId);
+      if (!parsedModel) {
         return LikeC4Model.EMPTY;
       }
-      const {
-        views: parsedViews,
-        ...model
-      } = parsed;
-      const computeView = LikeC4Model.makeCompute(parsed);
       const allViews = [];
-      for (const view of values(parsedViews)) {
-        const result = computeView(view);
+      for (const view of values(parsedModel.$data.views)) {
+        const result = computeView(view, parsedModel);
         if (!result.isSuccess) {
           logger.warn(loggable(result.error));
           continue;
@@ -178,7 +181,8 @@ export class DefaultLikeC4ModelBuilder extends ADisposable {
       });
       this.previousViews = { ...this.previousViews, ...views };
       return LikeC4Model.create({
-        ...model,
+        ...parsedModel.$data,
+        [c4._stage]: "computed",
         views
       });
     });
@@ -213,21 +217,20 @@ export class DefaultLikeC4ModelBuilder extends ADisposable {
       return null;
     }
     return cache.get(cacheKey, () => {
-      const view = parsed.views[viewId];
+      const view = parsed.$data.views[viewId];
       if (!view) {
         log.warn`computeView: cant find view ${viewId}`;
         return null;
       }
       log.debug`computeView: ${viewId}`;
-      const computeView = LikeC4Model.makeCompute(parsed);
-      const result = computeView(view);
+      const result = computeView(view, parsed);
       if (!result.isSuccess) {
         logWarnError(result.error);
         return null;
       }
       let computedView = result.view;
       const allElementViews = pipe(
-        parsed.views,
+        parsed.$data.views,
         values(),
         filter(isScopedElementView),
         filter((v) => v.id !== viewId),

package/dist/model/model-locator.d.ts

@@ -1,5 +1,7 @@
 import type * as c4 from '@likec4/core';
-import type { Location } from 'vscode-languageserver-types';
+import type { Cancellation } from 'langium';
+import type { Location, Range } from 'vscode-languageserver-types';
+import { URI } from 'vscode-uri';
 import type { ParsedAstElement, ParsedAstView, ParsedLikeC4LangiumDocument } from '../ast';
 import { ast } from '../ast';
 import type { LikeC4Services } from '../module';
@@ -14,7 +16,7 @@ export declare class LikeC4ModelLocator {
     private documents;
     getParsedElement(...args: [ast.Element] | [c4.Fqn] | [c4.Fqn, c4.ProjectId]): ParsedAstElement | null;
     locateElement(fqn: c4.Fqn, projectId?: c4.ProjectId | undefined): Location | null;
-    locateDeploymentElement(fqn: c4.Fqn, projectId?: c4.ProjectId | undefined): Location | null;
+    locateDeploymentElement(deploymentFqn: c4.DeploymentFqn, projectId?: c4.ProjectId | undefined): Location | null;
     locateRelation(relationId: c4.RelationId, projectId?: c4.ProjectId): Location | null;
     locateViewAst(viewId: c4.ViewId, projectId?: c4.ProjectId | undefined): null | {
         doc: ParsedLikeC4LangiumDocument;
@@ -22,4 +24,10 @@ export declare class LikeC4ModelLocator {
         viewAst: ast.LikeC4View;
     };
     locateView(viewId: c4.ViewId, projectId?: c4.ProjectId): Location | null;
+    locateDocumentTags(documentUri: URI, cancelToken?: Cancellation.CancellationToken): Promise<Array<{
+        name: string;
+        color: string;
+        range: Range;
+        isSpecification: boolean;
+    }>>;
 }

package/dist/model/model-locator.js

@@ -1,10 +1,14 @@
-import { splitGlobalFqn } from "@likec4/core";
-import { AstUtils, GrammarUtils } from "langium";
-import { isString } from "remeda";
-import { ast } from "../ast.js";
+import { ifilter, invariant, splitGlobalFqn, toArray } from "@likec4/core";
+import { loggable } from "@likec4/log";
+import { AstUtils, DocumentState, GrammarUtils } from "langium";
+import { flatMap, isString, pipe } from "remeda";
+import { ast, isLikeC4LangiumDocument } from "../ast.js";
+import { logger as serverLogger } from "../logger.js";
 import { projectIdFrom } from "../utils/index.js";
+import { MergedSpecification } from "./builder/MergedSpecification.js";
 const { findNodeForKeyword, findNodeForProperty } = GrammarUtils;
-const { getDocument } = AstUtils;
+const { getDocument, streamAllContents } = AstUtils;
+const logger = serverLogger.getChild("ModelLocator");
 export class LikeC4ModelLocator {
   constructor(services) {
     this.services = services;
@@ -63,10 +67,10 @@ export class LikeC4ModelLocator {
       range: docsegment.range
     };
   }
-  locateDeploymentElement(fqn, projectId) {
-    let [_projectId, _fqn] = splitGlobalFqn(fqn);
-    _projectId ??= this.projects.ensureProjectId(projectId);
-    const entry = this.deploymentsIndex.byFqn(_projectId, _fqn).head();
+  locateDeploymentElement(deploymentFqn, projectId) {
+    const _projectId = this.projects.ensureProjectId(projectId);
+    const fqn = deploymentFqn;
+    const entry = this.deploymentsIndex.byFqn(_projectId, fqn).head();
     const docsegment = entry?.nameSegment ?? entry?.selectionSegment;
     if (!entry || !docsegment) {
       return null;
@@ -92,6 +96,7 @@ export class LikeC4ModelLocator {
       }
       let targetNode = node.title ? findNodeForProperty(node.$cstNode, "title") : void 0;
       targetNode ??= node.kind ? findNodeForProperty(node.$cstNode, "kind") : void 0;
+      targetNode ??= findNodeForKeyword(node.$cstNode, "->");
       targetNode ??= findNodeForProperty(node.$cstNode, "target");
       targetNode ??= node.$cstNode;
       if (!targetNode) {
@@ -142,4 +147,55 @@ export class LikeC4ModelLocator {
       range: targetNode.range
     };
   }
+  async locateDocumentTags(documentUri, cancelToken) {
+    const doc = this.langiumDocuments.getDocument(documentUri);
+    if (!doc || !isLikeC4LangiumDocument(doc)) {
+      return [];
+    }
+    if (doc.state < DocumentState.Validated) {
+      logger.debug(`Waiting for document ${doc.uri.path} to be Validated`);
+      await this.services.shared.workspace.DocumentBuilder.waitUntil(DocumentState.Validated, doc.uri, cancelToken);
+    }
+    const projectId = projectIdFrom(doc);
+    logger.debug(`locate document tags for ${doc.uri.path} in project ${projectId}`);
+    try {
+      const tagSpecs = new MergedSpecification(this.documents(projectId).toArray()).tags;
+      logger.debug(`Assigned colors to tags`, { tagSpecs });
+      const tags = pipe(
+        streamAllContents(doc.parseResult.value),
+        ifilter((astNode) => ast.isTag(astNode) || ast.isTagRef(astNode)),
+        toArray(),
+        flatMap((tagRef) => {
+          let name;
+          let $cstNode;
+          try {
+            if (ast.isTag(tagRef)) {
+              name = tagRef.name;
+              $cstNode = tagRef.$cstNode;
+            } else {
+              name = tagRef.tag.$refText;
+              $cstNode = tagRef.tag.$refNode;
+            }
+            const specification = tagSpecs[name];
+            invariant(specification, `Tag ${name} not found in merged specification`);
+            invariant($cstNode, `Tag ${name} does not have a $cstNode`);
+            return {
+              name,
+              color: specification.color,
+              range: $cstNode.range,
+              isSpecification: ast.isTag(tagRef)
+            };
+          } catch (err) {
+            logger.warn(`Fail on tag ${name}`, { err });
+            return [];
+          }
+        })
+      );
+      logger.debug(`Found ${tags.length} tags in document ${doc.uri.path}`);
+      return tags;
+    } catch (e) {
+      logger.warn(loggable(e));
+      return [];
+    }
+  }
 }

package/dist/model/model-parser-where.d.ts

@@ -1,3 +1,3 @@
 import type * as c4 from '@likec4/core';
 import { ast } from '../ast';
-export declare function parseWhereClause(astNode: ast.WhereExpression): c4.WhereOperator<string, string>;
+export declare function parseWhereClause(astNode: ast.WhereExpression): c4.WhereOperator;

package/dist/model/model-parser-where.js

@@ -23,7 +23,7 @@ function parseParticipant(astNode) {
 export function parseWhereClause(astNode) {
   switch (true) {
     case ast.isWhereTagEqual(astNode): {
-      const tag = astNode.value?.ref?.name;
+      const tag = astNode.value.tag.ref?.name;
       const participant = parseParticipant(astNode);
       invariant(tag, "Expected tag name");
       const tagOperator = { tag: parseEquals(astNode, tag) };