@likec4/language-server 1.43.0 → 1.44.0

package/dist/validation/dynamic-view.js

@@ -0,0 +1,67 @@
+import { isAncestor } from '@likec4/core';
+import { AstUtils } from 'langium';
+import { isEmpty } from 'remeda';
+import { ast } from '../ast';
+import { elementRef } from '../utils/elementRef';
+import { tryOrLog } from './_shared';
+export const dynamicViewStepSingle = (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,
+            });
+        }
+    });
+};
+export const dynamicViewStepChain = (services) => {
+    const fqnIndex = services.likec4.FqnIndex;
+    return tryOrLog((el, accept) => {
+        const source = el.source;
+        if (ast.isDynamicStepSingle(source) && source.isBackward) {
+            accept('error', 'Invalid chain after backward step', {
+                node: el,
+            });
+        }
+        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',
+            });
+        }
+    });
+};
+export const dynamicViewDisplayVariant = (_services) => {
+    return tryOrLog((prop, accept) => {
+        if (isEmpty(prop.value) || (prop.value !== 'diagram' && prop.value !== 'sequence')) {
+            accept('error', 'Invalid display variant: "diagram" or "sequence" are allowed', {
+                node: prop,
+                property: 'value',
+            });
+            return;
+        }
+        if (!AstUtils.hasContainerOfType(prop, ast.isDynamicViewBody)) {
+            accept('error', `Display mode can be defined only inside dynamic view`, {
+                node: prop,
+            });
+        }
+    });
+};

package/dist/validation/element-ref.js

@@ -0,0 +1,12 @@
+import { isReferenceToDeploymentModel } from '../utils';
+import { tryOrLog } from './_shared';
+export const checkElementRef = (_services) => {
+    return tryOrLog((el, accept) => {
+        if (isReferenceToDeploymentModel(el.modelElement)) {
+            accept('error', 'Only model elements allowed here', {
+                node: el,
+                property: 'modelElement',
+            });
+        }
+    });
+};

package/dist/validation/element.js

