@likec4/language-server 0.5.0 → 0.6.1

package/dist/index.d.ts

@@ -1,3 +1,3 @@
 export { createLanguageServices } from './module';
+export type { LikeC4Services } from './module';
 export { LikeC4LanguageMetaData as LanguageMetaData } from './generated/module';
-export { Rpc } from './protocol';

package/dist/index.js

@@ -1,6 +1,5 @@
 // import { type DefaultSharedModuleContext, startLanguageServer as startLangiumLanguageServer } from 'langium'
 export { createLanguageServices } from './module';
-// export type { C4XServices }
 // export type { C4XModel } from './c4x-model'
 // export type { C4XLangiumDocument } from './ast'
 // export {
@@ -13,4 +12,3 @@ export { LikeC4LanguageMetaData as LanguageMetaData } from './generated/module';
 //   startLangiumLanguageServer(shared)
 //   return likec4
 // }
-export { Rpc } from './protocol';

package/dist/lsp/SemanticTokenProvider.js

@@ -15,17 +15,8 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
                 property: 'el',
                 type: isElementRefHead(node) ? SemanticTokenTypes.variable : SemanticTokenTypes.property
             });
-            // acceptor({
-            //   node,
-            //   property: 'el',
-            //   type: SemanticTokenTypes.variable,
-            // })
             return;
         }
