@likec4/language-server 1.42.1 → 1.44.0

package/dist/test/testServices.d.ts

@@ -8,25 +8,25 @@ export declare function createTestServices(options?: {
     workspace?: string;
     projectConfig?: Partial<LikeC4ProjectJsonConfig>;
 }): {
-    services: any;
+    services: import("langium").LangiumGeneratedCoreServices & import("langium").LangiumDefaultCoreServices & import("langium/lsp").LangiumLSPServices & import("../module").LikeC4AddedServices;
     addDocument: (input: string, uri?: string) => Promise<LikeC4LangiumDocument>;
     removeDocument: (doc: LangiumDocument | URI) => Promise<void>;
     parse: (input: string, uri?: string) => Promise<LikeC4LangiumDocument>;
     validate: (input: string | LikeC4LangiumDocument, uri?: string) => Promise<{
         document: LikeC4LangiumDocument;
-        diagnostics: any[];
-        warnings: any[];
-        errors: any[];
+        diagnostics: (import("vscode-languageserver-types").Diagnostic & import("langium").DiagnosticInfo<import("../ast").LikeC4AstNode>)[];
+        warnings: string[];
+        errors: string[];
     }>;
     validateAll: () => Promise<{
-        diagnostics: any;
-        errors: any;
-        warnings: any;
+        diagnostics: import("vscode-languageserver-types").Diagnostic[];
+        errors: string[];
+        warnings: string[];
     }>;
     buildModel: () => Promise<ComputedLikeC4ModelData>;
-    buildLikeC4Model: () => Promise<any>;
+    buildLikeC4Model: () => Promise<import("@likec4/core/model").LikeC4Model<import("@likec4/core").UnknownComputed>>;
     resetState: () => Promise<void>;
-    format: (input: string | LikeC4LangiumDocument, uri?: string) => Promise<any>;
+    format: (input: string | LikeC4LangiumDocument, uri?: string) => Promise<string>;
 };
 /**
  * @example
@@ -43,21 +43,21 @@ export declare function createTestServices(options?: {
  * ```
  */
 export declare function createMultiProjectTestServices<const Projects extends Record<string, Record<string, string>>>(data: Projects): Promise<{
-    services: any;
+    services: import("langium").LangiumGeneratedCoreServices & import("langium").LangiumDefaultCoreServices & import("langium/lsp").LangiumLSPServices & import("../module").LikeC4AddedServices;
     projects: { readonly [K in keyof Projects]: { readonly [L in keyof Projects[K]]: LikeC4LangiumDocument; }; };
-    projectsManager: any;
+    projectsManager: import("..").ProjectsManager;
     addDocument: (uri: string | URI, input: string) => Promise<LikeC4LangiumDocument>;
     /**
      * Add document outside of projects
      */
     addDocumentOutside: (input: string) => Promise<LikeC4LangiumDocument>;
     validateAll: () => Promise<{
-        diagnostics: any;
-        errors: any;
-        warnings: any;
+        diagnostics: import("vscode-languageserver-types").Diagnostic[];
+        errors: string[];
+        warnings: string[];
     }>;
-    buildModel: (projectId: LiteralUnion<keyof Projects, string>) => Promise<ComputedLikeC4ModelData>;
-    buildLikeC4Model: (projectId: LiteralUnion<keyof Projects, string>) => Promise<any>;
+    buildModel: (projectId: LiteralUnion<keyof Projects, string>) => Promise<ComputedLikeC4ModelData<import("@likec4/core").UnknownComputed>>;
+    buildLikeC4Model: (projectId: LiteralUnion<keyof Projects, string>) => Promise<import("@likec4/core/model").LikeC4Model<import("@likec4/core").UnknownComputed>>;
 }>;
 export type TestServices = ReturnType<typeof createTestServices>;
 export type TestParseFn = TestServices['validate'];

package/dist/test/testServices.js

