@likec4/language-server 1.27.2 → 1.28.0

package/dist/validation/index.js

@@ -9,46 +9,47 @@ import {
   deploymentRelationChecks,
   extendDeploymentChecks
 } from "./deployment-checks.js";
-import { dynamicViewRulePredicate } from "./dynamic-view-rule.js";
 import { dynamicViewStep } from "./dynamic-view-step.js";
-import { elementChecks } from "./element.js";
+import { checkElement } from "./element.js";
+import { checkElementRef } from "./element-ref.js";
+import { checkImported, checkImportsFromPoject } from "./imports.js";
 import { iconPropertyRuleChecks, notesPropertyRuleChecks, opacityPropertyRuleChecks } from "./property-checks.js";
-import { relationBodyChecks, relationChecks } from "./relation.js";
+import { checkRelationBody, relationChecks } from "./relation.js";
 import {
-  deploymentNodeKindChecks,
-  elementKindChecks,
-  globalPredicateChecks,
-  globalsChecks,
-  globalStyleIdChecks,
-  modelRuleChecks,
-  relationshipChecks,
-  specificationRuleChecks,
-  tagChecks
+  checkDeploymentNodeKind,
+  checkElementKind,
+  checkGlobalPredicate,
+  checkGlobals,
+  checkGlobalStyleId,
+  checkModel,
+  checkRelationshipKind,
+  checkSpecificationRule,
+  checkTag
 } from "./specification.js";
 import { viewChecks } from "./view.js";
 import {
-  elementPredicateWithChecks,
-  expandElementExprChecks,
-  fqnRefExprChecks,
-  incomingExpressionChecks,
-  outgoingExpressionChecks,
-  relationExprChecks,
-  relationPredicateWithChecks
+  checkFqnExprWith,
+  checkFqnRefExpr,
+  checkIncomingRelationExpr,
+  checkOutgoingRelationExpr,
+  checkRelationExpr,
+  checkRelationExprWith
 } from "./view-predicates/index.js";
 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.isDynamicViewPredicateIterator,
-  ast.isElementPredicateWith,
-  ast.isRelationPredicateWith,
-  ast.isElementExpression,
-  ast.isRelationExpression,
+  ast.isFqnExprWith,
+  ast.isRelationExprWith,
+  ast.isFqnExpr,
+  ast.isRelationExpr,
   ast.isDynamicViewParallelSteps,
   ast.isDynamicViewStep,
   ast.isDeploymentViewRule,