-        //   if (ast.isSpec(node)) {
-        //     keyword('spec')
-        //     return
-        //   }
         if (ast.isWildcardExpression(node)) {
             acceptor({
                 node,
@@ -56,21 +47,6 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
             }
             return;
         }
-        //   if (ast.isDynamicViewStep(node)) {
-        //     keyword(node.isReverse ? '<-' : '->')
-        //     if (hasTitle(node)) {
-        //       acceptor({
-        //         node,
-        //         property: 'title',
-        //         type: SemanticTokenTypes.string
-        //       })
-        //     }
-        //     return
-        //   }
-        //   if (ast.isStyleProperties(node)) {
-        //     keyword('style')
-        //     return
-        //   }
         if (ast.isElementKind(node)) {
             acceptor({
                 node,
@@ -122,7 +98,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
             });
             return;
         }
-        if (ast.isColorProperty(node) || ast.isShapeProperty(node)) {
+        if (ast.isAStyleProperty(node)) {
             acceptor({
                 node,
                 property: 'key',
@@ -135,36 +111,34 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
             });
             return;
         }
-        if (ast.isElementProperty(node) || ast.isRelationProperty(node) || ast.isViewProperty(node)) {
+        if (ast.isAnyStringProperty(node)) {
             acceptor({
                 node,
                 property: 'key',
                 type: SemanticTokenTypes.keyword
             });
-            if ('value' in node) {
-                acceptor({
-                    node,
-                    property: 'value',
-                    type: SemanticTokenTypes.string
-                });
-            }
-            return;
-        }
-        if (ast.isModel(node)) {
-            keyword('model');
-            return;
-        }
-        if (ast.isModelViews(node)) {
-            keyword('views');
+            acceptor({
+                node,
+                property: 'value',
+                type: SemanticTokenTypes.string
+            });
             return;
         }
+        // if (ast.isModel(node)) {
+        //   keyword('model')
+        //   return
+        // }
+        // if (ast.isModelViews(node)) {
+        //   keyword('views')
+        //   return
+        // }
         if (ast.isElement(node)) {
             return this.highlightAstElement(node, acceptor);
         }
-        if (ast.isExtendElement(node)) {
-            keyword('extend');
-            return;
-        }
+        // if (ast.isExtendElement(node)) {
+        //   keyword('extend')
+        //   return
+        // }
         //   if (ast.isElementProperty(node) || ast.isRelationProperty(node) || ast.isViewProperty(node)) {
         //     acceptor({
         //       node,
@@ -188,19 +162,19 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         //     keyword('steps')
         //     return
         //   }
-        if (ast.isViewRuleAutoLayout(node)) {
-            keyword('autoLayout');
-            return;
-        }
-        if (ast.isViewRuleStyle(node)) {
-            keyword('style');
-            return;
-        }
-        if (ast.isViewRuleExpression(node)) {
-            keyword(node.isInclude ? 'include' : 'exclude');
-            return;
-        }
-        //
+        // if (ast.isViewRuleAutoLayout(node)) {
+        //   keyword('autoLayout')
+        //   return
+        // }
+        // if (ast.isViewRuleStyle(node)) {
+        //   keyword('style')
+        //   return
+        // }
+        // if (ast.isViewRuleExpression(node)) {
+        //   keyword(node.isInclude ? 'include' : 'exclude')
+        //   return
+        // }
+        // //
     }
     highlightAstElement(node, acceptor) {
         acceptor({

package/dist/model/model-builder.js

@@ -6,10 +6,11 @@ import { DocumentState, getDocument, interruptAndCheck } from 'langium';
 import objectHash from 'object-hash';
 import { clone, isNil, mergeDeepRight, omit, reduce } from 'rambdax';
 import invariant from 'tiny-invariant';
+import { toAutoLayout } from '../ast';
 import { ElementViewOps, ast, c4hash, cleanParsedModel, isLikeC4LangiumDocument, isParsedLikeC4LangiumDocument, resolveRelationPoints, streamModel, toElementStyle } from '../ast';
 import { elementRef, strictElementRefFqn } from '../elementRef';
 import { logger } from '../logger';
-import { Rpc } from '../protocol';
+import { Rpc } from '@likec4/language-protocol';
 import { failExpectedNever } from '../utils';
 export class LikeC4ModelBuilder {
     services;
@@ -258,29 +259,29 @@ export class LikeC4ModelBuilder {
         }
         failExpectedNever(astNode);
     }
-    parseViewRule(astNode) {
-        if (ast.isViewRuleExpression(astNode)) {
-            const exprs = astNode.expressions.map(n => this.parseExpression(n));
+    parseViewRule(astRule) {
+        if (ast.isViewRuleExpression(astRule)) {
+            const exprs = astRule.expressions.map(n => this.parseExpression(n));
             return {
-                isInclude: astNode.isInclude,
+                isInclude: astRule.isInclude,
                 exprs
             };
         }
-        if (ast.isViewRuleStyle(astNode)) {
-            const styleProps = toElementStyle(astNode.props);
+        if (ast.isViewRuleStyle(astRule)) {
+            const styleProps = toElementStyle(astRule.props);
             return {
-                targets: astNode.targets.map(n => this.parseElementExpression(n)),
+                targets: astRule.targets.map(n => this.parseElementExpression(n)),
                 style: {
                     ...styleProps
                 }
             };
         }
-        if (ast.isViewRuleAutoLayout(astNode)) {
+        if (ast.isViewRuleAutoLayout(astRule)) {
             return {
-                autoLayout: astNode.direction
+                autoLayout: toAutoLayout(astRule.direction)
             };
         }
-        failExpectedNever(astNode);
+        failExpectedNever(astRule);
     }
     parseElementView(astNode) {
         const viewOfEl = astNode.viewOf && elementRef(astNode.viewOf);
@@ -326,6 +327,6 @@ export class LikeC4ModelBuilder {
             return;
         }
         logger.debug('Send onDidChangeModel');
-        await connection.sendNotification(Rpc.onDidChangeModel, null);
+        await connection.sendNotification(Rpc.onDidChangeModel);
     }
 }

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

@@ -0,0 +1 @@
+export {};

package/dist/model/model-builder.spec.js

@@ -0,0 +1,141 @@
+import { describe, expect, it } from 'vitest';
+import { createTestServices } from '../test';
+import { keys } from 'rambdax';
+describe('LikeC4ModelBuilder', () => {
+    it('builds model', async () => {
+        const { validate, buildModel } = createTestServices();
+        const { diagnostics } = await validate(`
+    specification {
+      element component
+      element user {
+        style {
+          shape: person
+        }
+      }
+      tag deprecated
+    }
+    model {
+      user client {
+        -> frontend
+      }
+      component system {
+        backend = component 'Backend' {
+          technology 'NodeJS'
+
+          style {
+            color secondary
+          }
+        }
+        component frontend {
+          #deprecated
+          description 'Frontend description'
+
+          style {
+            color: muted
+            shape: browser
+          }
+
+          -> backend 'requests'
+        }
+      }
+    }
+    `);
+        expect(diagnostics).toHaveLength(0);
+        const model = await buildModel();
+        expect(model).toBeDefined();
+        expect(model.elements).toMatchObject({
+            client: {
+                kind: 'user',
+                shape: 'person'
+            },
+            'system.backend': {
+                color: 'secondary',
+                title: 'Backend',
+                technology: 'NodeJS'
+            },
+            'system.frontend': {
+                color: 'muted',
+                shape: 'browser',
+                description: 'Frontend description'
+            }
+        });
+        expect(model.elements['client']).not.toHaveProperty('color');
+        expect(model.elements['system']).not.toHaveProperty('color');
+        expect(model.elements['system']).not.toHaveProperty('shape');
+        expect(model.elements['system.backend']).toHaveProperty('color', 'secondary');
+        expect(model.elements['system.backend']).not.toHaveProperty('description');
+        expect(model).toMatchSnapshot();
+    });
+    it('builds model with extend', async () => {
+        const { parse, validateAll, buildModel } = createTestServices();
+        await parse(`
+    specification {
+      element component
+      element user
+      tag deprecated
+    }
+    model {
+      user client
+      component system {
+        backend = component
+        component frontend
+      }
+    }
+    `);
+        await parse(`
+    model {
+      extend system.backend {
+        component api
+      }
+      system.frontend -> api 'requests'
+      client -> system.frontend {
+        title 'opens'
+      }
+    }
+    views {
+      view index {
+        title 'Index'
+        include *
+      }
+
+      view v1 of api {
+        include *
+        autoLayout LeftRight
+      }
+
+      view of system.frontend {
+        include *
+      }
+    }
+    `);
+        const { errors } = await validateAll();
+        expect(errors).toEqual([]);
+        const model = await buildModel();
+        expect(model).toBeDefined();
+        expect(model.elements).toMatchObject({
+            client: {
+                kind: 'user'
+            },
+            'system.backend.api': {
+                kind: 'component'
+            }
+        });
+        expect(keys(model.relations)).toHaveLength(2);
+        expect(keys(model.views)).toHaveLength(3);
+        expect(model.views).toMatchObject({
+            index: {
+                id: 'index',
+                title: 'Index',
+                autoLayout: 'TB'
+            },
+            v1: {
+                id: 'v1',
+                viewOf: 'system.backend.api',
+                title: 'api',
+                autoLayout: 'LR'
+            }
+        });
+        expect(model.views['index']).not.toHaveProperty('viewOf');
+        expect(model).toMatchSnapshot();
+    });
+});

package/dist/protocol.d.ts

@@ -4,32 +4,36 @@ import { NotificationType, RequestType0, RequestType } from 'vscode-languageserv
 export declare const onDidChangeLikeC4Model: NotificationType<unknown>;
 export declare const fetchLikeC4Model: RequestType0<{
     model: LikeC4Model | null;
-}, unknown>;
-export declare const buildDocuments: RequestType<string[], void, unknown>;
+}, void>;
+export declare const buildDocuments: RequestType<string[], void, void>;
 export declare const locateElement: RequestType<{
     element: Fqn;
-    property?: string;
-}, Location | null, unknown>;
+    property: string | null;
+}, {
+    location: Location | null;
+}, void>;
 export declare const locateRelation: RequestType<{
     id: RelationID;
-}, Location | null, unknown>;
+}, Location | null, void>;
 export declare const locateView: RequestType<{
     id: ViewID;
-}, Location | null, unknown>;
+}, Location | null, void>;
 export declare const Rpc: {
     readonly onDidChangeModel: NotificationType<unknown>;
     readonly fetchModel: RequestType0<{
         model: LikeC4Model | null;
-    }, unknown>;
-    readonly buildDocuments: RequestType<string[], void, unknown>;
+    }, void>;
+    readonly buildDocuments: RequestType<string[], void, void>;
     readonly locateElement: RequestType<{
         element: Fqn;
-        property?: string;
-    }, Location | null, unknown>;
+        property: string | null;
+    }, {
+        location: Location | null;
+    }, void>;
     readonly locateRelation: RequestType<{
         id: RelationID;
-    }, Location | null, unknown>;
+    }, Location | null, void>;
     readonly locateView: RequestType<{
         id: ViewID;
-    }, Location | null, unknown>;
+    }, Location | null, void>;
 };

