@likec4/language-server 1.46.2 → 1.46.4

package/dist/Rpc.js

@@ -1,4 +1,4 @@
-import { filter, flatMap, funnel, indexBy, keys, map, mapValues, pipe, sort } from 'remeda';
+import { filter, funnel, indexBy, keys, map, mapValues, pipe, sort } from 'remeda';
 import { logger as rootLogger } from './logger';
 import { invariant, nonexhaustive, } from '@likec4/core';
 import { LikeC4Model } from '@likec4/core/model';
@@ -43,7 +43,7 @@ export class Rpc extends ADisposable {
         });
         let isFirstBuild = true;
         this.onDispose(likec4Services.ModelBuilder.onModelParsed(() => notifyModelParsed.call(1)), connection.onRequest(FetchComputedModel.req, async ({ projectId, cleanCaches }, cancelToken) => {
-            logger.debug `received request ${'fetchComputedModel'} for project ${projectId}`;
+            logger.debug `received request ${'fetchComputedModel'} for project ${projectId} (cleanCaches: ${cleanCaches})`;
             if (cleanCaches) {
                 const docs = projectId
                     ? LangiumDocuments.projectDocuments(projectId)
@@ -53,7 +53,7 @@ export class Rpc extends ADisposable {
             }
             const likec4model = await likec4Services.ModelBuilder.computeModel(projectId, cancelToken);
             if (likec4model !== LikeC4Model.EMPTY) {
-                return { model: likec4model.$model };
+                return { model: likec4model.$data };
             }
             return { model: null };
         }), connection.onNotification(DidChangeSnapshotNotification.type, async ({ snapshotUri }) => {
@@ -105,38 +105,41 @@ export class Rpc extends ADisposable {
                     };
                 }),
             };
-        }), connection.onRequest(ReloadProjects.req, async () => {
+        }), connection.onRequest(ReloadProjects.req, async (cancelToken) => {
             logger.debug `received request ${'ReloadProjects'}`;
             likec4Services.ManualLayouts.clearCaches();
-            await projects.reloadProjects();
+            await projects.reloadProjects(cancelToken);
             return;
-        }), connection.onRequest(RegisterProject.req, async (params) => {
+        }), connection.onRequest(RegisterProject.req, async (params, cancelToken) => {
             logger.debug `received request ${'RegisterProject'}`;
-            const project = await projects.registerProject(params);
+            const project = await projects.registerProject(params, cancelToken);
             return { id: project.id };
         }), connection.onRequest(FetchViewsFromAllProjects.req, async (cancelToken) => {
             logger.debug `received request ${'FetchViewsFromAllProjects'}`;
-            const promises = projects.all.map(async (projectId) => {
-                const computedViews = await likec4Services.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)),
-            };
+            const views = [];
+            for (const projectId of projects.all) {
+                await interruptAndCheck(cancelToken);
+                try {
+                    const computedViews = await likec4Services.Views.computedViews(projectId, cancelToken);
+                    views.push(...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);
+                    })));
+                }
+                catch (error) {
+                    logger.warn(`Failed to fetch views for project ${projectId}:`, { error });
+                }
+            }
+            return { views };
         }), 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));
@@ -186,52 +189,51 @@ export class Rpc extends ADisposable {
                 default:
                     nonexhaustive(params);
             }
-        }), connection.onRequest(ChangeView.req, async (request, _cancelToken) => {
+        }), connection.onRequest(ChangeView.req, async (request, cancelToken) => {
             logger.debug `received request ${'changeView'} of ${request.viewId} from project ${request.projectId}`;
             const loc = await likec4Services.ModelChanges.applyChange(request);
             const op = request.change.op;
             if (request.projectId &&
                 (op === 'save-view-snapshot' || op === 'reset-manual-layout')) {
-                await projects.rebuidProject(request.projectId);
+                await projects.rebuidProject(request.projectId, cancelToken);
             }
             return loc;
         }), connection.onRequest(FetchTelemetryMetrics.req, async (cancelToken) => {
-            const projectsIds = [...projects.all];
-            const promises = projectsIds.map(async (projectId) => {
-                const model = await likec4Services.ModelBuilder.computeModel(projectId, cancelToken);
-                if (model === LikeC4Model.EMPTY) {
-                    return Promise.reject(new Error(`Model is empty`));
+            let metrics = null;
+            for (const projectId of projects.all) {
+                try {
+                    const model = await likec4Services.ModelBuilder.computeModel(projectId, cancelToken);
+                    if (model === LikeC4Model.EMPTY) {
+                        continue;
+                    }
+                    metrics ??= {
+                        elementKinds: 0,
+                        deploymentKinds: 0,
+                        relationshipKinds: 0,
+                        tags: 0,
+                        customColors: 0,
+                        elements: 0,
+                        deploymentNodes: 0,
+                        relationships: 0,
+                        views: 0,
+                        projects: 0,
+                    };
+                    metrics.elementKinds += keys(model.specification.elements).length;
+                    metrics.deploymentKinds += keys(model.specification.deployments).length;
+                    metrics.relationshipKinds += keys(model.specification.relationships).length;
+                    metrics.tags += keys(model.specification.tags).length;
+                    metrics.customColors += keys(model.specification.customColors ?? {}).length;
+                    metrics.elements += keys(model.$data.elements).length;
+                    metrics.deploymentNodes += [...model.deployment.nodes()].length;
+                    metrics.relationships += keys(model.$data.relations).length;
+                    metrics.views += keys(model.$data.views).length;
+                    metrics.projects += 1;
                 }
-                return {
-                    elementKinds: keys(model.specification.elements).length,
-                    deploymentKinds: keys(model.specification.deployments).length,
-                    relationshipKinds: keys(model.specification.relationships).length,
-                    tags: keys(model.specification.tags).length,
-                    customColors: keys(model.specification.customColors ?? {}).length,
-                    elements: keys(model.$data.elements).length,
-                    deploymentNodes: [...model.deployment.nodes()].length,
-                    relationships: keys(model.$data.relations).length,
-                    views: keys(model.$data.views).length,
-                    projects: 1,
-                };
-            });
-            const results = await Promise.allSettled(promises);
+                catch (err) {
+                    logger.warn(`Error fetching telemetry metrics for project ${projectId}`, { err });
+                }
+            }
             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,
-                    deploymentKinds: acc.deploymentKinds + r.deploymentKinds,
-                    relationshipKinds: acc.relationshipKinds + r.relationshipKinds,
-                    tags: acc.tags + r.tags,
-                    customColors: acc.customColors + r.customColors,
-                    elements: acc.elements + r.elements,
-                    deploymentNodes: acc.deploymentNodes + r.deploymentNodes,
-                    relationships: acc.relationships + r.relationships,
-                    views: acc.views + r.views,
-                    projects: acc.projects + 1,
-                }))
-                : null;
             return {
                 metrics,
             };