@@ -0,0 +1,210 @@
+import { DocumentState, TextDocument, UriUtils } from 'langium';
+import * as assert from 'node:assert';
+import { entries } from 'remeda';
+import stripIndent from 'strip-indent';
+import { DiagnosticSeverity } from 'vscode-languageserver-types';
+import { URI, Utils } from 'vscode-uri';
+import { NoopFileSystem } from '../filesystem';
+import { createLanguageServices } from '../module';
+export function createTestServices(options) {
+    const workspace = options?.workspace ?? 'file:///test/workspace';
+    const projectConfig = options?.projectConfig;
+    const services = createLanguageServices(NoopFileSystem).likec4;
+    const metaData = services.LanguageMetaData;
+    const langiumDocuments = services.shared.workspace.LangiumDocuments;
+    const documentBuilder = services.shared.workspace.DocumentBuilder;
+    const modelBuilder = services.likec4.ModelBuilder;
+    const workspaceUri = URI.parse(workspace);
+    const formatter = services.lsp.Formatter;
+    const workspaceFolder = {
+        name: projectConfig?.name || 'test-project',
+        uri: workspaceUri.toString(),
+    };
+    let isInitialized = false;
+    let documentIndex = 1;
+    async function initialize() {
+        if (isInitialized)
+            return;
+        isInitialized = true;
+        services.shared.workspace.ConfigurationProvider.updateConfiguration({
+            settings: { likec4: { formatting: { quoteStyle: 'single' } } },
+        });
+        services.shared.workspace.WorkspaceManager.initialize({
+            capabilities: {},
+            processId: null,
+            rootUri: workspaceFolder.uri,
+            workspaceFolders: [workspaceFolder],
+        });
+        await services.shared.workspace.WorkspaceManager.initializeWorkspace([workspaceFolder]);
+        // Register project with config if provided...
+        if (projectConfig) {
+            const projectFolderUri = Utils.resolvePath(workspaceUri, 'src');
+            await services.shared.workspace.ProjectsManager.registerProject({
+                config: {
+                    name: projectConfig?.name || 'test-project',
+                    title: projectConfig?.title || 'Test Project',
+                    contactPerson: projectConfig?.contactPerson || 'Unknown',
+                    imageAliases: projectConfig?.imageAliases || {},
+                    exclude: projectConfig?.exclude || ['node_modules'],
+                },
+                folderUri: projectFolderUri,
+            });
+        }
+    }
+    const addDocument = async (input, uri) => {
+        await initialize();
+        const docUri = Utils.resolvePath(workspaceUri, './src/', uri ?? `${documentIndex++}${metaData.fileExtensions[0]}`);
+        const document = services.shared.workspace.LangiumDocumentFactory.fromString(stripIndent(input), docUri);
+        langiumDocuments.addDocument(document);
+        return document;
+    };
+    const removeDocument = async (doc) => {
+        const uri = doc instanceof URI ? doc : doc.uri;
+        await documentBuilder.update([], [uri]);
+    };
+    const parse = async (input, uri) => {
+        const document = await addDocument(input, uri);
+        await documentBuilder.build([document], { validation: false });
+        return document;
+    };
+    const validate = async (input, uri) => {
+        const document = typeof input === 'string' ? await addDocument(input, uri) : input;
+        await documentBuilder.build([document], { validation: true });
+        const diagnostics = document.diagnostics ?? [];
+        const warnings = diagnostics.flatMap(d => d.severity === DiagnosticSeverity.Warning ? d.message : []);
+        const errors = diagnostics.flatMap(d => d.severity === DiagnosticSeverity.Error ? d.message : []);
+        return {
+            document,
+            diagnostics,
+            warnings,
+            errors,
+        };
+    };
+    const format = async (input, uri) => {
+        const document = typeof input === 'string' ? await parse(stripIndent(input), uri) : input;
+        await documentBuilder.build([document], { validation: true });
+        const edits = await formatter?.formatDocument(document, {
+            options: { tabSize: 2, insertSpaces: true },
+            textDocument: { uri: document.uri.toString() },
+        });
+        return TextDocument.applyEdits(document.textDocument, edits ?? []);
+    };
+    const validateAll = async () => {
+        const docs = langiumDocuments.all.toArray();
+        assert.ok(docs.length > 0, 'no documents to validate');
+        await documentBuilder.build(docs, { validation: true });
+        const diagnostics = docs.flatMap(doc => doc.diagnostics ?? []);
+        const warnings = diagnostics.flatMap(d => d.severity === DiagnosticSeverity.Warning ? d.message : []);
+        const errors = diagnostics.flatMap(d => d.severity === DiagnosticSeverity.Error ? d.message : []);
+        return {
+            diagnostics,
+            errors,
+            warnings,
+        };
+    };
+    const buildModel = async () => {
+        if (langiumDocuments.all.some(doc => doc.state < DocumentState.Validated)) {
+            await validateAll();
+        }
+        const likec4model = await modelBuilder.computeModel();
+        if (!likec4model)
+            throw new Error('No model found');
+        return likec4model.$data;
+    };
+    const buildLikeC4Model = async () => {
+        if (langiumDocuments.all.some(doc => doc.state < DocumentState.Validated)) {
+            await validateAll();
+        }
+        const likec4model = await modelBuilder.computeModel();
+        if (!likec4model)
+            throw new Error('No model found');
+        return likec4model;
+    };
+    /**
+     * This will clear all documents
+     */
+    const resetState = async () => {
+        await services.shared.workspace.WorkspaceLock.write(async (cancelToken) => {
+            const docs = langiumDocuments.allExcludingBuiltin.toArray().map(doc => doc.uri);
+            await documentBuilder.update([], docs, cancelToken);
+        });
+    };
+    return {
+        services,
+        addDocument,
+        removeDocument,
+        parse,
+        validate,
+        validateAll,
+        buildModel,
+        buildLikeC4Model,
+        resetState,
+        format,
+    };
+}
+/**
+ * @example
+ * ```ts
+ * const { projects } = await createMultiProjectTestServices({
+ *   project1: {
+ *     doc1: `...`,
+ *     doc2: `...`,
+ *   },
+ *   project2: {
+ *     doc1: `...`,
+ *   },
+ * })
+ * ```
+ */
+export async function createMultiProjectTestServices(data) {
+    const workspace = 'file:///test/workspace';
+    const { services, addDocument, validateAll, } = createTestServices({ workspace });
+    const projects = {};
+    for (const [name, files] of entries(data)) {
+        const folderUri = UriUtils.joinPath(URI.parse(workspace), 'src', name);
+        await services.shared.workspace.ProjectsManager.registerProject({
+            config: {
+                name,
+                exclude: ['node_modules'],
+            },
+            folderUri,
+        });
+        // @ts-ignore
+        projects[name] = {};
+        for (let [docName, content] of entries(files)) {
+            const fileName = docName.endsWith('.c4') ? docName : `${docName}.c4`;
+            // @ts-ignore
+            projects[name][docName] = await addDocument(content, `${name}/${fileName}`);
+        }
+    }
+    async function buildLikeC4Model(projectId) {
+        if (services.shared.workspace.LangiumDocuments.all.some(doc => doc.state < DocumentState.Validated)) {
+            await validateAll();
+        }
+        const likec4model = await services.likec4.ModelBuilder.computeModel(projectId);
+        if (!likec4model)
+            throw new Error('No model found');
+        return likec4model;
+    }
+    async function buildModel(projectId) {
+        const model = await buildLikeC4Model(projectId);
+        return model.$data;
+    }
+    return {
+        services,
+        projects,
+        projectsManager: services.shared.workspace.ProjectsManager,
+        addDocument: async (uri, input) => {
+            return await addDocument(input, uri.toString());
+        },
+        /**
+         * Add document outside of projects
+         */
+        addDocumentOutside: async (input) => {
+            return await addDocument(input);
+        },
+        validateAll,
+        buildModel,
+        buildLikeC4Model,
+    };
+}

