@likec4/language-server 1.18.0 → 1.19.1

package/dist/test/testServices.d.ts

@@ -0,0 +1,22 @@
+import type { LikeC4LangiumDocument } from '../ast';
+export declare function createTestServices(workspace?: string): {
+    services: any;
+    parse: (input: string, uri?: string) => Promise<LikeC4LangiumDocument>;
+    validate: (input: string | LikeC4LangiumDocument, uri?: string) => Promise<{
+        document: LikeC4LangiumDocument;
+        diagnostics: any[];
+        warnings: any[];
+        errors: any[];
+    }>;
+    validateAll: () => Promise<{
+        diagnostics: any;
+        errors: any;
+        warnings: any;
+    }>;
+    buildModel: () => Promise<any>;
+    resetState: () => Promise<void>;
+    format: (input: string | LikeC4LangiumDocument, uri?: string) => Promise<any>;
+};
+export type TestServices = ReturnType<typeof createTestServices>;
+export type TestParseFn = TestServices['validate'];
+export type TestValidateFn = TestServices['validate'];

package/dist/test/testServices.js

@@ -0,0 +1,119 @@
+import { DocumentState, EmptyFileSystem, TextDocument } from "langium";
+import * as assert from "node:assert";
+import stripIndent from "strip-indent";
+import { DiagnosticSeverity } from "vscode-languageserver-types";
+import { URI, Utils } from "vscode-uri";
+import { createLanguageServices } from "../module.js";
+export function createTestServices(workspace = "file:///test/workspace") {
+  const services = createLanguageServices(EmptyFileSystem).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: "test",
+    uri: workspaceUri.toString()
+  };
+  let isInitialized = false;
+  let documentIndex = 1;
+  const parse = async (input, uri) => {
+    if (!isInitialized) {
+      await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
+        if (isInitialized) {
+          return;
+        }
+        isInitialized = true;
+        services.shared.workspace.WorkspaceManager.initialize({
+          capabilities: {},
+          processId: null,
+          rootUri: null,
+          workspaceFolders: [workspaceFolder]
+        });
+        await services.shared.workspace.WorkspaceManager.initializeWorkspace([workspaceFolder]);
+      });
+    }
+    const docUri = Utils.resolvePath(
+      workspaceUri,
+      "./src/",
+      uri ?? `${documentIndex++}${metaData.fileExtensions[0]}`
+    );
+    const document = services.shared.workspace.LangiumDocumentFactory.fromString(
+      stripIndent(input),
+      docUri
+    );
+    langiumDocuments.addDocument(document);
+    await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
+      await documentBuilder.build([document], { validation: false });
+    });
+    return document;
+  };
+  const validate = async (input, uri) => {
+    const document = typeof input === "string" ? await parse(input, uri) : input;
+    await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
+      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(input, uri) : input;
+    await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
+      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 () => {
+    await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
+      const docs2 = langiumDocuments.all.toArray();
+      await documentBuilder.build(docs2, { validation: true });
+    });
+    await documentBuilder.waitUntil(DocumentState.Validated);
+    const docs = langiumDocuments.all.toArray();
+    assert.ok(docs.length > 0, "no documents to validate");
+    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 () => {
+    await validateAll();
+    const model = await modelBuilder.buildComputedModel();
+    if (!model) throw new Error("No model found");
+    return model;
+  };
+  const resetState = async () => {
+    await services.shared.workspace.WorkspaceLock.write(async (cancelToken) => {
+      const docs = langiumDocuments.all.toArray().map((doc) => doc.uri);
+      await documentBuilder.update([], docs, cancelToken);
+    });
+  };
+  return {
+    services,
+    parse,
+    validate,
+    validateAll,
+    buildModel,
+    resetState,
+    format
+  };
+}

package/dist/utils/elementRef.d.ts

@@ -0,0 +1,11 @@
+import type * as c4 from '@likec4/core';
+import type { ast } from '../ast';
+/**
+ * Returns referenced AST Element
+ */
+export declare function elementRef(node: ast.ElementRef | ast.FqnElementRef): any;
+/**
+ * Returns FQN of FqnElementRef
+ * a.b.c.d - for c node returns a.b.c
+ */
+export declare function getFqnElementRef(node: ast.FqnElementRef): c4.Fqn;