package/dist/protocol.js

@@ -2,13 +2,13 @@ import { NotificationType, RequestType0, RequestType } from 'vscode-languageserv
 //#region From server
 export const onDidChangeLikeC4Model = new NotificationType('likec4/onDidChangeModel');
 //#endregion
-// //#region To server
+//#region To server
 export const fetchLikeC4Model = new RequestType0('likec4/fetchModel');
 export const buildDocuments = new RequestType('likec4/buildDocuments');
 export const locateElement = new RequestType('likec4/locateElement');
 export const locateRelation = new RequestType('likec4/locateRelation');
 export const locateView = new RequestType('likec4/locateView');
-// //#endregion
+//#endregion
 export const Rpc = {
     onDidChangeModel: onDidChangeLikeC4Model,
     fetchModel: fetchLikeC4Model,

package/dist/registerProtocolHandlers.js

@@ -1,5 +1,5 @@
 import { logger } from './logger';
-import { Rpc } from './protocol';
+import { buildDocuments, fetchLikeC4Model, locateElement, locateRelation, locateView } from '@likec4/language-protocol';
 export function registerProtocolHandlers(services) {
     const connection = services.shared.lsp.Connection;
     if (!connection) {
@@ -8,7 +8,7 @@ export function registerProtocolHandlers(services) {
     const modelBuilder = services.likec4.ModelBuilder;
     const modelLocator = services.likec4.ModelLocator;
     const LangiumDocuments = services.shared.workspace.LangiumDocuments;
-    connection.onRequest(Rpc.fetchModel, async (_cancelToken) => {
+    connection.onRequest(fetchLikeC4Model, async (_cancelToken) => {
         let model;
         try {
             model = modelBuilder.buildModel() ?? null;
@@ -21,7 +21,7 @@ export function registerProtocolHandlers(services) {
             model: model ?? null
         });
     });
-    connection.onRequest(Rpc.buildDocuments, async (docs, cancelToken) => {
+    connection.onRequest(buildDocuments, async (docs, cancelToken) => {
         const changed = [];
         for (const d of docs) {
             const uri = d;
@@ -37,13 +37,28 @@ export function registerProtocolHandlers(services) {
     ]`);
         await services.shared.workspace.DocumentBuilder.update(changed, [], cancelToken);
     });
-    connection.onRequest(Rpc.locateElement, ({ element, property }, _cancelToken) => {
-        return modelLocator.locateElement(element, property);
+    connection.onRequest(locateElement, async ({ element, property }, _cancelToken) => {
+        try {
+            return Promise.resolve(modelLocator.locateElement(element, property ?? 'name'));
+        }
+        catch (e) {
+            return Promise.reject(e);
+        }
     });
-    connection.onRequest(Rpc.locateRelation, ({ id }, _cancelToken) => {
-        return modelLocator.locateRelation(id);
+    connection.onRequest(locateRelation, ({ id }, _cancelToken) => {
+        try {
+            return Promise.resolve(modelLocator.locateRelation(id));
+        }
+        catch (e) {
+            return Promise.reject(e);
+        }
     });
-    connection.onRequest(Rpc.locateView, ({ id }, _cancelToken) => {
-        return modelLocator.locateView(id);
+    connection.onRequest(locateView, ({ id }, _cancelToken) => {
+        try {
+            return Promise.resolve(modelLocator.locateView(id));
+        }
+        catch (e) {
+            return Promise.reject(e);
+        }
     });
 }

package/dist/validation/element.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/validation/element.spec.js

@@ -0,0 +1,65 @@
+import { describe, expect, it } from 'vitest';
+import { createTestServices } from '../test';
+describe('elementChecks', () => {
+    it('should report duplicate element names', async () => {
+        const { validate } = createTestServices();
+        const { diagnostics } = await validate(`
+      specification {
+        element component
+      }
+      model {
+        component c1
+        component c2
+        component c1
+      }
+    `);
+        expect(diagnostics).toHaveLength(2);
+        for (const diagnostic of diagnostics) {
+            expect(diagnostic.severity, 'diagnostic severity').toBe(1);
+            expect(diagnostic.message, 'diagnostic message').toBe('Duplicate element name c1');
+        }
+    });
+    it('should report duplicate element names in extendElement', async () => {
+        const { parse, validateAll } = createTestServices();
+        await parse(`
+      specification {
+        element component
+      }
+      model {
+        component c1 {
+          component c2 {
+            component c3
+          }
+        }
+      }
+    `);
+        await parse(`
+      model {
+        extend c1.c2 {
+          component c3
+        }
+      }
+    `);
+        const { diagnostics } = await validateAll();
+        expect(diagnostics).toHaveLength(2);
+        for (const diagnostic of diagnostics) {
+            expect(diagnostic.severity, 'diagnostic severity').toBe(1);
+            expect(diagnostic.message, 'diagnostic message').toBe('Duplicate element name c3 (c1.c2.c3)');
+        }
+    });
+    it('should not report duplicate element names in nested', async () => {
+        const { validate } = createTestServices();
+        const { errors } = await validate(`
+      specification {
+        element component
+      }
+      model {
+        component c1
+        component c2 {
+          component c1
+        }
+      }
+    `);
+        expect(errors).toEqual([]);
+    });
+});

package/dist/validation/relation.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/validation/relation.spec.js

@@ -0,0 +1,93 @@
+import { describe, expect, it } from 'vitest';
+import { createTestServices } from '../test';
+describe('relationChecks', () => {
+    it('should not report invalid relations', async () => {
+        const { validate } = createTestServices();
+        const { errors } = await validate(`
+      specification {
+        element component
+      }
+      model {
+        component c1 {
+          component c2 {
+            -> c3
+          }
+        }
+        component c3 {
+          this -> c1
+        }
+        c3 -> c2
+      }
+    `);
+        expect(errors).toEqual([]);
+    });
+    it('should report invalid relation: parent -> child', async () => {
+        const { validate } = createTestServices();
+        const { errors } = await validate(`
+      specification {
+        element component
+      }
+      model {
+        component c1 {
+          component c2 {
+            component c3
+          }
+        }
+        c1 -> c3
+      }
+    `);
+        expect(errors).toEqual(['Invalid relation (same hierarchy)']);
+    });
+    it('should report invalid relation: -> nested child', async () => {
+        const { validate } = createTestServices();
+        const { errors } = await validate(`
+      specification {
+        element component
+      }
+      model {
+        component c1 {
+          component c2 {
+            component c3
+          }
+          -> c3
+        }
+      }
+    `);
+        expect(errors).toEqual(['Invalid relation (same hierarchy)']);
+    });
+    it('should report invalid relation: child -> parent', async () => {
+        const { validate } = createTestServices();
+        const { errors } = await validate(`
+      specification {
+        element component
+      }
+      model {
+        component c1 {
+          component c2 {
+            component c3
+          }
+        }
+        c3 -> c2
+      }
+    `);
+        expect(errors).toEqual(['Invalid relation (same hierarchy)']);
+    });
+    it('should report invalid relation: nested child -> parent', async () => {
+        const { validate } = createTestServices();
+        const { errors } = await validate(`
+      specification {
+        element component
+      }
+      model {
+        component c1 {
+          component c2 {
+            component c3 {
+              -> c1
+            }
+          }
+        }
+      }
+    `);
+        expect(errors).toEqual(['Invalid relation (same hierarchy)']);
+    });
+});

package/dist/validation/specification.spec.d.ts

@@ -0,0 +1 @@
+export {};