package/dist/utils/disposable.js

@@ -0,0 +1,26 @@
+import { logWarnError } from '../logger';
+export class ADisposable {
+    toDispose = [];
+    isDisposed = false;
+    onDispose(...disposable) {
+        this.toDispose.push(...disposable);
+    }
+    dispose() {
+        this.throwIfDisposed();
+        this.isDisposed = true;
+        let item;
+        while ((item = this.toDispose.pop())) {
+            try {
+                item.dispose();
+            }
+            catch (e) {
+                logWarnError(e);
+            }
+        }
+    }
+    throwIfDisposed() {
+        if (this.isDisposed) {
+            throw new Error('This has already been disposed');
+        }
+    }
+}

package/dist/utils/elementRef.d.ts

@@ -3,7 +3,7 @@ import { ast } from '../ast';
 /**
  * Returns referenced AST Element
  */
-export declare function elementRef(node: ast.ElementRef | ast.StrictFqnElementRef): any;
+export declare function elementRef(node: ast.ElementRef | ast.StrictFqnElementRef): ast.Element | undefined;
 /**
  * Returns FQN of StrictFqnElementRef
  * a.b.c.d - for c node returns a.b.c

package/dist/utils/elementRef.js

@@ -0,0 +1,27 @@
+import { ast } from '../ast';
+/**
+ * Returns referenced AST Element
+ */
+export function elementRef(node) {
+    let el = ast.isStrictFqnElementRef(node) ? node.el.ref : node.modelElement.value.ref;
+    if (el?.$type === 'Imported') {
+        el = el.imported.ref;
+    }
+    return el?.$type === 'Element' ? el : undefined;
+}
+/**
+ * Returns FQN of StrictFqnElementRef
+ * a.b.c.d - for c node returns a.b.c
+ */
+export function readStrictFqn(node) {
+    const name = [node.$type === 'StrictFqnRef' ? node.value.$refText : node.el.$refText];
+    let parent = node.parent;
+    while (parent) {
+        name.push(parent.$type === 'StrictFqnRef' ? parent.value.$refText : parent.el.$refText);
+        parent = parent.parent;
+    }
+    if (name.length === 1) {
+        return name[0];
+    }
+    return name.reverse().join('.');
+}

