@likec4/language-server 0.6.0 → 0.6.1

package/dist/__test__/parser-smoke/08-Structurizr.js

@@ -0,0 +1,22 @@
+const model = `
+specification {
+  element person
+  element group
+  element softwareSystem
+  element container
+  element component
+}
+`;
+export const valid_08_Structurizr = model +
+    `
+model {
+  u = person "User"
+  s = softwareSystem "Software System" {
+      webapp = container "Web Application" "" "Spring Boot"
+      database = container "Database" "" "Relational database schema"
+  }
+
+  u -> webapp "Uses"
+  webapp -> database "Reads from and writes to"
+}
+`;

package/dist/__test__/parser-smoke/index.d.ts

@@ -0,0 +1,8 @@
+export * from './01-Specification';
+export * from './02-Model';
+export * from './03-ModelRelation';
+export * from './04-Scope';
+export * from './05-StrictElementRef';
+export * from './06-ElementRef';
+export * from './07-Views';
+export * from './08-Structurizr';

package/dist/__test__/parser-smoke/index.js

@@ -0,0 +1,8 @@
+export * from './01-Specification';
+export * from './02-Model';
+export * from './03-ModelRelation';
+export * from './04-Scope';
+export * from './05-StrictElementRef';
+export * from './06-ElementRef';
+export * from './07-Views';
+export * from './08-Structurizr';

package/dist/__test__/parser-smoke-extendsElement.spec.d.ts

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

package/dist/__test__/parser-smoke-extendsElement.spec.js

@@ -0,0 +1,36 @@
+import { expect, test } from 'vitest';
+import { createTestServices } from '../test';
+const document1 = `
+specification {
+  element component
+}
+model {
+  component system {
+    sub = component {
+      component sub1
+    }
+  }
+}
+`;
+const document2 = `
+model {
+  extend system.sub {
+    component sub2 {
+      -> sub1
+    }
+  }
+}
+`;
+const document3 = `
+model {
+  system.sub1 -> system.sub2
+}
+`;
+test('parser smoke: ExtendsElement Scope', async () => {
+    const { parse, validateAll } = createTestServices();
+    await parse(document1);
+    await parse(document2);
+    await parse(document3);
+    const { errors } = await validateAll();
+    expect(errors).toEqual([]);
+});

package/dist/__test__/parser-smoke.spec.d.ts

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

package/dist/__test__/parser-smoke.spec.js

@@ -0,0 +1,28 @@
+import { toPairs } from 'rambdax';
+import { describe, vi, it } from 'vitest';
+import { createTestServices } from '../test';
+import * as testfiles from './parser-smoke';
+vi.mock('../logger', () => ({
+    logger: {
+        log: vi.fn(),
+        error: vi.fn(),
+        warn: vi.fn(),
+        info: vi.fn(),
+        debug: vi.fn()
+    }
+}));
+describe('parser smoke', () => {
+    toPairs(testfiles).forEach(([name, document]) => {
+        it.concurrent(name, async ({ expect }) => {
+            const { validate } = createTestServices();
+            const { diagnostics } = await validate(document);
+            const errors = diagnostics.map(d => d.message);
+            if (name.startsWith('invalid_')) {
+                expect(errors).not.toEqual([]);
+            }
+            else {
+                expect(errors).toEqual([]);
+            }
+        });
+    });
+});

package/dist/ast.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="react" />
 import * as ast from './generated/ast';
 import type { LangiumDocument } from 'langium';
 import type { LikeC4Document } from './generated/ast';

package/dist/index.d.ts

@@ -1,4 +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

@@ -12,4 +12,3 @@ export { LikeC4LanguageMetaData as LanguageMetaData } from './generated/module';
 //   startLangiumLanguageServer(shared)
 //   return likec4
 // }
-export { Rpc } from './protocol';

package/dist/lsp/DocumentSymbolProvider.d.ts

@@ -3,6 +3,7 @@
  * This program and the accompanying materials are made available under the
  * terms of the MIT License, which is available in the project root.
  ******************************************************************************/
+/// <reference types="react" />
 import { type DocumentSymbolProvider, type MaybePromise } from 'langium';
 import { type DocumentSymbol } from 'vscode-languageserver-protocol';
 import { type LikeC4LangiumDocument, ast } from '../ast';

package/dist/model/model-builder.js

@@ -10,7 +10,7 @@ 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;
@@ -259,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: toAutoLayout(astNode.direction)
+                autoLayout: toAutoLayout(astRule.direction)
             };
         }
-        failExpectedNever(astNode);
+        failExpectedNever(astRule);
     }
     parseElementView(astNode) {
         const viewOfEl = astNode.viewOf && elementRef(astNode.viewOf);
@@ -327,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.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="react" />
 import type { ValidationCheck } from 'langium';
 import type { ast } from '../ast';
 import type { LikeC4Services } from '../module';

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 {};

package/dist/validation/specification.spec.js

@@ -0,0 +1,31 @@
+import { expect, test } from 'vitest';
+import { createTestServices } from '../test';
+const { validate } = createTestServices();
+test('elementKindChecks', async () => {
+    const { diagnostics } = await validate(`
+    specification {
+      element component
+      element user
+      element component
+    }
+  `);
+    expect(diagnostics).toHaveLength(2);
+    for (const diagnostic of diagnostics) {
+        expect(diagnostic.severity, 'diagnostic severity').toBe(1);
+        expect(diagnostic.message, 'diagnostic message').toBe("Duplicate element kind 'component'");
+    }
+});
+test('tagChecks', async () => {
+    const { diagnostics } = await validate(`
+    specification {
+      tag tag1
+      tag tag2
+      tag tag1
+    }
+  `);
+    expect(diagnostics).toHaveLength(2);
+    for (const diagnostic of diagnostics) {
+        expect(diagnostic.severity, 'diagnostic severity').toBe(1);
+        expect(diagnostic.message, 'diagnostic message').toBe("Duplicate tag 'tag1'");
+    }
+});

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

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