@likec4/language-server 0.37.1 → 0.41.0

package/dist/model/model-builder.js

@@ -1,196 +1,267 @@
-import { ModelIndex, compareByFqnHierarchically, parentFqn, resolveRulesExtendedViews, computeView, assignNavigateTo, isStrictElementView } from '@likec4/core';
-import * as R from 'remeda';
-import { isValidLikeC4LangiumDocument } from '../ast';
-import { logError, logWarnError, logger } from '../logger';
-import { Rpc } from '../protocol';
-import { printDocs } from '../utils';
+import {
+  compareByFqnHierarchically,
+  invariant,
+  isStrictElementView,
+  parentFqn
+} from "@likec4/core";
+import {
+  DocumentState,
+  interruptAndCheck
+} from "langium";
+import * as R from "remeda";
+import { Disposable } from "vscode-languageserver";
+import { isValidLikeC4LangiumDocument } from "../ast.js";
+import { logError, logWarnError, logger } from "../logger.js";
+import { LikeC4WorkspaceManager } from "../shared/index.js";
+import { printDocs, queueMicrotask } from "../utils.js";
+import { assignNavigateTo, resolveRelativePaths, resolveRulesExtendedViews } from "../view-utils/index.js";
+import { LikeC4ModelGraph, computeView } from "@likec4/graph";
+function isRelativeLink(link) {
+  return link.startsWith(".") || link.startsWith("/");
+}
 function buildModel(docs) {
-    const c4Specification = {
-        kinds: {}
-    };
-    R.forEach(R.map(docs, R.prop('c4Specification')), spec => Object.assign(c4Specification.kinds, spec.kinds));
-    const toModelElement = (doc) => {
-        const base = new URL(doc.uri.toString());
-        const resolveLinks = (links) => links.map((l) => new URL(l, base).toString());
-        return ({ astPath, tags, links, ...parsed }) => {
-            try {
-                const kind = c4Specification.kinds[parsed.kind];
-                if (kind) {
-                    return {
-                        ...kind,
-                        description: null,
-                        technology: null,
-                        tags: tags ?? null,
-                        links: links ? resolveLinks(links) : null,
-                        ...parsed
-                    };
-                }
-            }
-            catch (e) {
-                logWarnError(e);
-            }
-            return null;
-        };
+  const c4Specification = {
+    kinds: {},
+    relationships: {}
+  };
+  R.forEach(R.map(docs, R.prop("c4Specification")), (spec) => {
+    Object.assign(c4Specification.kinds, spec.kinds), Object.assign(c4Specification.relationships, spec.relationships);
+  });
+  const resolveLinks = (doc, links) => {
+    const base = new URL(doc.uri.toString());
+    return links.map(
+      (l) => isRelativeLink(l) ? new URL(l, base).toString() : l
+    );
+  };
+  const toModelElement = (doc) => {
+    return ({ astPath, tags, links, ...parsed }) => {
+      try {
+        const kind = c4Specification.kinds[parsed.kind];
+        if (kind) {
+          return {
+            ...kind,
+            description: null,
+            technology: null,
+            tags: tags ?? null,
+            links: links ? resolveLinks(doc, links) : null,
+            ...parsed
+          };
+        }
+      } catch (e) {
+        logWarnError(e);
+      }
+      return null;
     };
-    const elements = R.pipe(R.flatMap(docs, d => d.c4Elements.map(toModelElement(d))), R.compact, R.sort(compareByFqnHierarchically), R.reduce((acc, el) => {
+  };
+  const elements = R.pipe(
+    R.flatMap(docs, (d) => d.c4Elements.map(toModelElement(d))),
+    R.compact,
+    R.sort(compareByFqnHierarchically),
+    R.reduce(
+      (acc, el) => {
         const parent = parentFqn(el.id);
         if (parent && R.isNil(acc[parent])) {
-            logWarnError(`No parent found for ${el.id}`);
-            return acc;
+          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;
+          logWarnError(`Duplicate element id: ${el.id}`);
+          return acc;
         }
         acc[el.id] = el;
         return acc;
-    }, {}));
-    const toModelRelation = ({ astPath, source, target, ...model }) => {
-        if (source in elements && target in elements) {
-            return {
-                source,
-                target,
-                ...model
-            };
-        }
-        return null;
-    };
-    const relations = R.pipe(R.flatMap(docs, d => d.c4Relations), R.map(toModelRelation), R.compact, R.mapToObj(r => [r.id, r]));
-    const toElementView = (view) => {
-        // eslint-disable-next-line prefer-const
-        let { astPath, rules, title, description, tags, links, ...model } = view;
-        if (!title && 'viewOf' in view) {
-            title = elements[view.viewOf]?.title;
-        }
-        if (!title && view.id === 'index') {
-            title = 'Landscape view';
-        }
+      },
+      {}
+    )
+  );
+  const toModelRelation = ({
+    astPath,
+    source,
+    target,
+    ...model
+  }) => {
+    if (source in elements && target in elements) {
+      if (model.kind) {
+        const kind = c4Specification.relationships[model.kind];
         return {
-            ...model,
-            title: title ?? null,
-            description: description ?? null,
-            tags: tags ?? null,
-            links: links ?? null,
-            rules
-        };
-    };
-    const views = R.pipe(R.flatMap(docs, d => d.c4Views), R.map(toElementView), R.compact, R.mapToObj(v => [v.id, v]));
-    // add index view if not present
-    if (!('index' in views)) {
-        views['index'] = {
-            id: 'index',
-            title: 'Landscape',
-            description: null,
-            tags: null,
-            links: null,
-            rules: [
-                {
-                    isInclude: true,
-                    exprs: [
-                        {
-                            wildcard: true
-                        }
-                    ]
-                }
-            ]
+          source,
+          target,
+          ...kind,
+          ...model
         };
+      }
+      return {
+        source,
+        target,
+        ...model
+      };
     }
-    return {
-        elements,
-        relations,
-        views: resolveRulesExtendedViews(views)
+    return null;
+  };
+  const relations = R.pipe(
+    R.flatMap(docs, (d) => d.c4Relations),
+    R.map(toModelRelation),
+    R.compact,
+    R.mapToObj((r) => [r.id, r])
+  );
+  const toElementView = (doc) => {
+    const docUri = doc.uri.toString();
+    return (view) => {
+      let { astPath, rules, title, description, tags, links, ...model } = view;
+      if (!title && "viewOf" in view) {
+        title = elements[view.viewOf]?.title;
+      }
+      if (!title && view.id === "index") {
+        title = "Landscape view";
+      }
+      return {
+        ...model,
+        title: title ?? null,
+        description: description ?? null,
+        tags: tags ?? null,
+        links: links ? resolveLinks(doc, links) : null,
+        docUri,
+        rules
+      };
     };
-}
-export class LikeC4ModelBuilder {
-    services;
-    langiumDocuments;
-    cachedModel = {};
-    constructor(services) {
-        this.services = services;
-        this.langiumDocuments = services.shared.workspace.LangiumDocuments;
-        services.likec4.ModelParser.onParsed(() => {
-            this.cleanCache();
-            this.notifyClient();
-        });
-    }
-    cleanCache() {
-        delete this.cachedModel.last;
-    }
-    documents() {
-        return this.langiumDocuments.all.filter(isValidLikeC4LangiumDocument).toArray();
-    }
-    buildRawModel() {
-        if ('last' in this.cachedModel) {
-            logger.debug('[ModelBuilder] returning cached model');
-            return this.cachedModel.last;
-        }
-        try {
-            const docs = this.documents();
-            if (docs.length === 0) {
-                logger.debug('[ModelBuilder] No documents to build model from');
-                return null;
+  };
+  const views = R.pipe(
+    R.flatMap(docs, (d) => R.map(d.c4Views, toElementView(d))),
+    resolveRelativePaths,
+    R.mapToObj((v) => [v.id, v]),
+    resolveRulesExtendedViews
+  );
+  if (!("index" in views)) {
+    views["index"] = {
+      id: "index",
+      title: "Landscape",
+      description: null,
+      tags: null,
+      links: null,
+      rules: [
+        {
+          include: [
+            {
+              wildcard: true
             }
-            logger.debug(`[ModelBuilder] buildModel from ${docs.length} docs:\n${printDocs(docs)}`);
-            return (this.cachedModel.last = buildModel(docs));
-        }
-        catch (e) {
-            logError(e);
-            return null;
+          ]
         }
-    }
-    buildModel() {
-        const model = this.buildRawModel();
-        if (!model) {
-            return null;
+      ]
+    };
+  }
+  return {
+    elements,
+    relations,
+    views
+  };
+}
+const RAW_MODEL_CACHE = "LikeC4RawModel";
+const MODEL_CACHE = "LikeC4Model";
+export class LikeC4ModelBuilder {
+  constructor(services) {
+    this.services = services;
+    this.langiumDocuments = services.shared.workspace.LangiumDocuments;
+    invariant(services.shared.workspace.WorkspaceManager instanceof LikeC4WorkspaceManager);
+    this.workspaceManager = services.shared.workspace.WorkspaceManager;
+    const parser = services.likec4.ModelParser;
+    services.shared.workspace.DocumentBuilder.onBuildPhase(
+      DocumentState.Validated,
+      async (docs, cancelToken) => {
+        await queueMicrotask(() => parser.parse(docs));
+        await interruptAndCheck(cancelToken);
+        this.notifyListeners(docs.map((d) => d.uri));
+      }
+    );
+  }
+  langiumDocuments;
+  workspaceManager;
+  listeners = [];
+  get workspaceUri() {
+    return this.workspaceManager.workspace()?.uri ?? null;
+  }
+  buildRawModel() {
+    const cache = this.services.WorkspaceCache;
+    return cache.get(RAW_MODEL_CACHE, () => {
+      try {
+        const docs = this.documents();
+        if (docs.length === 0) {
+          logger.debug("[ModelBuilder] No documents to build model from");
+          return null;
         }
-        const index = ModelIndex.from(model);
-        const views = R.pipe(R.values(model.views), R.map(view => computeView(view, index).view), R.compact);
-        assignNavigateTo(views);
-        return {
-            elements: model.elements,
-            relations: model.relations,
-            views: R.mapToObj(views, v => [v.id, v])
-        };
+        logger.debug(`[ModelBuilder] buildModel from ${docs.length} docs:
+${printDocs(docs)}`);
+        return buildModel(docs);
+      } catch (e) {
+        logError(e);
+        return null;
+      }
+    });
+  }
+  buildModel() {
+    const cache = this.services.WorkspaceCache;
+    return cache.get(MODEL_CACHE, () => {
+      const model = this.buildRawModel();
+      if (!model) {
+        return null;
+      }
+      const index = new LikeC4ModelGraph(model);
+      const views = R.pipe(
+        R.values(model.views),
+        R.map((view) => computeView(view, index).view),
+        R.compact
+      );
+      assignNavigateTo(views);
+      return {
+        elements: model.elements,
+        relations: model.relations,
+        views: R.mapToObj(views, (v) => [v.id, v])
+      };
+    });
+  }
+  computeView(viewId) {
+    const model = this.buildRawModel();
+    const view = model?.views[viewId];
+    if (!view) {
+      logger.warn(`[ModelBuilder] Cannot find view ${viewId}`);
+      return null;
     }
-    computeView(viewId) {
-        const model = this.buildRawModel();
-        const view = model?.views[viewId];
-        if (!view) {
-            logger.warn(`[ModelBuilder] Cannot find view ${viewId}`);
-            return null;
-        }
-        const result = computeView(view, ModelIndex.from(model));
-        if (!result.isSuccess) {
-            logError(result.error);
-            return null;
-        }
-        const allElementViews = R.values(model.views).filter((v) => isStrictElementView(v) && v.id !== viewId);
-        const computedView = result.view;
-        computedView.nodes.forEach(node => {
-            // find first element view that is not the current one
-            const navigateTo = R.find(allElementViews, v => v.viewOf === node.id);
-            if (navigateTo) {
-                node.navigateTo = navigateTo.id;
-            }
-        });
-        return computedView;
+    const index = new LikeC4ModelGraph(model);
+    const result = computeView(view, index);
+    if (!result.isSuccess) {
+      logError(result.error);
+      return null;
     }
-    scheduledCb = null;
-    notifyClient() {
-        const connection = this.services.shared.lsp.Connection;
-        if (!connection) {
-            return;
-        }
-        if (this.scheduledCb) {
-            logger.debug('[ModelBuilder] debounce onDidChangeModel');
-            clearTimeout(this.scheduledCb);
-        }
-        this.scheduledCb = setTimeout(() => {
-            this.scheduledCb = null;
-            logger.debug('[ModelBuilder] send onDidChangeModel');
-            void connection.sendNotification(Rpc.onDidChangeModel, '');
-        }, 200);
+    const allElementViews = R.values(model.views).filter(
+      (v) => isStrictElementView(v) && v.id !== viewId
+    );
+    const computedView = result.view;
+    computedView.nodes.forEach((node) => {
+      const navigateTo = R.find(allElementViews, (v) => v.viewOf === node.id);
+      if (navigateTo) {
+        node.navigateTo = navigateTo.id;
+      }
+    });
+    return computedView;
+  }
+  onModelParsed(callback) {
+    this.listeners.push(callback);
+    return Disposable.create(() => {
+      const index = this.listeners.indexOf(callback);
+      if (index >= 0) {
+        this.listeners.splice(index, 1);
+      }
+    });
+  }
+  documents() {
+    return this.langiumDocuments.all.filter(isValidLikeC4LangiumDocument).toArray();
+  }
+  notifyListeners(docs) {
+    for (const listener of this.listeners) {
+      try {
+        listener(docs);
+      } catch (e) {
+        logError(e);
+      }
     }
+  }
 }
-//# sourceMappingURL=model-builder.js.map

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

@@ -1,4 +1,4 @@
-import type * as c4 from '@likec4/core/types';
+import type { likec4 as c4 } from '@likec4/core';
 import type { Location } from 'vscode-languageserver-protocol';
 import type { ParsedAstElement } from '../ast';
 import { ast } from '../ast';

package/dist/model/model-locator.js

@@ -1,111 +1,113 @@
-import { InvalidModelError } from '@likec4/core';
-import { findNodeForProperty, getDocument } from 'langium';
-import { ast, isParsedLikeC4LangiumDocument } from '../ast';
-import {} from './fqn-index';
+import { InvalidModelError } from "@likec4/core";
+import { findNodeForProperty, getDocument } from "langium";
+import { ast, isParsedLikeC4LangiumDocument } from "../ast.js";
 export class LikeC4ModelLocator {
-    services;
-    fqnIndex;
-    langiumDocuments;
-    constructor(services) {
-        this.services = services;
-        this.fqnIndex = services.likec4.FqnIndex;
-        this.langiumDocuments = services.shared.workspace.LangiumDocuments;
+  constructor(services) {
+    this.services = services;
+    this.fqnIndex = services.likec4.FqnIndex;
+    this.langiumDocuments = services.shared.workspace.LangiumDocuments;
+  }
+  fqnIndex;
+  langiumDocuments;
+  documents() {
+    return this.langiumDocuments.all.filter(isParsedLikeC4LangiumDocument);
+  }
+  getParsedElement(astNode) {
+    const fqn = this.fqnIndex.getFqn(astNode);
+    if (!fqn)
+      return null;
+    const doc = getDocument(astNode);
+    if (!isParsedLikeC4LangiumDocument(doc)) {
+      return null;
     }
-    documents() {
-        return this.langiumDocuments.all.filter(isParsedLikeC4LangiumDocument);
+    return doc.c4Elements.find((e) => e.id === fqn) ?? null;
+  }
+  locateElement(fqn, property = "name") {
+    const entry = this.fqnIndex.byFqn(fqn).head();
+    if (!entry) {
+      return null;
     }
-    getParsedElement(astNode) {
-        const fqn = this.fqnIndex.getFqn(astNode);
-        if (!fqn)
-            return null;
-        const doc = getDocument(astNode);
-        if (!isParsedLikeC4LangiumDocument(doc)) {
-            return null;
-        }
-        return doc.c4Elements.find(e => e.id === fqn) ?? null;
-    }
-    locateElement(fqn, property = 'name') {
-        const entry = this.fqnIndex.byFqn(fqn).head();
-        if (!entry) {
-            return null;
-        }
-        const propertyNode = findNodeForProperty(entry.el.$cstNode, property) ?? entry.el.$cstNode;
-        if (!propertyNode) {
-            return null;
-        }
-        return {
-            uri: entry.doc.uri.toString(),
-            range: propertyNode.range
-        };
+    const propertyNode = findNodeForProperty(entry.el.$cstNode, property) ?? entry.el.$cstNode;
+    if (!propertyNode) {
+      return null;
     }
-    locateRelation(relationId) {
-        for (const doc of this.documents()) {
-            const relation = doc.c4Relations.find(r => r.id === relationId);
-            if (!relation) {
-                continue;
-            }
-            const node = this.services.workspace.AstNodeLocator.getAstNode(doc.parseResult.value, relation.astPath);
-            if (!ast.isRelation(node)) {
-                continue;
-            }
-            if (node.title) {
-                const targetNode = findNodeForProperty(node.$cstNode, 'title');
-                if (targetNode) {
-                    return {
-                        uri: doc.uri.toString(),
-                        range: {
-                            start: targetNode.range.start,
-                            end: targetNode.range.start
-                        }
-                    };
-                }
-            }
-            if (node.arr == null) {
-                throw new InvalidModelError('Relation.arr is not defined, but should be');
-            }
-            const targetNode = findNodeForProperty(node.$cstNode, 'arr');
-            if (!targetNode) {
-                return null;
+    return {
+      uri: entry.doc.uri.toString(),
+      range: propertyNode.range
+    };
+  }
+  locateRelation(relationId) {
+    for (const doc of this.documents()) {
+      const relation = doc.c4Relations.find((r) => r.id === relationId);
+      if (!relation) {
+        continue;
+      }
+      const node = this.services.workspace.AstNodeLocator.getAstNode(
+        doc.parseResult.value,
+        relation.astPath
+      );
+      if (!ast.isRelation(node)) {
+        continue;
+      }
+      if (node.title) {
+        const targetNode2 = findNodeForProperty(node.$cstNode, "title");
+        if (targetNode2) {
+          return {
+            uri: doc.uri.toString(),
+            range: {
+              start: targetNode2.range.start,
+              end: targetNode2.range.start
             }
-            return {
-                uri: doc.uri.toString(),
-                range: {
-                    start: targetNode.range.start,
-                    end: targetNode.range.end
-                }
-            };
+          };
         }
+      }
+      if (node.arr == null) {
+        throw new InvalidModelError("Relation.arr is not defined, but should be");
+      }
+      const targetNode = findNodeForProperty(node.$cstNode, "arr");
+      if (!targetNode) {
         return null;
-    }
-    locateView(viewId) {
-        for (const doc of this.documents()) {
-            const view = doc.c4Views.find(r => r.id === viewId);
-            if (!view) {
-                continue;
-            }
-            const node = this.services.workspace.AstNodeLocator.getAstNode(doc.parseResult.value, view.astPath);
-            if (!ast.isElementView(node)) {
-                continue;
-            }
-            let targetNode = node.$cstNode;
-            if (node.name) {
-                targetNode = findNodeForProperty(node.$cstNode, 'name') ?? targetNode;
-            }
-            else if ('viewOf' in node) {
-                targetNode = findNodeForProperty(node.$cstNode, 'viewOf') ?? targetNode;
-            }
-            if (!targetNode) {
-                return null;
-            }
-            return {
-                uri: doc.uri.toString(),
-                range: {
-                    start: targetNode.range.start,
-                    end: targetNode.range.start
-                }
-            };
+      }
+      return {
+        uri: doc.uri.toString(),
+        range: {
+          start: targetNode.range.start,
+          end: targetNode.range.end
         }
+      };
+    }
+    return null;
+  }
+  locateView(viewId) {
+    for (const doc of this.documents()) {
+      const view = doc.c4Views.find((r) => r.id === viewId);
+      if (!view) {
+        continue;
+      }
+      const node = this.services.workspace.AstNodeLocator.getAstNode(
+        doc.parseResult.value,
+        view.astPath
+      );
+      if (!ast.isElementView(node)) {
+        continue;
+      }
+      let targetNode = node.$cstNode;
+      if (node.name) {
+        targetNode = findNodeForProperty(node.$cstNode, "name") ?? targetNode;
+      } else if ("viewOf" in node) {
+        targetNode = findNodeForProperty(node.$cstNode, "viewOf") ?? targetNode;
+      }
+      if (!targetNode) {
         return null;
+      }
+      return {
+        uri: doc.uri.toString(),
+        range: {
+          start: targetNode.range.start,
+          end: targetNode.range.start
+        }
+      };
     }
+    return null;
+  }
 }
-//# sourceMappingURL=model-locator.js.map