package/dist/utils/fqnRef.js

@@ -0,0 +1,63 @@
+import { AstUtils } from 'langium';
+import { isNullish } from 'remeda';
+import { ast } from '../ast';
+export function referenceableParent(node) {
+    // iterate up the root parent
+    while (node.parent) {
+        node = node.parent;
+    }
+    return node.value.ref ?? null;
+}
+export function instanceRef(deploymentRef) {
+    let referenceable;
+    while ((referenceable = deploymentRef.value?.ref)) {
+        if (ast.isDeploymentNode(referenceable)) {
+            return null;
+        }
+        if (ast.isDeployedInstance(referenceable)) {
+            return referenceable;
+        }
+        if (isNullish(deploymentRef.parent)) {
+            return null;
+        }
+        deploymentRef = deploymentRef.parent;
+    }
+    return null;
+}
+export function deploymentNodeRef(deploymentRef) {
+    let referenceable = deploymentRef.value.ref ?? null;
+    if (!referenceable || ast.isDeploymentNode(referenceable)) {
+        return referenceable;
+    }
+    const artifact = instanceRef(deploymentRef);
+    // Because path in deploymentRef may be omitted,
+    // we find artifact first and then its container
+    return artifact ? AstUtils.getContainerOfType(artifact, ast.isDeploymentNode) ?? null : null;
+}
+export function importsRef(node) {
+    const referenceable = referenceableParent(node);
+    return referenceable?.$type === 'Imported' ? referenceable : null;
+}
+export function isImportsRef(node) {
+    return !!importsRef(node);
+}
+export function isReferenceToLogicalModel(node) {
+    const referenceable = referenceableParent(node);
+    return referenceable?.$type === 'Element';
+}
+/**
+ * Returns true if node references deployment model
+ */
+export function isReferenceToDeploymentModel(node) {
+    let referenceable;
+    while ((referenceable = node.value?.ref)) {
+        if (ast.isDeploymentElement(referenceable)) {
+            return true;
+        }
+        if (isNullish(node.parent)) {
+            return false;
+        }
+        node = node.parent;
+    }
+    return false;
+}

package/dist/utils/index.js