@@ -0,0 +1,49 @@
+import { AstUtils } from 'langium';
+import { projectIdFrom } from '../utils';
+import { RESERVED_WORDS, tryOrLog } from './_shared';
+const { getDocument } = AstUtils;
+export const checkElement = (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(projectIdFrom(doc), 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/imports.js

@@ -0,0 +1,46 @@
+import { AstUtils } from 'langium';
+import { projectIdFrom } from '../utils';
+import { tryOrLog } from './_shared';
+const { getDocument } = AstUtils;
+export const checkImportsFromPoject = (services) => {
+    const projects = services.shared.workspace.ProjectsManager;
+    return tryOrLog((el, accept) => {
+        const doc = getDocument(el);
+        const projectId = projectIdFrom(doc);
+        if (el.project === projectId) {
+            accept('error', 'Imported project cannot be the same as the current project', {
+                node: el,
+                property: 'project',
+            });
+            return;
+        }
+        if (!projects.all.includes(el.project)) {
+            accept('error', 'Imported project not found', {
+                node: el,
+                property: 'project',
+            });
+            return;
+        }
+    });
+};
+// export const checkImported = (services: LikeC4Services): ValidationCheck<ast.Imported> => {
+//   const fqnIndex = services.likec4.FqnIndex
+//   const projects = services.shared.workspace.ProjectsManager
+//   return tryOrLog((el, accept) => {
+//     const doc = getDocument(el)
+//     const importFromProject = el.$container.project as ProjectId
+//     if (importFromProject === projectId || !projects.all.includes(importFromProject)) {
+//       accept('error', 'Invalid import', {
+//         node: el,
+//       })
+//       return
+//     }
+//     const fqn = fqnIndex.byFqn(importFromProject, el.element.$refText as Fqn).head()
+//     if (!fqn) {
+//       accept('error', `Imported element not found in project "${importFromProject}"`, {
+//         node: el,
+//       })
+//       return
+//     }
+//   })
+// }

package/dist/validation/index.d.ts

@@ -4,7 +4,7 @@ import type { LikeC4Services } from '../module';
 export { LikeC4DocumentValidator } from './DocumentValidator';
 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.DynamicViewDisplayVariantProperty | ast.LinkProperty | ast.ViewStringProperty | ast.ElementStringProperty | ast.ElementStyleProperty | ast.IconProperty | ast.MetadataBody | ast.RelationStringProperty | ast.MetadataAttribute | ast.NotationProperty | ast.NotesProperty | ast.SpecificationElementStringProperty | ast.SpecificationRelationshipStringProperty | ast.HexColor | ast.RGBAColor | ast.DeployedInstance | ast.DeploymentNode | ast.DeploymentViewRulePredicate | ast.DeploymentViewRuleStyle | ast.ViewRuleAutoLayout | ast.DynamicViewGlobalPredicateRef | ast.DynamicViewIncludePredicate | ast.ViewRuleGlobalStyle | ast.ViewRuleStyle | ast.DynamicStepChain | ast.DynamicStepSingle | ast.ElementKindExpression | ast.ElementTagExpression | ast.FqnRefExpr | ast.WildcardExpression | ast.FqnExprWhere | ast.FqnExprWith | ast.DirectedRelationExpr | ast.InOutRelationExpr | ast.IncomingRelationExpr | ast.OutgoingRelationExpr | ast.RelationExprWhere | ast.RelationExprWith | ast.Element | ast.ExtendDeployment | ast.ExtendElement | ast.Imported | ast.DeploymentView | ast.DynamicView | ast.ElementView | ast.ArrowProperty | ast.ColorProperty | ast.LineProperty | ast.PaddingSizeProperty | ast.ShapeSizeProperty | ast.TextSizeProperty | ast.BorderProperty | ast.MultipleProperty | ast.OpacityProperty | ast.ShapeProperty | ast.ViewRuleGlobalPredicateRef | ast.ViewRuleGroup | ast.ViewRulePredicate | ast.DynamicViewParallelSteps | ast.ElementRef | ast.SpecificationRelationshipKind | ast.GlobalStyle | ast.SpecificationColor | ast.NavigateToProperty | ast.DeploymentRelation | ast.Tags | ast.SpecificationDeploymentNodeKind | ast.GlobalDynamicPredicateGroup | ast.Relation | ast.SpecificationElementKind | ast.Globals | ast.GlobalPredicateGroup | ast.GlobalStyleGroup | ast.SpecificationTag | ast.ImportsFromPoject | ast.SpecificationRule;
+declare const isValidatableAstNode: (n: AstNode) => n is ast.DynamicViewDisplayVariantProperty | ast.LinkProperty | ast.ViewStringProperty | ast.ElementStringProperty | ast.ElementStyleProperty | ast.IconProperty | ast.MetadataBody | ast.RelationStringProperty | ast.MetadataAttribute | ast.NotationProperty | ast.NotesProperty | ast.SpecificationElementStringProperty | ast.SpecificationRelationshipStringProperty | ast.HexColor | ast.RGBAColor | ast.DeployedInstance | ast.DeploymentNode | ast.DeploymentViewRulePredicate | ast.DeploymentViewRuleStyle | ast.ViewRuleAutoLayout | ast.DynamicViewGlobalPredicateRef | ast.DynamicViewIncludePredicate | ast.ViewRuleGlobalStyle | ast.ViewRuleStyle | ast.DynamicStepChain | ast.DynamicStepSingle | ast.ElementKindExpression | ast.ElementTagExpression | ast.FqnRefExpr | ast.WildcardExpression | ast.FqnExprWhere | ast.FqnExprWith | ast.DirectedRelationExpr | ast.InOutRelationExpr | ast.IncomingRelationExpr | ast.OutgoingRelationExpr | ast.RelationExprWhere | ast.RelationExprWith | ast.Element | ast.ExtendDeployment | ast.ExtendElement | ast.Imported | ast.DeploymentView | ast.DynamicView | ast.ElementView | ast.ArrowProperty | ast.ColorProperty | ast.LineProperty | ast.PaddingSizeProperty | ast.ShapeSizeProperty | ast.TextSizeProperty | ast.BorderProperty | ast.MultipleProperty | ast.OpacityProperty | ast.ShapeProperty | ast.ViewRuleGlobalPredicateRef | ast.ViewRuleGroup | ast.ViewRulePredicate | ast.DynamicViewParallelSteps | ast.SpecificationRelationshipKind | ast.SpecificationRule | ast.ElementRef | ast.DeploymentRelation | ast.Relation | ast.GlobalDynamicPredicateGroup | ast.Globals | ast.GlobalPredicateGroup | ast.GlobalStyle | ast.SpecificationDeploymentNodeKind | ast.SpecificationElementKind | ast.GlobalStyleGroup | ast.SpecificationColor | ast.NavigateToProperty | ast.Tags | ast.ImportsFromPoject | ast.SpecificationTag;
 type ValidatableAstNode = Guarded<typeof isValidatableAstNode>;
 export declare function checksFromDiagnostics(doc: LikeC4LangiumDocument): {
     isValid: (n: ValidatableAstNode) => boolean;

package/dist/validation/index.js

@@ -0,0 +1,157 @@
+import { onNextTick } from '@likec4/core/utils';
+import { loggable } from '@likec4/log';
+import { DocumentState } from 'langium';
+import { isNullish } from 'remeda';
+import { DiagnosticSeverity } from 'vscode-languageserver-types';
+import { ast } from '../ast';
+import { logger } from '../logger';
+import { deployedInstanceChecks, deploymentNodeChecks, deploymentRelationChecks, extendDeploymentChecks, } from './deployment-checks';
+import { dynamicViewDisplayVariant, dynamicViewStepChain, dynamicViewStepSingle } from './dynamic-view';
+import { checkElement } from './element';
+import { checkElementRef } from './element-ref';
+import { checkImportsFromPoject } from './imports';
+import { colorLiteralRuleChecks, iconPropertyRuleChecks, notesPropertyRuleChecks, opacityPropertyRuleChecks, } from './property-checks';
+import { checkRelationBody, relationChecks } from './relation';
+import { checkDeploymentNodeKind, checkElementKind, checkGlobalPredicate, checkGlobals, checkGlobalStyleId, checkModel, checkRelationshipKind, checkSpecificationRule, checkTag, } from './specification';
+import { viewChecks } from './view';
+import { checkFqnExprWith, checkFqnRefExpr, checkIncomingRelationExpr, checkOutgoingRelationExpr, checkRelationExpr, checkRelationExprWith, } from './view-predicates';
+export { LikeC4DocumentValidator } from './DocumentValidator';
+function validatableAstNodeGuards(predicates) {
+    return (n) => predicates.some(p => p(n));
+}
+const isValidatableAstNode = validatableAstNodeGuards([
+    ast.isImportsFromPoject,
+    ast.isImported,
+    ast.isGlobals,
+    ast.isGlobalPredicateGroup,
+    ast.isGlobalDynamicPredicateGroup,
+    ast.isGlobalStyle,
+    ast.isGlobalStyleGroup,
+    ast.isFqnExprWith,
+    ast.isRelationExprWith,
+    ast.isFqnExpr,
+    ast.isRelationExpr,
+    ast.isDynamicViewParallelSteps,
+    ast.isDynamicStepChain,
+    ast.isDynamicStepSingle,
+    ast.isDeploymentViewRule,
+    ast.isDeploymentViewRulePredicate,
+    ast.isExpressionV2,
+    ast.isRelationExpr,
+    ast.isFqnRefExpr,
+    ast.isViewProperty,
+    ast.isStyleProperty,
+    ast.isTags,
+    ast.isViewRule,
+    ast.isDynamicViewRule,
+    ast.isLikeC4View,
+    ast.isViewRuleStyleOrGlobalRef,
+    ast.isDeployedInstance,
+    ast.isDeploymentNode,
+    ast.isDeploymentRelation,
+    ast.isRelationshipStyleProperty,
+    ast.isDynamicViewDisplayVariantProperty,
+    ast.isMetadataProperty,
+    ast.isRelation,
+    ast.isElementProperty,
+    ast.isStringProperty,
+    ast.isNavigateToProperty,
+    ast.isElement,
+    ast.isElementRef,
+    ast.isExtendElement,
+    ast.isExtendDeployment,
+    ast.isSpecificationElementKind,
+    ast.isSpecificationRelationshipKind,
+    ast.isSpecificationDeploymentNodeKind,
+    ast.isSpecificationTag,
+    ast.isSpecificationColor,
+    ast.isSpecificationRule,
+    ast.isColorLiteral,
+]);
+const findInvalidContainer = (node) => {
+    let nd = node;
+    while (nd && !ast.isLikeC4Grammar(nd)) {
+        if (isValidatableAstNode(nd)) {
+            return nd;
+        }
+        nd = nd.$container;
+    }
+    return undefined;
+};
+export function checksFromDiagnostics(doc) {
+    const errors = doc.state >= DocumentState.Validated
+        ? (doc.diagnostics?.filter(d => d.severity === DiagnosticSeverity.Error) ?? [])
+        : [];
+    const invalidNodes = new WeakSet();
+    for (const { node } of errors) {
+        if (isNullish(node) || invalidNodes.has(node)) {
+            continue;
+        }
+        invalidNodes.add(node);
+        const container = findInvalidContainer(node);
+        if (container) {
+            invalidNodes.add(container);
+        }
+    }
+    const isValid = (n) => !invalidNodes.has(n);
+    return {
+        isValid,
+        invalidNodes,
+    };
+}
+export function registerValidationChecks(services) {
+    logger.debug('registerValidationChecks');
+    const registry = services.validation.ValidationRegistry;
+    registry.register({
+        DeployedInstance: deployedInstanceChecks(services),
+        DeploymentNodeKind: checkDeploymentNodeKind(services),
+        DeploymentNode: deploymentNodeChecks(services),
+        DeploymentRelation: deploymentRelationChecks(services),
+        ExtendDeployment: extendDeploymentChecks(services),
+        FqnRefExpr: checkFqnRefExpr(services),
+        RelationExpr: checkRelationExpr(services),
+        NotesProperty: notesPropertyRuleChecks(services),
+        OpacityProperty: opacityPropertyRuleChecks(services),
+        IconProperty: iconPropertyRuleChecks(services),
+        SpecificationRule: checkSpecificationRule(services),
+        Model: checkModel(services),
+        Globals: checkGlobals(services),
+        GlobalPredicateGroup: checkGlobalPredicate(services),
+        GlobalDynamicPredicateGroup: checkGlobalPredicate(services),
+        GlobalStyleId: checkGlobalStyleId(services),
+        DynamicStepSingle: dynamicViewStepSingle(services),
+        DynamicStepChain: dynamicViewStepChain(services),
+        LikeC4View: viewChecks(services),
+        Element: checkElement(services),
+        ElementRef: checkElementRef(services),
+        ElementKind: checkElementKind(services),
+        Relation: relationChecks(services),
+        RelationBody: checkRelationBody(services),
+        Tag: checkTag(services),
+        FqnExprWith: checkFqnExprWith(services),
+        RelationExprWith: checkRelationExprWith(services),
+        RelationshipKind: checkRelationshipKind(services),
+        IncomingRelationExpr: checkIncomingRelationExpr(services),
+        OutgoingRelationExpr: checkOutgoingRelationExpr(services),
+        ImportsFromPoject: checkImportsFromPoject(services),
+        // Imported: checkImported(services),
+        ColorLiteral: colorLiteralRuleChecks(services),
+        DynamicViewDisplayVariantProperty: dynamicViewDisplayVariant(services),
+    });
+    const connection = services.shared.lsp.Connection;
+    if (connection) {
+        // delay initialization
+        onNextTick(() => {
+            // workaround for bug in langium
+            services.shared.workspace.DocumentBuilder.onUpdate((_, deleted) => {
+                for (const uri of deleted) {
+                    logger.debug(`clear diagnostics for deleted ${uri.path}`);
+                    connection.sendDiagnostics({
+                        uri: uri.toString(),
+                        diagnostics: [],
+                    }).catch(e => logger.error(loggable(e)));
+                }
+            });
+        });
+    }
+}

package/dist/validation/property-checks.js

@@ -0,0 +1,108 @@
+import { nonexhaustive } from '@likec4/core';
+import { AstUtils } from 'langium';
+import { isNumber, isString } from 'remeda';
+import { ast } from '../ast';
+import { tryOrLog } from './_shared';
+export const opacityPropertyRuleChecks = (_) => {
+    return tryOrLog((node, accept) => {
+        const opacity = parseFloat(node.value);
+        if (isNaN(opacity) || opacity < 0 || opacity > 100) {
+            accept('warning', `Value ignored, must be between 0% and 100%`, {
+                node,
+                property: 'value',
+            });
+        }
+    });
+};
+export const iconPropertyRuleChecks = (_) => {
+    return (node, accept) => {
+        const container = node.$container;
+        const anotherIcon = container.props.some(p => ast.isIconProperty(p) && p !== node);
+        if (anotherIcon) {
+            accept('error', `Icon must be defined once`, {
+                node,
+            });
+        }
+        if (ast.isElementStyleProperty(container) && ast.isElementBody(container.$container)
+            && container.$container.props.some(p => ast.isIconProperty(p))) {
+            accept('warning', `Redundant as icon defined on element`, {
+                node,
+            });
+        }
+        if (node.value?.startsWith('file://')) {
+            accept('error', `Icon URI must not start with file://`, {
+                node,
+                property: 'value',
+            });
+        }
+    };
+};
+export const notesPropertyRuleChecks = (_) => {
+    return (node, accept) => {
+        if (!AstUtils.hasContainerOfType(node, ast.isDynamicViewStep)) {
+            accept('error', `Notes can be defined only inside dynamic view`, {
+                node,
+            });
+        }
+    };
+};
+export const colorLiteralRuleChecks = (_) => {
+    return (node, accept) => {
+        if (node.$type === 'HexColor') {
+            if (node.hex === undefined || (isString(node.hex) && !node.hex.match(/^[a-fA-F0-9]+$/))) {
+                accept('error', `Invalid HEX`, {
+                    node,
+                    property: 'hex',
+                });
+                return;
+            }
+            const length = isNumber(node.hex) ? node.hex.toString().length : node.hex.length;
+            if (length !== 6 && length !== 3 && length !== 8) {
+                accept('error', `Invalid value "${node.$cstNode?.text}", must be 3, 6 or 8 characters long`, {
+                    node,
+                    property: 'hex',
+                });
+            }
+            return;
+        }
+        if (node.$type === 'RGBAColor') {
+            if (!isNumber(node.red) || node.red < 0 || node.red > 255) {
+                accept('error', `Invalid value, must be between 0 and 255`, {
+                    node,
+                    property: 'red',
+                });
+            }
+            if (!isNumber(node.green) || node.green < 0 || node.green > 255) {
+                accept('error', `Invalid value, must be between 0 and 255`, {
+                    node,
+                    property: 'green',
+                });
+            }
+            if (!isNumber(node.blue) || node.blue < 0 || node.blue > 255) {
+                accept('error', `Invalid value, must be between 0 and 255`, {
+                    node,
+                    property: 'blue',
+                });
+            }
+            if (isNumber(node.alpha)) {
+                if (node.alpha < 0 || node.alpha > 1) {
+                    accept('error', `Invalid value, must be between 0 and 1`, {
+                        node,
+                        property: 'alpha',
+                    });
+                }
+            }
+            if (isString(node.alpha)) {
+                const alpha = parseFloat(node.alpha);
+                if (alpha < 0 || alpha > 100) {
+                    accept('error', `Invalid value, must be between 0% and 100%`, {
+                        node,
+                        property: 'alpha',
+                    });
+                }
+            }
+            return;
+        }
+        nonexhaustive(node);
+    };
+};

package/dist/validation/relation.js

@@ -0,0 +1,55 @@
+import { FqnRef, isSameHierarchy } from '@likec4/core';
+import { AstUtils } from 'langium';
+import { ast } from '../ast';
+import { safeCall } from '../utils';
+import { tryOrLog } from './_shared';
+export const relationChecks = (services) => {
+    const modelParser = services.likec4.ModelParser;
+    return tryOrLog((el, accept) => {
+        const parser = modelParser.forDocument(AstUtils.getDocument(el));
+        const source = safeCall(() => parser._resolveRelationSource(el));
+        if (!source) {
+            accept('error', 'Source not resolved', {
+                node: el,
+                property: 'source',
+            });
+            return;
+        }
+        const target = safeCall(() => parser.parseFqnRef(el.target));
+        if (!target) {
+            accept('error', 'Target not resolved', {
+                node: el,
+                property: 'target',
+            });
+            return;
+        }
+        if (FqnRef.isImportRef(source)) {
+            if (FqnRef.isImportRef(target)) {
+                accept('warning', 'Relationship between imported elements may not be visible in origin projects', {
+                    node: el,
+                });
+            }
+            else {
+                accept('warning', 'Relationship from imported element to local element may not be visible in origin project', {
+                    node: el,
+                    property: 'source',
+                });
+            }
+        }
+        if (isSameHierarchy(FqnRef.flatten(source), FqnRef.flatten(target))) {
+            accept('error', 'Invalid parent-child relationship', {
+                node: el,
+            });
+        }
+    });
+};
+export const checkRelationBody = (_services) => {
+    return tryOrLog((body, accept) => {
+        const relation = body.$container;
+        if (relation.tags?.values && body.tags?.values) {
+            accept('error', 'Relation cannot have tags in both header and body', {
+                node: body.tags,
+            });
+        }
+    });
+};