@likec4/language-server 1.25.0 → 1.26.0

package/bin/likec4-language-server.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { startLanguageServer } from '.../dist/bundled.mjs'
+import { startLanguageServer } from '../dist/bundled.mjs'
 
 startLanguageServer().catch((e) => {
   console.error(e)

package/dist/LikeC4FileSystem.js

@@ -4,10 +4,15 @@ import { NodeFileSystemProvider } from "langium/node";
 import { LikeC4LanguageMetaData } from "./generated/module.js";
 import { Content, isLikeC4Builtin } from "./likec4lib.js";
 import { logError } from "./logger.js";
+import { ProjectsManager } from "./workspace/ProjectsManager.js";
 export const LikeC4FileSystem = {
   fileSystemProvider: () => new SymLinkTraversingFileSystemProvider()
 };
-const hasExtension = (path) => LikeC4LanguageMetaData.fileExtensions.some((ext) => path.endsWith(ext));
+const SearchExtension = [
+  ...LikeC4LanguageMetaData.fileExtensions,
+  ...ProjectsManager.ConfigFileNames
+];
+const hasExtension = (path) => SearchExtension.some((ext) => path.endsWith(ext));
 class SymLinkTraversingFileSystemProvider extends NodeFileSystemProvider {
   async readFile(uri) {
     if (isLikeC4Builtin(uri)) {

package/dist/LikeC4LanguageServices.d.ts

@@ -0,0 +1,77 @@
+import { type DiagramView, type NonEmptyArray, type ProjectId, LikeC4Model } from '@likec4/core';
+import { URI } from 'langium';
+import { type Range } from 'vscode-languageserver-types';
+import type { ProjectConfig } from './config';
+import type { LikeC4ModelBuilder } from './model';
+import type { LikeC4Services } from './module';
+import type { LikeC4Views } from './views/likec4-views';
+export interface LikeC4LanguageServices {
+    readonly views: LikeC4Views;
+    readonly builder: LikeC4ModelBuilder;
+    readonly workspaceUri: URI;
+    projects(): NonEmptyArray<{
+        id: ProjectId;
+        folder: URI;
+        config: ProjectConfig;
+        documents: NonEmptyArray<URI> | null;
+    }>;
+    diagrams(): Promise<DiagramView[]>;
+    computedModel(project?: ProjectId | undefined): Promise<LikeC4Model.Computed>;
+    layoutedModel(project?: ProjectId | undefined): Promise<LikeC4Model.Layouted>;
+    getErrors(): Array<{
+        message: string;
+        line: number;
+        range: Range;
+        sourceFsPath: string;
+    }>;
+    notifyUpdate(update: {
+        changed?: string;
+        removed?: string;
+    }): Promise<boolean>;
+}
+/**
+ * Public Language Services
+ */
+export declare class DefaultLikeC4LanguageServices implements LikeC4LanguageServices {
+    private services;
+    readonly views: LikeC4Views;
+    readonly builder: LikeC4ModelBuilder;
+    private projectsManager;
+    constructor(services: LikeC4Services);
+    get workspaceUri(): URI;
+    projects(): NonEmptyArray<{
+        id: ProjectId;
+        folder: URI;
+        config: ProjectConfig;
+        documents: NonEmptyArray<URI> | null;
+    }>;
+    /**
+     * Diagram is a computed view, layouted using Graphviz
+     * Used in React components
+     */
+    diagrams(): Promise<DiagramView[]>;
+    /**
+     * Builds LikeC4Model from all documents
+     * Only computes view predicates {@link ComputedView} - i.e. no layout
+     * Not ready for rendering, but enough to traverse
+     */
+    computedModel(project?: ProjectId | undefined): Promise<LikeC4Model.Computed>;
+    /**
+     * Same as {@link computedModel()}, but also applies layout
+     * Ready for rendering
+     */
+    layoutedModel(project?: ProjectId | undefined): Promise<LikeC4Model.Layouted>;
+    getErrors(): Array<{
+        message: string;
+        line: number;
+        range: Range;
+        sourceFsPath: string;
+    }>;
+    /**
+     * TODO Replace with watcher
+     */
+    notifyUpdate({ changed, removed }: {
+        changed?: string;
+        removed?: string;
+    }): Promise<boolean>;
+}

package/dist/LikeC4LanguageServices.js

@@ -0,0 +1,118 @@
+import { LikeC4Model } from "@likec4/core";
+import { loggable } from "@likec4/log";
+import { URI } from "langium";
+import { entries, hasAtLeast, indexBy, map, pipe, prop } from "remeda";
+import { DiagnosticSeverity } from "vscode-languageserver-types";
+import { logger as mainLogger } from "./logger.js";
+import { ProjectsManager } from "./workspace/index.js";
+const logger = mainLogger.getChild("LikeC4LanguageServices");
+export class DefaultLikeC4LanguageServices {
+  constructor(services) {
+    this.services = services;
+    this.views = services.likec4.Views;
+    this.builder = services.likec4.ModelBuilder;
+    this.projectsManager = services.shared.workspace.ProjectsManager;
+  }
+  views;
+  builder;
+  projectsManager;
+  get workspaceUri() {
+    return this.services.shared.workspace.WorkspaceManager.workspaceUri;
+  }
+  projects() {
+    const projectsManager = this.services.shared.workspace.ProjectsManager;
+    const projectsWithDocs = pipe(
+      this.services.shared.workspace.LangiumDocuments.groupedByProject(),
+      entries(),
+      map(([projectId, docs]) => {
+        const id = projectId;
+        const { folder, config } = projectsManager.getProject(id);
+        return {
+          id,
+          folder,
+          config,
+          documents: map(docs, prop("uri"))
+        };
+      })
+    );
+    if (hasAtLeast(projectsWithDocs, 1)) {
+      return projectsWithDocs;
+    }
+    return [{
+      id: ProjectsManager.DefaultProjectId,
+      folder: this.services.shared.workspace.WorkspaceManager.workspaceUri,
+      config: {
+        name: "default"
+      },
+      documents: null
+    }];
+  }
+  /**
+   * Diagram is a computed view, layouted using Graphviz
+   * Used in React components
+   */
+  async diagrams() {
+    return await this.views.diagrams();
+  }
+  /**
+   * Builds LikeC4Model from all documents
+   * Only computes view predicates {@link ComputedView} - i.e. no layout
+   * Not ready for rendering, but enough to traverse
+   */
+  async computedModel(project) {
+    const projectId = this.projectsManager.ensureProjectId(project);
+    return await this.builder.buildLikeC4Model(projectId);
+  }
+  /**
+   * Same as {@link computedModel()}, but also applies layout
+   * Ready for rendering
+   */
+  async layoutedModel(project) {
+    const projectId = this.projectsManager.ensureProjectId(project);
+    const parsed = await this.builder.parseModel(projectId);
+    if (!parsed) {
+      throw new Error("Failed to parse model");
+    }
+    const diagrams = await this.views.diagrams(projectId);
+    return LikeC4Model.create({
+      ...parsed,
+      __: "layouted",
+      views: indexBy(diagrams, prop("id"))
+    });
+  }
+  getErrors() {
+    const docs = this.services.shared.workspace.LangiumDocuments.allExcludingBuiltin.toArray();
+    return docs.flatMap((doc) => {
+      return (doc.diagnostics ?? []).filter((d) => d.severity === DiagnosticSeverity.Error).map(({ message, range }) => ({
+        message,
+        line: range.start.line,
+        range,
+        sourceFsPath: doc.uri.fsPath
+      }));
+    });
+  }
+  /**
+   * TODO Replace with watcher
+   */
+  async notifyUpdate({ changed, removed }) {
+    if (!changed && !removed) {
+      return false;
+    }
+    const mutex = this.services.shared.workspace.WorkspaceLock;
+    try {
+      let completed = false;
+      await mutex.write(async (token) => {
+        await this.services.shared.workspace.DocumentBuilder.update(
+          changed ? [URI.file(changed)] : [],
+          removed ? [URI.file(removed)] : [],
+          token
+        );
+        completed = !token.isCancellationRequested;
+      });
+      return completed;
+    } catch (e) {
+      logger.error(loggable(e));
+      return false;
+    }
+  }
+}

package/dist/Rpc.js

@@ -1,19 +1,23 @@
-import { filter, funnel, indexBy, map, pipe } from "remeda";
+import { filter, flatMap, funnel, indexBy, keys, map, mapValues, pipe, sort } from "remeda";
 import { logger as rootLogger } from "./logger.js";
-import { LikeC4Model, nonexhaustive } from "@likec4/core";
+import {
+  LikeC4Model,
+  nonexhaustive
+} from "@likec4/core";
 import { Disposable, interruptAndCheck, URI, UriUtils } from "langium";
 import { DiagnosticSeverity } from "vscode-languageserver";
-import { isLikeC4LangiumDocument } from "./ast.js";
-import { isLikeC4Builtin } from "./likec4lib.js";
 import {
   BuildDocuments,
   ChangeView,
   ComputeView,
+  DidChangeModelNotification,
   FetchComputedModel,
   FetchLayoutedModel,
+  FetchProjects,
+  FetchTelemetryMetrics,
+  FetchViewsFromAllProjects,
   LayoutView,
   Locate,
-  onDidChangeModel,
   ValidateLayout
 } from "./protocol.js";
 import { ADisposable } from "./utils/index.js";
@@ -29,6 +33,7 @@ export class Rpc extends ADisposable {
     const modelEditor = this.services.likec4.ModelChanges;
     const views = this.services.likec4.Views;
     const connection = this.services.shared.lsp.Connection;
+    const projects = this.services.shared.workspace.ProjectsManager;
     if (!connection) {
       logger.info(`[ServerRpc] no connection, not initializing`);
       return;
@@ -39,14 +44,14 @@ export class Rpc extends ADisposable {
     const notifyModelParsed = funnel(
       () => {
         logger.debug`sendNotification ${"onDidChangeModel"}`;
-        connection.sendNotification(onDidChangeModel, "").catch((e) => {
+        connection.sendNotification(DidChangeModelNotification.type, "").catch((e) => {
           logger.warn(`[ServerRpc] error sending onDidChangeModel: ${e}`);
           return Promise.resolve();
         });
       },
       {
         triggerAt: "end",
-        minQuietPeriodMs: 150,
+        minQuietPeriodMs: 100,
         maxBurstDurationMs: 500,
         minGapMs: 300
       }
@@ -54,28 +59,29 @@ export class Rpc extends ADisposable {
     let isFirstBuild = true;
     this.onDispose(
       modelBuilder.onModelParsed(() => notifyModelParsed.call()),
-      connection.onRequest(FetchComputedModel.Req, async ({ cleanCaches }, cancelToken) => {
-        logger.debug`received request ${"fetchComputedModel"}`;
+      connection.onRequest(FetchComputedModel.req, async ({ projectId, cleanCaches }, cancelToken) => {
+        logger.debug`received request ${"fetchComputedModel"} for project ${projectId}`;
         if (cleanCaches) {
-          const all = LangiumDocuments.all.map((d) => d.uri).toArray();
-          await DocumentBuilder.update(all, [], cancelToken);
+          const docs = projectId ? LangiumDocuments.projectDocuments(projectId) : LangiumDocuments.all;
+          const uris = docs.map((d) => d.uri).toArray();
+          await DocumentBuilder.update(uris, [], cancelToken);
         }
-        const likec4model = await modelBuilder.buildLikeC4Model(cancelToken);
+        const likec4model = await modelBuilder.buildLikeC4Model(projectId, cancelToken);
         if (likec4model !== LikeC4Model.EMPTY) {
           return { model: likec4model.$model };
         }
         return { model: null };
       }),
-      connection.onRequest(ComputeView.Req, async ({ viewId }, cancelToken) => {
-        const view = await modelBuilder.computeView(viewId, cancelToken);
+      connection.onRequest(ComputeView.req, async ({ viewId, projectId }, cancelToken) => {
+        const view = await modelBuilder.computeView(viewId, projectId, cancelToken);
         return { view };
       }),
-      connection.onRequest(FetchLayoutedModel.Req, async (cancelToken) => {
-        const model = await modelBuilder.parseModel(cancelToken);
+      connection.onRequest(FetchLayoutedModel.req, async ({ projectId }, cancelToken) => {
+        const model = await modelBuilder.parseModel(projectId, cancelToken);
         if (model === null) {
           return { model: null };
         }
-        const diagrams = await views.diagrams();
+        const diagrams = await views.diagrams(projectId, cancelToken);
         return {
           model: {
             ...model,
@@ -84,20 +90,59 @@ export class Rpc extends ADisposable {
           }
         };
       }),
-      connection.onRequest(LayoutView.Req, async ({ viewId }, cancelToken) => {
-        logger.debug`received request ${"layoutView"} of ${viewId}`;
-        const result = await views.layoutView(viewId, cancelToken);
+      connection.onRequest(LayoutView.req, async ({ viewId, projectId }, cancelToken) => {
+        logger.debug`received request ${"layoutView"} of ${viewId} from project ${projectId}`;
+        const result = await views.layoutView(viewId, projectId, cancelToken);
         return { result };
       }),
-      connection.onRequest(ValidateLayout.Req, async (cancelToken) => {
-        const layouts = await views.layoutAllViews(cancelToken);
+      connection.onRequest(ValidateLayout.Req, async ({ projectId }, cancelToken) => {
+        const layouts = await views.layoutAllViews(projectId, cancelToken);
         const result = reportLayoutDrift(layouts.map((l) => l.diagram));
         return { result };
       }),
+      connection.onRequest(FetchProjects.req, async (_cancelToken) => {
+        logger.debug`received request ${"FetchProjects"}`;
+        const docsByProject = LangiumDocuments.groupedByProject();
+        return {
+          projects: mapValues(docsByProject, (docs) => map(docs, (d) => d.uri.toString()))
+        };
+      }),
+      connection.onRequest(FetchViewsFromAllProjects.req, async (cancelToken) => {
+        logger.debug`received request ${"FetchViewsFromAllProjects"}`;
+        const promises = projects.all.map(async (projectId) => {
+          const computedViews = await views.computedViews(projectId, cancelToken);
+          return pipe(
+            computedViews,
+            map((v) => ({
+              id: v.id,
+              title: v.title ?? v.id,
+              projectId
+            })),
+            sort((a, b) => {
+              if (a.id === "index") {
+                return -1;
+              }
+              if (b.id === "index") {
+                return 1;
+              }
+              return a.title.localeCompare(b.title);
+            })
+          );
+        });
+        const results = await Promise.allSettled(promises);
+        await interruptAndCheck(cancelToken);
+        return {
+          views: pipe(
+            results,
+            filter((r) => r.status === "fulfilled"),
+            flatMap((r) => r.value)
+          )
+        };
+      }),
       connection.onRequest(BuildDocuments.Req, async ({ docs }, cancelToken) => {
         const changed = docs.map((d) => URI.parse(d));
         const notChanged = (uri) => changed.every((c) => !UriUtils.equals(c, uri));
-        const deleted = LangiumDocuments.all.toArray().filter((d) => !isLikeC4Builtin(d.uri) && isLikeC4LangiumDocument(d) && notChanged(d.uri)).map((d) => d.uri);
+        const deleted = LangiumDocuments.allExcludingBuiltin.toArray().filter((d) => notChanged(d.uri)).map((d) => d.uri);
         logger.debug(
           `[ServerRpc] received request to build:
   changed (total ${changed.length}):${docs.map((d) => "\n    - " + d).join("")}
@@ -126,21 +171,54 @@ export class Rpc extends ADisposable {
       connection.onRequest(Locate.Req, (params) => {
         switch (true) {
           case "element" in params:
-            return modelLocator.locateElement(params.element, params.property ?? "name");
+            return modelLocator.locateElement(params.element, params.projectId);
           case "relation" in params:
-            return modelLocator.locateRelation(params.relation);
+            return modelLocator.locateRelation(params.relation, params.projectId);
           case "view" in params:
-            return modelLocator.locateView(params.view);
+            return modelLocator.locateView(params.view, params.projectId);
           case "deployment" in params:
-            return modelLocator.locateDeploymentElement(params.deployment, params.property ?? "name");
+            return modelLocator.locateDeploymentElement(params.deployment, params.projectId);
           default:
             nonexhaustive(params);
         }
       }),
       connection.onRequest(ChangeView.Req, async (request, _cancelToken) => {
-        logger.debug`received request ${"changeView"} of ${request.viewId}`;
+        logger.debug`received request ${"changeView"} of ${request.viewId} from project ${request.projectId}`;
         return await modelEditor.applyChange(request);
       }),
+      connection.onRequest(FetchTelemetryMetrics.req, async (cancelToken) => {
+        const projectsIds = [...projects.all];
+        const promises = projectsIds.map(async (projectId) => {
+          const model = await modelBuilder.buildLikeC4Model(projectId, cancelToken);
+          if (model === LikeC4Model.EMPTY) {
+            return Promise.reject(new Error(`Model is empty`));
+          }
+          return {
+            elementKinds: keys(model.$model.specification.elements).length,
+            relationshipKinds: keys(model.$model.specification.relationships).length,
+            tags: model.$model.specification.tags.length,
+            elements: keys(model.$model.elements).length,
+            relationships: keys(model.$model.relations).length,
+            views: keys(model.$model.views).length,
+            projects: 1
+          };
+        });
+        const results = await Promise.allSettled(promises);
+        await interruptAndCheck(cancelToken);
+        const values = results.filter((r) => r.status === "fulfilled").map((r) => r.value);
+        const metrics = values.length > 0 ? values.reduce((acc, r) => ({
+          elementKinds: acc.elementKinds + r.elementKinds,
+          relationshipKinds: acc.relationshipKinds + r.relationshipKinds,
+          tags: acc.tags + r.tags,
+          elements: acc.elements + r.elements,
+          relationships: acc.relationships + r.relationships,
+          views: acc.views + r.views,
+          projects: acc.projects + 1
+        })) : null;
+        return {
+          metrics
+        };
+      }),
       Disposable.create(() => {
         notifyModelParsed.cancel();
       })

package/dist/ast.d.ts

@@ -7,6 +7,14 @@ import * as ast from './generated/ast';
 import type { IsValidFn } from './validation';
 export { ast };
 declare const idattr: unique symbol;
+declare module 'langium' {
+    interface LangiumDocument {
+        likec4ProjectId?: c4.ProjectId;
+    }
+    interface AstNodeDescription {
+        likec4ProjectId?: c4.ProjectId;
+    }
+}
 declare module './generated/ast' {
     interface Element {
         [idattr]?: c4.Fqn | undefined;
@@ -173,8 +181,10 @@ export interface LikeC4DocumentProps {
 }
 type LikeC4GrammarDocument = Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>;
 export interface LikeC4LangiumDocument extends LikeC4GrammarDocument, LikeC4DocumentProps {
+    likec4ProjectId: c4.ProjectId;
 }
 export interface ParsedLikeC4LangiumDocument extends LikeC4GrammarDocument, Required<LikeC4DocumentProps> {
+    likec4ProjectId: c4.ProjectId;
 }
 export declare function isLikeC4LangiumDocument(doc: LangiumDocument): doc is LikeC4LangiumDocument;
 export declare function isParsedLikeC4LangiumDocument(doc: LangiumDocument): doc is ParsedLikeC4LangiumDocument;