@@ -0,0 +1,35 @@
+import prettyMs from 'pretty-ms';
+import { logger } from '../logger';
+export * from './disposable';
+export * from './elementRef';
+export * from './fqnRef';
+export * from './projectId';
+export * from './stringHash';
+export function safeCall(fn) {
+    try {
+        return fn();
+    }
+    catch (e) {
+        logger.debug(`Safe call failed`, { error: e });
+        return undefined;
+    }
+}
+export function performanceNow() {
+    try {
+        return performance.now();
+    }
+    catch {
+        return Date.now();
+    }
+}
+export function performanceMark() {
+    const t0 = performanceNow();
+    return {
+        get ms() {
+            return performanceNow() - t0;
+        },
+        get pretty() {
+            return prettyMs(performanceNow() - t0);
+        },
+    };
+}

package/dist/utils/printDocs.js

@@ -0,0 +1 @@
+export const printDocs = (docs) => docs.map(d => '  - ' + d.uri.toString(true)).join('\n');

package/dist/utils/projectId.js

@@ -0,0 +1,16 @@
+import { invariant, nonNullable } from '@likec4/core';
+import { AstUtils, isAstNode } from 'langium';
+import { ast } from '../ast';
+export function projectIdFrom(value) {
+    if (ast.isImported(value)) {
+        while (value.$type === 'Imported' && value.$container) {
+            value = value.$container;
+        }
+        invariant(ast.isImportsFromPoject(value));
+    }
+    if (ast.isImportsFromPoject(value)) {
+        return value.project;
+    }
+    const doc = isAstNode(value) ? AstUtils.getDocument(value) : value;
+    return nonNullable(doc.likec4ProjectId, () => `Invalid state, document ${doc.uri} has no project ID assigned`);
+}

package/dist/utils/stringHash.js

@@ -0,0 +1,5 @@
+import { stringHash as hash } from '@likec4/core/utils';
+export function stringHash(...str) {
+    var s = str.length > 1 ? str.join(':::') : str[0];
+    return hash(s);
+}

package/dist/validation/DocumentValidator.js

@@ -0,0 +1,17 @@
+import { Cancellation, DefaultDocumentValidator } from 'langium';
+export class LikeC4DocumentValidator extends DefaultDocumentValidator {
+    services;
+    constructor(services) {
+        super(services);
+        this.services = services;
+    }
+    /**
+     * If the document is excluded, then we skip validation and return an empty array of diagnostics.
+     */
+    async validateDocument(document, options, cancelToken) {
+        if (this.services.shared.workspace.ProjectsManager.isExcluded(document)) {
+            return [];
+        }
+        return await super.validateDocument(document, options, cancelToken);
+    }
+}

package/dist/validation/_shared.js

@@ -0,0 +1,26 @@
+import { isPromise } from 'remeda';
+import { logger } from '../logger';
+export const RESERVED_WORDS = [
+    'this',
+    'it',
+    'self',
+    'super',
+    'likec4lib',
+    'global',
+];
+export function tryOrLog(fn) {
+    return async function tryOrLogFn(node, accept, cancelToken) {
+        try {
+            const result = fn(node, accept, cancelToken);
+            if (isPromise(result)) {
+                await result;
+            }
+            return;
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            accept('error', `Validation failed: ${message}`, { node });
+            logger.debug(`Validation failed: ${message}`, { error: e });
+        }
+    };
+}

package/dist/validation/deployment-checks.js