package/dist/utils/elementRef.js

@@ -0,0 +1,15 @@
+export function elementRef(node) {
+  return node.el.ref;
+}
+export function getFqnElementRef(node) {
+  const name = [node.el.$refText];
+  let parent = node.parent;
+  while (parent) {
+    name.push(parent.el.$refText);
+    parent = parent.parent;
+  }
+  if (name.length === 1) {
+    return name[0];
+  }
+  return name.reverse().join(".");
+}

package/dist/utils/fqnRef.d.ts

@@ -0,0 +1,8 @@
+import { ast } from '../ast';
+export declare function instanceRef(deploymentRef: ast.FqnRef): ast.DeployedInstance | null;
+export declare function deploymentNodeRef(deploymentRef: ast.FqnRef): ast.DeploymentNode | null;
+export declare function isReferenceToLogicalModel(node: ast.FqnRef): boolean;
+/**
+ * Returns true if node references deployment model
+ */
+export declare function isReferenceToDeploymentModel(node: ast.FqnRef): boolean;

package/dist/utils/fqnRef.js

@@ -0,0 +1,46 @@
+import { AstUtils } from "langium";
+import { isNullish } from "remeda";
+import { ast } from "../ast.js";
+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);
+  return artifact ? AstUtils.getContainerOfType(artifact, ast.isDeploymentNode) ?? null : null;
+}
+export function isReferenceToLogicalModel(node) {
+  while (node.parent) {
+    node = node.parent;
+  }
+  return ast.isElement(node.value.ref);
+}
+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.d.ts

@@ -0,0 +1 @@
+export * from './stringHash';

package/dist/utils/index.js

@@ -0,0 +1 @@
+export * from "./stringHash.js";

package/dist/utils/printDocs.d.ts

@@ -0,0 +1,2 @@
+import type { LangiumDocument } from 'langium';
+export declare const printDocs: (docs: LangiumDocument[]) => string;

package/dist/utils/printDocs.js

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

package/dist/utils/stringHash.d.ts

@@ -0,0 +1 @@
+export declare function stringHash(...str: [string, ...string[]]): string;

package/dist/utils/stringHash.js

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

package/dist/validation/_shared.d.ts

@@ -0,0 +1,3 @@
+import { type AstNode, type ValidationCheck } from 'langium';
+export declare const RESERVED_WORDS: string[];
+export declare function tryOrLog<T extends AstNode>(fn: ValidationCheck<T>): ValidationCheck<T>;

package/dist/validation/_shared.js

@@ -0,0 +1,22 @@
+import { isPromise } from "remeda";
+import { logWarnError } from "../logger.js";
+export const RESERVED_WORDS = [
+  "this",
+  "it",
+  "self",
+  "super",
+  "likec4lib",
+  "global"
+];
+export function tryOrLog(fn) {
+  return async (node, accept, cancelToken) => {
+    try {
+      const result = fn(node, accept, cancelToken);
+      if (isPromise(result)) {
+        await result;
+      }
+    } catch (e) {
+      logWarnError(e);
+    }
+  };
+}

package/dist/validation/deployment-checks.d.ts

@@ -0,0 +1,6 @@
+import { type ValidationCheck } from 'langium';
+import { ast } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare const deploymentNodeChecks: (services: LikeC4Services) => ValidationCheck<ast.DeploymentNode>;
+export declare const deployedInstanceChecks: (services: LikeC4Services) => ValidationCheck<ast.DeployedInstance>;
+export declare const deploymentRelationChecks: (services: LikeC4Services) => ValidationCheck<ast.DeploymentRelation>;

package/dist/validation/deployment-checks.js

