@likec4/language-server 1.23.1 → 1.24.0

package/dist/model/builder/buildModel.js

@@ -0,0 +1,194 @@
+import {
+  computeColorValues,
+  DeploymentElement,
+  parentFqn,
+  sortByFqnHierarchically
+} from "@likec4/core";
+import { resolveRulesExtendedViews } from "@likec4/core/compute-view";
+import {
+  filter,
+  flatMap,
+  indexBy,
+  isDefined,
+  isNullish,
+  isTruthy,
+  map,
+  mapValues,
+  pipe,
+  prop,
+  reduce
+} from "remeda";
+import { logger } from "../../logger.js";
+import { resolveRelativePaths } from "../../view-utils/index.js";
+import { MergedExtends } from "./MergedExtends.js";
+import { MergedSpecification } from "./MergedSpecification.js";
+export function buildModel(docs) {
+  const c4Specification = new MergedSpecification(docs);
+  const customColorDefinitions = mapValues(
+    c4Specification.specs.colors,
+    (c) => computeColorValues(c.color)
+  );
+  const elementExtends = new MergedExtends();
+  const deploymentExtends = new MergedExtends();
+  const elements = pipe(
+    docs,
+    flatMap((d) => {
+      elementExtends.merge(d.c4ExtendElements);
+      return map(d.c4Elements, c4Specification.toModelElement);
+    }),
+    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])) {
+          logger.debug`No parent found for ${el.id}`;
+          return acc;
+        }
+        acc[el.id] = elementExtends.apply(el);
+        return acc;
+      },
+      {}
+    )
+  );
+  const relations = pipe(
+    docs,
+    flatMap((d) => map(d.c4Relations, c4Specification.toModelRelation)),
+    filter((rel) => {
+      if (!rel) return false;
+      if (isNullish(elements[rel.source]) || isNullish(elements[rel.target])) {
+        logger.debug`Invalid relation ${rel.id}
+  source: ${rel.source} resolved: ${!!elements[rel.source]}
+  target: ${rel.target} resolved: ${!!elements[rel.target]}\n`;
+        return false;
+      }
+      return true;
+    }),
+    indexBy(prop("id"))
+  );
+  const deploymentElements = pipe(
+    docs,
+    flatMap((d) => {
+      deploymentExtends.merge(d.c4ExtendDeployments);
+      return map(d.c4Deployments, c4Specification.toDeploymentElement);
+    }),
+    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])) {
+          logger.debug`No parent found for deployment element ${el.id}`;
+          return acc;
+        }
+        acc[el.id] = DeploymentElement.isDeploymentNode(el) ? deploymentExtends.apply(el) : el;
+        return acc;
+      },
+      {}
+    )
+  );
+  const deploymentRelations = pipe(
+    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])) {
+        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`;
+        return false;
+      }
+      return true;
+    }),
+    reduce(
+      (acc, el) => {
+        if (isDefined(acc[el.id])) {
+          logger.debug`Duplicate deployment relation ${el.id}`;
+          return acc;
+        }
+        acc[el.id] = el;
+        return acc;
+      },
+      {}
+    )
+  );
+  function toC4View(doc) {
+    const docUri = doc.uri.toString();
+    return (parsedAstView) => {
+      let {
+        id,
+        title,
+        description,
+        // ignore this property
+        astPath: _ignore,
+        // model should include discriminant __
+        ...model
+      } = parsedAstView;
+      if (parsedAstView.__ === "element" && isNullish(title) && "viewOf" in parsedAstView) {
+        title = elements[parsedAstView.viewOf]?.title ?? null;
+      }
+      if (isNullish(title) && id === "index") {
+        title = "Landscape view";
+      }
+      return {
+        ...model,
+        customColorDefinitions,
+        docUri,
+        description,
+        title,
+        id
+      };
+    };
+  }
+  const parsedViews = pipe(
+    docs,
+    flatMap((d) => map(d.c4Views, toC4View(d))),
+    // Resolve relative paths and sort by
+    resolveRelativePaths
+  );
+  if (!parsedViews.some((v) => v.id === "index")) {
+    parsedViews.unshift({
+      __: "element",
+      id: "index",
+      title: "Landscape view",
+      description: null,
+      tags: null,
+      links: null,
+      customColorDefinitions,
+      rules: [
+        {
+          include: [
+            {
+              wildcard: true
+            }
+          ]
+        }
+      ]
+    });
+  }
+  const views = pipe(
+    parsedViews,
+    indexBy(prop("id")),
+    resolveRulesExtendedViews
+  );
+  return {
+    specification: {
+      tags: Array.from(c4Specification.specs.tags),
+      elements: c4Specification.specs.elements,
+      relationships: c4Specification.specs.relationships,
+      deployments: c4Specification.specs.deployments
+    },
+    elements,
+    relations,
+    globals: c4Specification.globals,
+    views,
+    deployments: {
+      elements: deploymentElements,
+      relations: deploymentRelations
+    }
+  };
+}

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

@@ -1,61 +1,11 @@
-import type { Fqn } from '@likec4/core';
-import type { DocumentCache, LangiumDocuments, Stream } from 'langium';
-import { MultiMap } from 'langium';
-import { type DeploymentAstNodeDescription, type LikeC4LangiumDocument, ast } from '../ast';
+import { type LikeC4LangiumDocument } from '../ast';
 import type { LikeC4Services } from '../module';
 import type { LikeC4NameProvider } from '../references';
-export declare class DeploymentsIndex {
-    private services;
+import { DocumentFqnIndex, FqnIndex } from './fqn-index';
+export declare class DeploymentsIndex extends FqnIndex {
+    protected services: LikeC4Services;
     protected Names: LikeC4NameProvider;
-    protected langiumDocuments: LangiumDocuments;
-    protected documentCache: DocumentCache<string, DocumentDeploymentsIndex>;
+    protected cachePrefix: string;
     constructor(services: LikeC4Services);
-    private documents;
-    get(document: LikeC4LangiumDocument): DocumentDeploymentsIndex;
-    /**
-     * Nested elements (nodes/artifacts) of the node
-     * @param nodeName Name of the deployment node
-     * @returns Stream of artifacts
-     */
-    nested(node: ast.DeploymentNode): Stream<DeploymentAstNodeDescription>;
-    byFqn(fqnName: string): Stream<DeploymentAstNodeDescription>;
-    getFqn(node: ast.DeploymentElement): Fqn;
-    createDocumentIndex(document: LikeC4LangiumDocument): DocumentDeploymentsIndex;
-}
-/**
- * Index of deployment elements in the document
- */
-export declare class DocumentDeploymentsIndex {
-    private _rootNodes;
-    /**
-     * Nested of a deployment node
-     */
-    private _nested;
-    /**
-     * All elements by FQN
-     */
-    private _byfqn;
-    static readonly EMPTY: DocumentDeploymentsIndex;
-    constructor(_rootNodes: Array<DeploymentAstNodeDescription>, 
-    /**
-     * Nested of a deployment node
-     */
-    _nested: MultiMap<string, DeploymentAstNodeDescription>, 
-    /**
-     * All elements by FQN
-     */
-    _byfqn: MultiMap<string, DeploymentAstNodeDescription>);
-    rootNodes(): readonly DeploymentAstNodeDescription[];
-    byFqn(fqnName: string): readonly DeploymentAstNodeDescription[];
-    /**
-     * Returns artifacts of a deployment node
-     * @param nodeName Name of the deployment node
-     * @returns Stream of artifacts
-     */
-    nested(nodeName: string): readonly DeploymentAstNodeDescription[];
-    /**
-     * Returns all deployment elements in the document,
-     * with unique combination "type and name"
-     */
-    unique(): readonly DeploymentAstNodeDescription[];
+    protected createDocumentIndex(document: LikeC4LangiumDocument): DocumentFqnIndex;
 }

package/dist/model/deployments-index.js

@@ -1,174 +1,96 @@
-import { AstUtils, DocumentState, MultiMap } from "langium";
-import { forEachObj, groupBy, isTruthy, pipe, prop } from "remeda";
+import { ancestorsFqn, AsFqn } from "@likec4/core";
+import { MultiMap } from "langium";
+import { isDefined, isTruthy } from "remeda";
 import {
   ast,
-  ElementOps,
-  isLikeC4LangiumDocument
+  ElementOps
 } from "../ast.js";
 import { logWarnError } from "../logger.js";
-export class DeploymentsIndex {
+import { readStrictFqn } from "../utils/elementRef.js";
+import { DocumentFqnIndex, FqnIndex } from "./fqn-index.js";
+export class DeploymentsIndex extends FqnIndex {
   constructor(services) {
+    super(services);
     this.services = services;
     this.Names = services.references.NameProvider;
-    this.langiumDocuments = services.shared.workspace.LangiumDocuments;
-    this.documentCache = services.DocumentCache;
   }
   Names;
-  langiumDocuments;
-  documentCache;
-  documents() {
-    return this.langiumDocuments.all.filter(
-      (d) => isLikeC4LangiumDocument(d) && d.state >= DocumentState.IndexedContent
-    );
-  }
-  get(document) {
-    if (document.state < DocumentState.IndexedContent) {
-      logWarnError(`Document ${document.uri.path} is not indexed`);
-    }
-    return this.documentCache.get(document.uri, "DeploymentsIndex", () => this.createDocumentIndex(document));
-  }
-  /**
-   * Nested elements (nodes/artifacts) of the node
-   * @param nodeName Name of the deployment node
-   * @returns Stream of artifacts
-   */
-  nested(node) {
-    const fqnName = this.getFqn(node);
-    return this.documents().flatMap((doc) => this.get(doc).nested(fqnName));
-  }
-  byFqn(fqnName) {
-    return this.documents().flatMap((doc) => this.get(doc).byFqn(fqnName));
-  }
-  getFqn(node) {
-    let id = ElementOps.readId(node);
-    if (isTruthy(id)) {
-      return id;
-    }
-    const fqn = [
-      this.Names.getNameStrict(node)
-    ];
-    let _node = node;
-    let parentNode;
-    while (parentNode = AstUtils.getContainerOfType(_node.$container, ast.isDeploymentNode)) {
-      fqn.push(this.Names.getNameStrict(parentNode));
-      _node = parentNode;
-    }
-    id = fqn.reduceRight((acc, cur) => `${acc}.${cur}`);
-    ElementOps.writeId(node, id);
-    return id;
-  }
+  cachePrefix = "deployments-index";
   createDocumentIndex(document) {
     const rootNodes = document.parseResult.value.deployments.flatMap((m) => m.elements);
     if (rootNodes.length === 0) {
-      return DocumentDeploymentsIndex.EMPTY;
+      return DocumentFqnIndex.EMPTY;
     }
-    const _root = new Array();
-    const _nested = new MultiMap();
-    const _byfqn = new MultiMap();
+    const root = new Array();
+    const children = new MultiMap();
+    const descendants = new MultiMap();
+    const byfqn = new MultiMap();
     const Names = this.Names;
     const Descriptions = this.services.workspace.AstNodeDescriptionProvider;
-    const createAndSaveDescription = (props) => {
+    const createAndSaveDescription = (node, name, fqn) => {
       const desc = {
-        ...Descriptions.createDescription(props.node, props.name, document),
-        fqn: props.fqn
+        ...Descriptions.createDescription(node, name, document),
+        id: fqn
       };
-      ElementOps.writeId(props.node, props.fqn);
-      _byfqn.add(props.fqn, desc);
+      ElementOps.writeId(node, fqn);
+      byfqn.add(fqn, desc);
       return desc;
     };
-    const traverseNode = (container, parentFqn) => {
-      const _descedants = [];
-      const children = container.body?.elements;
-      if (!children || children.length === 0) {
-        return [];
-      }
-      const directChildren = /* @__PURE__ */ new Set();
-      for (const node of children) {
-        if (ast.isDeploymentRelation(node)) {
-          continue;
+    const traverseNode = (node, parentFqn) => {
+      let thisFqn;
+      if (ast.isExtendDeployment(node)) {
+        thisFqn = readStrictFqn(node.deploymentNode);
+      } else {
+        const name = Names.getName(node);
+        if (!isTruthy(name)) {
+          return [];
+        }
+        thisFqn = AsFqn(name, parentFqn);
+        const desc = createAndSaveDescription(node, name, thisFqn);
+        if (!parentFqn) {
+          root.push(desc);
+        } else {
+          children.add(parentFqn, desc);
         }
-        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));
+        if (ast.isDeployedInstance(node)) {
+          return [];
+        }
+      }
+      let _nested = [];
+      if (isDefined(node.body)) {
+        for (const child of node.body.elements) {
+          if (!ast.isDeploymentRelation(child)) {
+            try {
+              _nested.push(...traverseNode(child, thisFqn));
+            } catch (e) {
+              logWarnError(e);
             }
           }
-        } 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]);
-          })
-        );
+      const directChildren = children.get(thisFqn);
+      _nested = [
+        ...directChildren,
+        ..._nested
+      ];
+      descendants.addAll(thisFqn, _nested);
+      if (ast.isExtendDeployment(node)) {
+        ancestorsFqn(thisFqn).forEach((ancestor) => {
+          descendants.addAll(ancestor, _nested);
+        });
       }
-      return _nested.get(parentFqn);
+      return descendants.get(thisFqn);
     };
     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);
-        }
+        traverseNode(node, null);
       } catch (e) {
         logWarnError(e);
       }
     }
-    return new DocumentDeploymentsIndex(_root, _nested, _byfqn);
-  }
-}
-export class DocumentDeploymentsIndex {
-  constructor(_rootNodes, _nested, _byfqn) {
-    this._rootNodes = _rootNodes;
-    this._nested = _nested;
-    this._byfqn = _byfqn;
-  }
-  static EMPTY = new DocumentDeploymentsIndex([], new MultiMap(), new MultiMap());
-  rootNodes() {
-    return this._rootNodes;
-  }
-  byFqn(fqnName) {
-    return this._byfqn.get(fqnName);
-  }
-  /**
-   * Returns artifacts of a deployment node
-   * @param nodeName Name of the deployment node
-   * @returns Stream of artifacts
-   */
-  nested(nodeName) {
-    return this._nested.get(nodeName);
-  }
-  /**
-   * Returns all deployment elements in the document,
-   * with unique combination "type and name"
-   */
-  unique() {
-    const result = [];
-    pipe(
-      [...this._byfqn.values()],
-      groupBy(prop("name")),
-      forEachObj((descs) => {
-        if (descs.length === 1) {
-          result.push(descs[0]);
-        }
-      })
-    );
-    return result;
+    return new DocumentFqnIndex(root, children, descendants, byfqn);
   }
 }

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

@@ -1,26 +1,56 @@
-import type { Fqn } from '@likec4/core';
-import type { AstNodeDescription, LangiumDocuments, Stream } from 'langium';
-import type { ast, FqnIndexedDocument } from '../ast';
+import { type Fqn } from '@likec4/core/types';
+import { DefaultWeakMap } from '@likec4/core/utils';
+import { type LangiumDocuments, type Stream, MultiMap } from 'langium';
+import { type AstNodeDescriptionWithFqn, type LikeC4LangiumDocument, ast } from '../ast';
 import type { LikeC4Services } from '../module';
 import { ADisposable } from '../utils';
-export interface FqnIndexEntry {
-    fqn: Fqn;
-    name: string;
-    el: ast.Element;
-    doc: FqnIndexedDocument;
-    path: string;
-}
 export declare class FqnIndex extends ADisposable {
-    private services;
+    protected services: LikeC4Services;
     protected langiumDocuments: LangiumDocuments;
+    protected documentCache: DefaultWeakMap<LikeC4LangiumDocument, DocumentFqnIndex>;
+    protected cachePrefix: string;
     constructor(services: LikeC4Services);
-    get documents(): any;
-    private entries;
-    getFqn(el: ast.Element): Fqn | null;
-    byFqn(fqn: Fqn): Stream<AstNodeDescription>;
-    directChildrenOf(parent: Fqn): Stream<AstNodeDescription>;
+    private documents;
+    get(document: LikeC4LangiumDocument): DocumentFqnIndex;
+    getFqn(el: ast.Element | ast.DeploymentElement): Fqn;
+    byFqn(fqn: Fqn): Stream<AstNodeDescriptionWithFqn>;
+    directChildrenOf(parent: Fqn): Stream<AstNodeDescriptionWithFqn>;
     /**
      * Returns descedant elements with unique names in the scope
      */
-    uniqueDescedants(parent: Fqn): Stream<AstNodeDescription>;
+    uniqueDescedants(parent: Fqn): Stream<AstNodeDescriptionWithFqn>;
+    protected createDocumentIndex(document: LikeC4LangiumDocument): DocumentFqnIndex;
+}
+export declare class DocumentFqnIndex {
+    private _rootElements;
+    /**
+     * direct children of elements
+     */
+    private _children;
+    /**
+     * All descendants of an element (unique by name)
+     */
+    private _descendants;
+    /**
+     * All elements by FQN
+     */
+    private _byfqn;
+    static readonly EMPTY: DocumentFqnIndex;
+    constructor(_rootElements: Array<AstNodeDescriptionWithFqn>, 
+    /**
+     * direct children of elements
+     */
+    _children: MultiMap<Fqn, AstNodeDescriptionWithFqn>, 
+    /**
+     * All descendants of an element (unique by name)
+     */
+    _descendants: MultiMap<Fqn, AstNodeDescriptionWithFqn>, 
+    /**
+     * All elements by FQN
+     */
+    _byfqn: MultiMap<Fqn, AstNodeDescriptionWithFqn>);
+    rootElements(): readonly AstNodeDescriptionWithFqn[];
+    byFqn(fqn: Fqn): readonly AstNodeDescriptionWithFqn[];
+    children(parent: Fqn): readonly AstNodeDescriptionWithFqn[];
+    descendants(nodeName: Fqn): readonly AstNodeDescriptionWithFqn[];
 }