@@ -0,0 +1,140 @@
+import { FqnRef, isSameHierarchy, nonNullable } from '@likec4/core';
+import { loggable } from '@likec4/log';
+import { AstUtils } from 'langium';
+import { ast } from '../ast';
+import { logger } from '../logger';
+import { projectIdFrom } from '../utils';
+import { RESERVED_WORDS, tryOrLog } from './_shared';
+const { getDocument } = AstUtils;
+export const deploymentNodeChecks = (services) => {
+    const DeploymentsIndex = services.likec4.DeploymentsIndex;
+    const Names = services.references.NameProvider;
+    return tryOrLog((el, accept) => {
+        const nodeName = Names.getName(el);
+        if (!nodeName) {
+            accept('error', 'DeploymentNode must be named', {
+                node: el,
+            });
+            return;
+        }
+        const range = nonNullable(Names.getNameNode(el), 'name CstNode not found').range;
+        if (RESERVED_WORDS.includes(nodeName)) {
+            accept('error', `Reserved word: ${nodeName}`, {
+                node: el,
+                range,
+            });
+        }
+        const projectId = projectIdFrom(el);
+        const fqnName = DeploymentsIndex.getFqn(el);
+        const withSameName = DeploymentsIndex.byFqn(projectId, fqnName).limit(2).toArray();
+        if (withSameName.length > 1) {
+            accept('error', `Duplicate node name "${fqnName}"`, {
+                node: el,
+                range,
+            });
+        }
+    });
+};
+export const deployedInstanceChecks = (services) => {
+    const DeploymentsIndex = services.likec4.DeploymentsIndex;
+    const Names = services.references.NameProvider;
+    // const Locator = services.workspace.AstNodeLocator
+    return tryOrLog((el, accept) => {
+        const artifactName = Names.getName(el);
+        if (!artifactName) {
+            accept('error', 'Deployed instance must be named, unique inside node', {
+                node: el,
+            });
+            return;
+        }
+        const range = nonNullable(Names.getNameNode(el), 'name CstNode not found').range;
+        if (RESERVED_WORDS.includes(artifactName)) {
+            accept('error', `Reserved word: ${artifactName}`, {
+                node: el,
+                range,
+            });
+        }
+        const projectId = projectIdFrom(el);
+        const fqnName = DeploymentsIndex.getFqn(el);
+        const withSameName = DeploymentsIndex.byFqn(projectId, fqnName).limit(2).toArray();
+        if (withSameName.length > 1) {
+            accept('error', `Duplicate instance name "${fqnName}"`, {
+                node: el,
+                range,
+            });
+        }
+    });
+};
+export const deploymentRelationChecks = (services) => {
+    const ModelParser = services.likec4.ModelParser;
+    return tryOrLog((el, accept) => {
+        const target = el.target?.value?.ref;
+        if (!target) {
+            let targetCstText = el.target?.$cstNode?.text ?? '';
+            accept('error', `DeploymentRelation target '${targetCstText}' not resolved`, {
+                node: el,
+                property: 'target',
+            });
+            return;
+        }
+        const doc = getDocument(el);
+        const parser = ModelParser.forDocument(doc);
+        let sourceFqnRef;
+        try {
+            sourceFqnRef = parser._resolveDeploymentRelationSource(el);
+        }
+        catch (e) {
+            logger.warn(loggable(e));
+            accept('error', 'DeploymentRelation source not resolved', {
+                node: el,
+                property: 'source',
+            });
+            return;
+        }
+        if (FqnRef.isImportRef(sourceFqnRef)) {
+            accept('error', 'DeploymentRelation cannot refer imported model (not implemented yet)', {
+                node: el,
+                property: 'source',
+            });
+            return;
+        }
+        if (FqnRef.isModelRef(sourceFqnRef)) {
+            accept('error', 'DeploymentRelation must refer deployment element', {
+                node: el,
+                property: 'source',
+            });
+            return;
+        }
+        const targetFqnRef = parser.parseFqnRef(el.target);
+        if (FqnRef.isImportRef(targetFqnRef)) {
+            accept('error', 'DeploymentRelation cannot refer imported model (not implemented yet)', {
+                node: el,
+                property: 'target',
+            });
+            return;
+        }
+        if (FqnRef.isModelRef(targetFqnRef)) {
+            accept('error', 'DeploymentRelation must refer deployment element', {
+                node: el,
+                property: 'target',
+            });
+            return;
+        }
+        if (isSameHierarchy(sourceFqnRef.deployment, targetFqnRef.deployment)) {
+            accept('error', 'Invalid parent-child relationship', {
+                node: el,
+            });
+        }
+    });
+};
+export const extendDeploymentChecks = (_services) => {
+    return tryOrLog((el, accept) => {
+        const target = el.deploymentNode.value.ref;
+        if (!target || !ast.isDeploymentNode(target)) {
+            accept('error', 'ExtendDeployment allows only DeploymentNode', {
+                node: el,
+                property: 'deploymentNode',
+            });
+        }
+    });
+};