@@ -0,0 +1,114 @@
+import { FqnRef, isSameHierarchy, nonNullable } from "@likec4/core";
+import { AstUtils } from "langium";
+import { RESERVED_WORDS, tryOrLog } from "./_shared.js";
+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 fqnName = DeploymentsIndex.getFqn(el);
+    const withSameName = DeploymentsIndex.byFqn(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;
+  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 fqnName = DeploymentsIndex.getFqn(el);
+    const withSameName = DeploymentsIndex.byFqn(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 source = el.source?.value?.ref;
+    if (!source) {
+      let sourceCstText = el.source?.$cstNode?.text ?? "";
+      accept("error", `DeploymentRelation source '${sourceCstText}' not resolved`, {
+        node: el,
+        property: "source"
+      });
+      return;
+    }
+    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);
+    const sourceFqnRef = parser.parseFqnRef(el.source);
+    if (FqnRef.isModelRef(sourceFqnRef)) {
+      accept("error", "DeploymentRelation must refer deployment element", {
+        node: el,
+        property: "source"
+      });
+      return;
+    }
+    const targetFqnRef = parser.parseFqnRef(el.target);
+    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
+      });
+    }
+  });
+};

package/dist/validation/dynamic-view-rule.d.ts

@@ -0,0 +1,4 @@
+import type { ValidationCheck } from 'langium';
+import { ast } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare const dynamicViewRulePredicate: (_services: LikeC4Services) => ValidationCheck<ast.DynamicViewPredicateIterator>;

package/dist/validation/dynamic-view-rule.js

@@ -0,0 +1,17 @@
+import { ast, elementExpressionFromPredicate } from "../ast.js";
+import { tryOrLog } from "./_shared.js";
+export const dynamicViewRulePredicate = (_services) => {
+  return tryOrLog((predicate, accept) => {
+    const expr = elementExpressionFromPredicate(predicate.value);
+    switch (true) {
+      case ast.isElementKindExpression(expr):
+      case ast.isElementTagExpression(expr):
+      case ast.isWildcardExpression(expr): {
+        accept("warning", `Predicate is ignored, as not supported in dynamic views`, {
+          node: predicate
+        });
+        return;
+      }
+    }
+  });
+};

package/dist/validation/dynamic-view-step.d.ts

@@ -0,0 +1,4 @@
+import type { ValidationCheck } from 'langium';
+import { ast } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare const dynamicViewStep: (services: LikeC4Services) => ValidationCheck<ast.DynamicViewStep>;

package/dist/validation/dynamic-view-step.js

@@ -0,0 +1,29 @@
+import { isAncestor } from "@likec4/core";
+import { elementRef } from "../utils/elementRef.js";
+import { tryOrLog } from "./_shared.js";
+export const dynamicViewStep = (services) => {
+  const fqnIndex = services.likec4.FqnIndex;
+  return tryOrLog((el, accept) => {
+    const sourceEl = elementRef(el.source);
+    const source = sourceEl && fqnIndex.getFqn(sourceEl);
+    if (!source) {
+      accept("error", "Source not found (not parsed/indexed yet)", {
+        node: el,
+        property: "source"
+      });
+    }
+    const targetEl = elementRef(el.target);
+    const target = targetEl && fqnIndex.getFqn(targetEl);
+    if (!target) {
+      accept("error", "Target not found (not parsed/indexed yet)", {
+        node: el,
+        property: "target"
+      });
+    }
+    if (source && target && (isAncestor(source, target) || isAncestor(target, source))) {
+      accept("error", "Invalid parent-child relationship", {
+        node: el
+      });
+    }
+  });
+};

package/dist/validation/element.d.ts

@@ -0,0 +1,4 @@
+import { type ValidationCheck } from 'langium';
+import type { ast } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare const elementChecks: (services: LikeC4Services) => ValidationCheck<ast.Element>;

package/dist/validation/element.js