@@ -58,7 +59,6 @@ const isValidatableAstNode = validatableAstNodeGuards([
   ast.isFqnRefExpr,
   ast.isViewProperty,
   ast.isStyleProperty,
-  ast.isPredicate,
   ast.isTags,
   ast.isViewRule,
   ast.isDynamicViewRule,
@@ -74,6 +74,7 @@ const isValidatableAstNode = validatableAstNodeGuards([
   ast.isStringProperty,
   ast.isNavigateToProperty,
   ast.isElement,
+  ast.isElementRef,
   ast.isExtendElement,
   ast.isExtendDeployment,
   ast.isSpecificationElementKind,
@@ -117,35 +118,36 @@ export function registerValidationChecks(services) {
   const registry = services.validation.ValidationRegistry;
   registry.register({
     DeployedInstance: deployedInstanceChecks(services),
-    DeploymentNodeKind: deploymentNodeKindChecks(services),
+    DeploymentNodeKind: checkDeploymentNodeKind(services),
     DeploymentNode: deploymentNodeChecks(services),
     DeploymentRelation: deploymentRelationChecks(services),
     ExtendDeployment: extendDeploymentChecks(services),
-    FqnRefExpr: fqnRefExprChecks(services),
-    RelationExpr: relationExprChecks(services),
+    FqnRefExpr: checkFqnRefExpr(services),
+    RelationExpr: checkRelationExpr(services),
     NotesProperty: notesPropertyRuleChecks(services),
     OpacityProperty: opacityPropertyRuleChecks(services),
     IconProperty: iconPropertyRuleChecks(services),
-    SpecificationRule: specificationRuleChecks(services),
-    Model: modelRuleChecks(services),
-    Globals: globalsChecks(services),
-    GlobalPredicateGroup: globalPredicateChecks(services),
-    GlobalDynamicPredicateGroup: globalPredicateChecks(services),
-    GlobalStyleId: globalStyleIdChecks(services),
+    SpecificationRule: checkSpecificationRule(services),
+    Model: checkModel(services),
+    Globals: checkGlobals(services),
+    GlobalPredicateGroup: checkGlobalPredicate(services),
+    GlobalDynamicPredicateGroup: checkGlobalPredicate(services),
+    GlobalStyleId: checkGlobalStyleId(services),
     DynamicViewStep: dynamicViewStep(services),
     LikeC4View: viewChecks(services),
-    Element: elementChecks(services),
-    ElementKind: elementKindChecks(services),
+    Element: checkElement(services),
+    ElementRef: checkElementRef(services),
+    ElementKind: checkElementKind(services),
     Relation: relationChecks(services),
-    RelationBody: relationBodyChecks(services),
-    Tag: tagChecks(services),
-    DynamicViewPredicateIterator: dynamicViewRulePredicate(services),
-    ElementPredicateWith: elementPredicateWithChecks(services),
-    RelationPredicateWith: relationPredicateWithChecks(services),
-    ExpandElementExpression: expandElementExprChecks(services),
-    RelationshipKind: relationshipChecks(services),
-    IncomingRelationExpression: incomingExpressionChecks(services),
-    OutgoingRelationExpression: outgoingExpressionChecks(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)
   });
   const connection = services.shared.lsp.Connection;
   if (connection) {

package/dist/validation/relation.d.ts

@@ -1,5 +1,5 @@
-import type { ValidationCheck } from 'langium';
+import { type ValidationCheck } from 'langium';
 import { ast } from '../ast';
 import type { LikeC4Services } from '../module';
 export declare const relationChecks: (services: LikeC4Services) => ValidationCheck<ast.Relation>;
-export declare const relationBodyChecks: (_services: LikeC4Services) => ValidationCheck<ast.RelationBody>;
+export declare const checkRelationBody: (_services: LikeC4Services) => ValidationCheck<ast.RelationBody>;

package/dist/validation/relation.js

@@ -1,50 +1,47 @@
-import { isSameHierarchy } from "@likec4/core";
-import { isDefined } from "remeda";
-import { ast } from "../ast.js";
-import { elementRef } from "../utils/elementRef.js";
+import { FqnRef, isSameHierarchy } from "@likec4/core";
+import { AstUtils } from "langium";
+import { safeCall } from "../utils/index.js";
 import { tryOrLog } from "./_shared.js";
 export const relationChecks = (services) => {
-  const fqnIndex = services.likec4.FqnIndex;
+  const modelParser = services.likec4.ModelParser;
   return tryOrLog((el, accept) => {
-    const targetEl = elementRef(el.target);
-    const target = targetEl && fqnIndex.getFqn(targetEl);
+    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;
     }
-    let sourceEl;
-    if (isDefined(el.source)) {
-      sourceEl = elementRef(el.source);
-      if (!sourceEl) {
-        return accept("error", "Source not resolved", {
+    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"
         });
       }
-    } else {
-      if (!ast.isElementBody(el.$container)) {
-        return accept("error", "Sourceless relation must be nested", {
-          node: el
-        });
-      }
-      sourceEl = el.$container.$container;
-    }
-    const source = fqnIndex.getFqn(sourceEl);
-    if (!source) {
-      accept("error", "Source not resolved", {
-        node: el
-      });
     }
-    if (source && target && isSameHierarchy(source, target)) {
+    if (isSameHierarchy(FqnRef.toModelFqn(source), FqnRef.toModelFqn(target))) {
       accept("error", "Invalid parent-child relationship", {
         node: el
       });
     }
   });
 };
-export const relationBodyChecks = (_services) => {
+export const checkRelationBody = (_services) => {
   return tryOrLog((body, accept) => {
     const relation = body.$container;
     if (relation.tags?.values && body.tags?.values) {

package/dist/validation/specification.d.ts

@@ -1,12 +1,12 @@
 import { type ValidationCheck } from 'langium';
 import { ast } from '../ast';
 import type { LikeC4Services } from '../module';
-export declare const specificationRuleChecks: (_: LikeC4Services) => ValidationCheck<ast.SpecificationRule>;
-export declare const modelRuleChecks: (_: LikeC4Services) => ValidationCheck<ast.Model>;
-export declare const globalsChecks: (_: LikeC4Services) => ValidationCheck<ast.Globals>;
-export declare const elementKindChecks: (services: LikeC4Services) => ValidationCheck<ast.ElementKind>;
-export declare const deploymentNodeKindChecks: (services: LikeC4Services) => ValidationCheck<ast.DeploymentNodeKind>;
-export declare const tagChecks: (services: LikeC4Services) => ValidationCheck<ast.Tag>;
-export declare const relationshipChecks: (services: LikeC4Services) => ValidationCheck<ast.RelationshipKind>;
-export declare const globalPredicateChecks: (services: LikeC4Services) => ValidationCheck<ast.GlobalPredicateGroup | ast.GlobalDynamicPredicateGroup>;
-export declare const globalStyleIdChecks: (services: LikeC4Services) => ValidationCheck<ast.GlobalStyleId>;
+export declare const checkSpecificationRule: (_: LikeC4Services) => ValidationCheck<ast.SpecificationRule>;
+export declare const checkModel: (_: LikeC4Services) => ValidationCheck<ast.Model>;
+export declare const checkGlobals: (_: LikeC4Services) => ValidationCheck<ast.Globals>;
+export declare const checkElementKind: (services: LikeC4Services) => ValidationCheck<ast.ElementKind>;
+export declare const checkDeploymentNodeKind: (services: LikeC4Services) => ValidationCheck<ast.DeploymentNodeKind>;
+export declare const checkTag: (services: LikeC4Services) => ValidationCheck<ast.Tag>;
+export declare const checkRelationshipKind: (services: LikeC4Services) => ValidationCheck<ast.RelationshipKind>;
+export declare const checkGlobalPredicate: (services: LikeC4Services) => ValidationCheck<ast.GlobalPredicateGroup | ast.GlobalDynamicPredicateGroup>;
+export declare const checkGlobalStyleId: (services: LikeC4Services) => ValidationCheck<ast.GlobalStyleId>;

package/dist/validation/specification.js

@@ -2,7 +2,7 @@ import { AstUtils } from "langium";
 import { ast } from "../ast.js";
 import { projectIdFrom } from "../utils/index.js";
 import { RESERVED_WORDS, tryOrLog } from "./_shared.js";
-export const specificationRuleChecks = (_) => {
+export const checkSpecificationRule = (_) => {
   return tryOrLog((node, accept) => {
     if (node.$containerIndex && node.$containerIndex > 0) {
       accept("warning", `Prefer one specification per document`, {
@@ -12,7 +12,7 @@ export const specificationRuleChecks = (_) => {
     }
   });
 };
-export const modelRuleChecks = (_) => {
+export const checkModel = (_) => {
   return tryOrLog((node, accept) => {
     if (node.$containerIndex && node.$containerIndex > 0) {
       accept("warning", `Prefer one model per document`, {
@@ -22,7 +22,7 @@ export const modelRuleChecks = (_) => {
     }
   });
 };
-export const globalsChecks = (_) => {
+export const checkGlobals = (_) => {
   return tryOrLog((node, accept) => {
     if (node.$containerIndex && node.$containerIndex > 0) {
       accept("warning", `Prefer one global block per document`, {
@@ -32,7 +32,7 @@ export const globalsChecks = (_) => {
     }
   });
 };
-export const elementKindChecks = (services) => {
+export const checkElementKind = (services) => {
   const index = services.shared.workspace.IndexManager;
   return tryOrLog((node, accept) => {
     if (RESERVED_WORDS.includes(node.name)) {
@@ -63,7 +63,7 @@ export const elementKindChecks = (services) => {
     }
   });
 };
-export const deploymentNodeKindChecks = (services) => {
+export const checkDeploymentNodeKind = (services) => {
   const index = services.shared.workspace.IndexManager;
   return tryOrLog((node, accept) => {
     if (RESERVED_WORDS.includes(node.name)) {
@@ -94,7 +94,7 @@ export const deploymentNodeKindChecks = (services) => {
     }
   });
 };
-export const tagChecks = (services) => {
+export const checkTag = (services) => {
   const index = services.shared.workspace.IndexManager;
   return tryOrLog((node, accept) => {
     const tagname = "#" + node.name;
@@ -124,7 +124,7 @@ export const tagChecks = (services) => {
     }
   });
 };
-export const relationshipChecks = (services) => {
+export const checkRelationshipKind = (services) => {
   const index = services.shared.workspace.IndexManager;
   return tryOrLog((node, accept) => {
     if (RESERVED_WORDS.includes(node.name)) {
@@ -143,7 +143,7 @@ export const relationshipChecks = (services) => {
     }
   });
 };
-export const globalPredicateChecks = (services) => {
+export const checkGlobalPredicate = (services) => {
   const index = services.shared.workspace.IndexManager;
   return tryOrLog((node, accept) => {
     const projectId = projectIdFrom(node);
@@ -158,7 +158,7 @@ export const globalPredicateChecks = (services) => {
     }
   });
 };
-export const globalStyleIdChecks = (services) => {
+export const checkGlobalStyleId = (services) => {
   const index = services.shared.workspace.IndexManager;
   return tryOrLog((node, accept) => {
     const projectId = projectIdFrom(node);

package/dist/validation/view-predicates/{element-with.d.ts → fqn-expr-with.d.ts}

@@ -1,4 +1,4 @@
 import type { ValidationCheck } from 'langium';
 import { ast } from '../../ast';
 import type { LikeC4Services } from '../../module';
-export declare const elementPredicateWithChecks: (_services: LikeC4Services) => ValidationCheck<ast.ElementPredicateWith>;
+export declare const checkFqnExprWith: (services: LikeC4Services) => ValidationCheck<ast.FqnExprWith>;

package/dist/validation/view-predicates/fqn-expr-with.js

@@ -0,0 +1,42 @@
+import { FqnExpr, nonexhaustive } from "@likec4/core";
+import { AstUtils } from "langium";
+import { getViewRulePredicateContainer } from "../../ast.js";
+import { tryOrLog } from "../_shared.js";
+export const checkFqnExprWith = (services) => {
+  const modelParser = services.likec4.ModelParser;
+  return tryOrLog((el, accept) => {
+    const container = getViewRulePredicateContainer(el);
+    if (container?.$type !== "DynamicViewIncludePredicate" && container?.isInclude !== true) {
+      accept("error", 'Invalid usage inside "exclude"', {
+        node: el
+      });
+      return;
+    }
+    const isInsideDynamicView = container.$type === "DynamicViewIncludePredicate";
+    const parser = modelParser.forDocument(AstUtils.getDocument(container));
+    let expr = FqnExpr.unwrap(parser.parseFqnExprWith(el).custom.expr);
+    switch (true) {
+      case (FqnExpr.isWildcard(expr) && isInsideDynamicView):
+      case (FqnExpr.isElementKindExpr(expr) && isInsideDynamicView):
+      case (FqnExpr.isElementTagExpr(expr) && isInsideDynamicView): {
+        accept("warning", `Predicate is ignored, as not supported in dynamic views`, {
+          node: el
+        });
+        return;
+      }
+      case FqnExpr.isWildcard(expr):
+      case FqnExpr.isModelRef(expr):
+      case FqnExpr.isDeploymentRef(expr):
+        return;
+      case FqnExpr.isElementKindExpr(expr):
+      case FqnExpr.isElementTagExpr(expr):
+        accept("error", "Invalid target (expect reference to specific element)", {
+          node: el,
+          property: "subject"
+        });
+        return;
+      default:
+        nonexhaustive(expr);
+    }
+  });
+};

package/dist/validation/view-predicates/fqn-ref-expr.d.ts

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

package/dist/validation/view-predicates/fqn-ref-expr.js

@@ -0,0 +1,53 @@
+import { FqnExpr, FqnRef } from "@likec4/core";
+import { AstUtils } from "langium";
+import { isTruthy } from "remeda";
+import { ast, getViewRulePredicateContainer, isFqnRefInsideDeployment } from "../../ast.js";
+import { tryOrLog } from "../_shared.js";
+export const checkFqnRefExpr = (services) => {
+  const modelParser = services.likec4.ModelParser;
+  return tryOrLog((node, accept) => {
+    const parser = modelParser.forDocument(AstUtils.getDocument(node));
+    const expr = parser.parseFqnRefExpr(node);
+    const viewRulePredicate = getViewRulePredicateContainer(node);
+    const isInsideDeploymentButNotStyle = isFqnRefInsideDeployment(node) && !AstUtils.hasContainerOfType(
+      node,
+      (n) => ast.isDeploymentViewRuleStyle(n) || ast.isViewRuleStyle(n)
+    );
+    if (viewRulePredicate?.$type === "DeploymentViewRulePredicate" || isInsideDeploymentButNotStyle) {
+      const isPartOfRelationExpr = AstUtils.hasContainerOfType(node, ast.isRelationExpr);
+      if (!isPartOfRelationExpr) {
+        if (FqnExpr.isModelRef(expr)) {
+          accept("error", "Deployment view predicate must reference deployment model", {
+            node
+          });
+          return;
+        }
+        if (FqnExpr.isDeploymentRef(expr) && FqnRef.isInsideInstanceRef(expr.ref)) {
+          accept("error", "Must reference deployment nodes or instances, but not internals", {
+            node
+          });
+          return;
+        }
+      }
+      if (isTruthy(node.selector) && !ast.isDeploymentNode(node.ref.value?.ref)) {
+        accept("warning", `Selector '${node.selector}' applies to deployment nodes only, ignored here`, {
+          node,
+          property: "selector"
+        });
+      }
+      return;
+    }
+    if (viewRulePredicate?.$type === "DynamicViewIncludePredicate") {
+      switch (true) {
+        case FqnExpr.isElementKindExpr(expr):
+        case FqnExpr.isElementTagExpr(expr):
+        case FqnExpr.isWildcard(expr): {
+          accept("warning", `Predicate is ignored, as not supported in dynamic views`, {
+            node
+          });
+          return;
+        }
+      }
+    }
+  });
+};

package/dist/validation/view-predicates/incoming.d.ts

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

package/dist/validation/view-predicates/incoming.js

@@ -2,9 +2,9 @@ import { AstUtils } from "langium";
 import { isNullish } from "remeda";
 import { ast } from "../../ast.js";
 import { tryOrLog } from "../_shared.js";
-export const incomingExpressionChecks = (_services) => {
+export const checkIncomingRelationExpr = (_services) => {
   return tryOrLog((el, accept) => {
-    if (ast.isWildcardExpression(el.to) && !ast.isInOutRelationExpression(el.$container)) {
+    if (el.to.$type === "WildcardExpression" && !ast.isInOutRelationExpr(el.$container)) {
       const view = AstUtils.getContainerOfType(el, ast.isElementView);
       if (isNullish(view?.viewOf)) {
         accept("warning", "Predicate is ignored as it concerns all relationships", {

package/dist/validation/view-predicates/index.d.ts

@@ -1,6 +1,6 @@
-export * from './element-with';
-export * from './expanded-element';
-export * from './expression-v2';
-export * from './incoming';
-export * from './outgoing';
-export * from './relation-with';
+export { checkFqnExprWith } from './fqn-expr-with';
+export { checkFqnRefExpr } from './fqn-ref-expr';
+export { checkIncomingRelationExpr } from './incoming';
+export { checkOutgoingRelationExpr } from './outgoing';
+export { checkRelationExpr } from './relation-expr';
+export { checkRelationExprWith } from './relation-with';

package/dist/validation/view-predicates/index.js

@@ -1,6 +1,6 @@
-export * from "./element-with.js";
-export * from "./expanded-element.js";
-export * from "./expression-v2.js";
-export * from "./incoming.js";
-export * from "./outgoing.js";
-export * from "./relation-with.js";
+export { checkFqnExprWith } from "./fqn-expr-with.js";
+export { checkFqnRefExpr } from "./fqn-ref-expr.js";
+export { checkIncomingRelationExpr } from "./incoming.js";
+export { checkOutgoingRelationExpr } from "./outgoing.js";
+export { checkRelationExpr } from "./relation-expr.js";
+export { checkRelationExprWith } from "./relation-with.js";

package/dist/validation/view-predicates/outgoing.d.ts

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

package/dist/validation/view-predicates/outgoing.js

@@ -1,12 +1,16 @@
 import { AstUtils } from "langium";
 import { isNullish } from "remeda";
-import { ast } from "../../ast.js";
+import { ast, getViewRulePredicateContainer } from "../../ast.js";
 import { tryOrLog } from "../_shared.js";
-export const outgoingExpressionChecks = (_services) => {
+export const checkOutgoingRelationExpr = (_services) => {
   return tryOrLog((el, accept) => {
-    if (ast.isWildcardExpression(el.from) && !ast.isDirectedRelationExpression(el.$container)) {
+    const viewRulePredicate = getViewRulePredicateContainer(el);
+    if (viewRulePredicate?.$type !== "ViewRulePredicate") {
+      return;
+    }
+    if (el.$container.$type !== "DirectedRelationExpr" && el.from.$type === "WildcardExpression") {
       const view = AstUtils.getContainerOfType(el, ast.isElementView);
-      if (isNullish(view?.viewOf)) {
+      if (view && isNullish(view.viewOf)) {
         accept("warning", "Predicate is ignored as it concerns all relationships", {
           node: el
         });

package/dist/validation/view-predicates/{expanded-element.d.ts → relation-expr.d.ts}

@@ -1,4 +1,4 @@
 import { type ValidationCheck } from 'langium';
 import { ast } from '../../ast';
 import type { LikeC4Services } from '../../module';
-export declare const expandElementExprChecks: (_services: LikeC4Services) => ValidationCheck<ast.ExpandElementExpression>;
+export declare const checkRelationExpr: (services: LikeC4Services) => ValidationCheck<ast.RelationExpr>;

package/dist/validation/view-predicates/relation-expr.js

@@ -0,0 +1,39 @@
+import { FqnExpr, RelationExpr } from "@likec4/core";
+import { AstUtils } from "langium";
+import { ast } from "../../ast.js";
+import { tryOrLog } from "../_shared.js";
+export const checkRelationExpr = (services) => {
+  const ModelParser = services.likec4.ModelParser;
+  return tryOrLog((node, accept) => {
+    const predicate = AstUtils.getContainerOfType(node, ast.isDeploymentViewRulePredicate);
+    if (!predicate || predicate.isInclude !== true) {
+      return;
+    }
+    const doc = AstUtils.getDocument(node);
+    const parser = ModelParser.forDocument(doc);
+    let relationExpr = RelationExpr.unwrap(parser.parseRelationExpr(node));
+    const ModelRefOnlyExclude = "Model reference is allowed in exclude predicate only";
+    if (RelationExpr.isDirect(relationExpr)) {
+      if (FqnExpr.isModelRef(relationExpr.source) || FqnExpr.isModelRef(relationExpr.target)) {
+        accept("error", ModelRefOnlyExclude, {
+          node
+        });
+      }
+      return;
+    }
+    let expr;
+    if (RelationExpr.isIncoming(relationExpr)) {
+      expr = relationExpr.incoming;
+    } else if (RelationExpr.isOutgoing(relationExpr)) {
+      expr = relationExpr.outgoing;
+    } else {
+      expr = relationExpr.inout;
+    }
+    if (FqnExpr.isModelRef(expr)) {
+      accept("error", ModelRefOnlyExclude, {
+        node
+      });
+      return;
+    }
+  });
+};

package/dist/validation/view-predicates/relation-with.d.ts

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

package/dist/validation/view-predicates/relation-with.js

@@ -1,13 +1,16 @@
-import { AstUtils } from "langium";
-import { ast } from "../../ast.js";
+import { getViewRulePredicateContainer } from "../../ast.js";
 import { tryOrLog } from "../_shared.js";
-export const relationPredicateWithChecks = (_services) => {
+export const checkRelationExprWith = (_services) => {
   return tryOrLog((el, accept) => {
-    const container = AstUtils.getContainerOfType(el, ast.isViewRulePredicate);
-    if (ast.isExcludePredicate(container)) {
+    const container = getViewRulePredicateContainer(el);
+    if (!container || container.$type == "DynamicViewIncludePredicate") {
+      return;
+    }
+    if (!container.isInclude) {
       accept("error", 'Invalid usage inside "exclude"', {
         node: el
       });
+      return;
     }
   });
 };

package/dist/workspace/AstNodeDescriptionProvider.d.ts

@@ -1,7 +1,7 @@
 import { type AstNode, type AstNodeDescription, type LangiumDocument, DefaultAstNodeDescriptionProvider } from 'langium';
 import type { LikeC4Services } from '../module';
 export declare class AstNodeDescriptionProvider extends DefaultAstNodeDescriptionProvider {
-    private projects;
+    protected services: LikeC4Services;
     constructor(services: LikeC4Services);
     createDescription(node: AstNode, name: string | undefined, document?: LangiumDocument): AstNodeDescription;
 }

package/dist/workspace/AstNodeDescriptionProvider.js

@@ -3,15 +3,14 @@ import {
   DefaultAstNodeDescriptionProvider
 } from "langium";
 export class AstNodeDescriptionProvider extends DefaultAstNodeDescriptionProvider {
-  projects;
   constructor(services) {
     super(services);
-    this.projects = services.shared.workspace.ProjectsManager;
+    this.services = services;
   }
   createDescription(node, name, document) {
     const doc = document ?? AstUtils.getDocument(node);
     const description = super.createDescription(node, name, document);
-    doc.likec4ProjectId ??= this.projects.belongsTo(doc.uri);
+    doc.likec4ProjectId ??= this.services.shared.workspace.ProjectsManager.belongsTo(doc.uri);
     description.likec4ProjectId = doc.likec4ProjectId;
     return description;
   }

package/dist/workspace/IndexManager.d.ts

@@ -3,7 +3,7 @@ import { type AstNodeDescription, type LangiumDocument, type Stream, DefaultInde
 import { CancellationToken } from 'vscode-jsonrpc';
 import type { LikeC4SharedServices } from '../module';
 export declare class IndexManager extends DefaultIndexManager {
-    private projects;
+    protected services: LikeC4SharedServices;
     constructor(services: LikeC4SharedServices);
     updateContent(document: LangiumDocument, cancelToken?: CancellationToken): Promise<void>;
     projectElements(projectId: ProjectId, nodeType?: string, uris?: Set<string>): Stream<AstNodeDescription>;