@@ -0,0 +1,49 @@
+import { AstUtils } from "langium";
+import { RESERVED_WORDS, tryOrLog } from "./_shared.js";
+const { getDocument } = AstUtils;
+export const elementChecks = (services) => {
+  const fqnIndex = services.likec4.FqnIndex;
+  const locator = services.workspace.AstNodeLocator;
+  return tryOrLog((el, accept) => {
+    const fqn = fqnIndex.getFqn(el);
+    if (!fqn) {
+      accept("error", "Not indexed element", {
+        node: el,
+        property: "name"
+      });
+      return;
+    }
+    if (RESERVED_WORDS.includes(el.name)) {
+      accept("error", `Reserved word: ${el.name}`, {
+        node: el,
+        property: "name"
+      });
+    }
+    const doc = getDocument(el);
+    const docUri = doc.uri;
+    const elPath = locator.getAstNodePath(el);
+    const withSameFqn = fqnIndex.byFqn(fqn).filter((v) => v.documentUri !== docUri || v.path !== elPath).head();
+    if (withSameFqn) {
+      const isAnotherDoc = withSameFqn.documentUri !== docUri;
+      accept(
+        "error",
+        `Duplicate element name ${el.name !== fqn ? el.name + " (" + fqn + ")" : el.name}`,
+        {
+          node: el,
+          property: "name",
+          ...isAnotherDoc && {
+            relatedInformation: [
+              {
+                location: {
+                  range: withSameFqn.nameSegment?.range ?? withSameFqn.selectionSegment?.range,
+                  uri: withSameFqn.documentUri.toString()
+                },
+                message: `conflicting element`
+              }
+            ]
+          }
+        }
+      );
+    }
+  });
+};

package/dist/validation/index.d.ts

@@ -0,0 +1,15 @@
+import type { AstNode } from 'langium';
+import { type LikeC4LangiumDocument, ast } from '../ast';
+import type { LikeC4Services } from '../module';
+type Guard<N extends AstNode> = (n: AstNode) => n is N;
+type Guarded<G> = G extends Guard<infer N> ? N : never;
+declare const isValidatableAstNode: (n: AstNode) => n is ast.DeployedInstance | ast.DeploymentNode | ast.DeploymentViewRulePredicate | ast.DeploymentViewRuleStyle | ast.ViewRuleAutoLayout | ast.DynamicViewGlobalPredicateRef | ast.DynamicViewIncludePredicate | ast.ViewRuleGlobalStyle | ast.ViewRuleStyle | ast.ElementDescedantsExpression | ast.ElementKindExpression | ast.ElementRef | ast.ElementTagExpression | ast.ExpandElementExpression | ast.WildcardExpression | ast.ElementPredicateWhere | ast.ElementPredicateWith | ast.ElementStringProperty | ast.ElementStyleProperty | ast.IconProperty | ast.LinkProperty | ast.MetadataBody | ast.FqnRefExpr | ast.DirectedRelationExpr | ast.InOutRelationExpr | ast.IncomingRelationExpr | ast.OutgoingRelationExpr | ast.Element | ast.ExtendElement | ast.DeploymentView | ast.DynamicView | ast.ElementView | ast.DirectedRelationExpression | ast.InOutRelationExpression | ast.IncomingRelationExpression | ast.OutgoingRelationExpression | ast.RelationPredicateWhere | ast.RelationPredicateWith | ast.RelationStringProperty | ast.ArrowProperty | ast.ColorProperty | ast.LineProperty | ast.MetadataAttribute | ast.NotationProperty | ast.NotesProperty | ast.SpecificationElementStringProperty | ast.SpecificationRelationshipStringProperty | ast.ViewStringProperty | ast.BorderProperty | ast.OpacityProperty | ast.ShapeProperty | ast.ViewRuleGlobalPredicateRef | ast.ViewRuleGroup | ast.ExcludePredicate | ast.IncludePredicate | ast.SpecificationRelationshipKind | ast.GlobalStyle | ast.SpecificationColor | ast.NavigateToProperty | ast.DynamicViewStep | ast.Tags | ast.DeploymentRelation | ast.SpecificationDeploymentNodeKind | ast.DynamicViewParallelSteps | ast.GlobalDynamicPredicateGroup | ast.DynamicViewPredicateIterator | ast.Relation | ast.SpecificationElementKind | ast.GlobalPredicateGroup | ast.Globals | ast.GlobalStyleGroup | ast.SpecificationRule | ast.SpecificationTag;
+type ValidatableAstNode = Guarded<typeof isValidatableAstNode>;
+export declare function checksFromDiagnostics(doc: LikeC4LangiumDocument): {
+    isValid: (n: ValidatableAstNode) => boolean;
+    invalidNodes: WeakSet<object>;
+};
+export type ChecksFromDiagnostics = ReturnType<typeof checksFromDiagnostics>;
+export type IsValidFn = ChecksFromDiagnostics['isValid'];
+export declare function registerValidationChecks(services: LikeC4Services): void;
+export {};