@likec4/language-server 1.27.3 → 1.28.1

package/dist/model/parser/FqnRefParser.js

@@ -1,17 +1,38 @@
-import { nonexhaustive, nonNullable } from "@likec4/core";
-import { isNonNullish } from "remeda";
-import { ast } from "../../ast.js";
+import { invariant, nonexhaustive, nonNullable } from "@likec4/core";
+import { isBoolean, isDefined, isNonNullish, isTruthy } from "remeda";
+import { ast, parseAstOpacityProperty, parseAstSizeValue, toColor } from "../../ast.js";
 import { logWarnError } from "../../logger.js";
-import { instanceRef } from "../../utils/fqnRef.js";
+import { projectIdFrom } from "../../utils/index.js";
+import { importsRef, instanceRef } from "../../utils/fqnRef.js";
 import { parseWhereClause } from "../model-parser-where.js";
+import { removeIndent } from "./Base.js";
 export function ExpressionV2Parser(B) {
   return class ExpressionV2Parser extends B {
     parseFqnRef(astNode) {
       const refValue = nonNullable(
-        astNode.value.ref,
+        astNode.value?.ref,
         `FqnRef is empty ${astNode.$cstNode?.range.start.line}:${astNode.$cstNode?.range.start.character}`
       );
+      if (ast.isImported(refValue)) {
+        const fqnRef = {
+          project: projectIdFrom(refValue),
+          model: this.resolveFqn(
+            nonNullable(refValue.imported.ref, `FqnRef is empty of imported: ${refValue.$cstNode?.text}`)
+          )
+        };
+        this.doc.c4Imports.set(fqnRef.project, fqnRef.model);
+        return fqnRef;
+      }
       if (ast.isElement(refValue)) {
+        const imported = importsRef(astNode);
+        if (imported) {
+          const fqnRef = {
+            project: projectIdFrom(imported),
+            model: this.resolveFqn(refValue)
+          };
+          this.doc.c4Imports.set(fqnRef.project, fqnRef.model);
+          return fqnRef;
+        }
         const deployedInstanceAst = instanceRef(astNode);
         if (!deployedInstanceAst) {
           return {
@@ -32,12 +53,160 @@ export function ExpressionV2Parser(B) {
       }
       nonexhaustive(refValue);
     }
+    parseExpressionV2(astNode) {
+      if (ast.isFqnExprOrWith(astNode)) {
+        return this.parseFqnExprOrWith(astNode);
+      }
+      if (ast.isRelationExprOrWith(astNode)) {
+        return this.parseRelationExprOrWith(astNode);
+      }
+      nonexhaustive(astNode);
+    }
+    parseFqnExprOrWith(astNode) {
+      if (ast.isFqnExprWith(astNode)) {
+        return this.parseFqnExprWith(astNode);
+      }
+      if (ast.isFqnExprOrWhere(astNode)) {
+        return this.parseFqnExprOrWhere(astNode);
+      }
+      nonexhaustive(astNode);
+    }
+    parseFqnExprWith(astNode) {
+      const expr = this.parseFqnExprOrWhere(astNode.subject);
+      const props = astNode.custom?.props ?? [];
+      return props.reduce(
+        (acc, prop) => {
+          if (!this.isValid(prop)) {
+            return acc;
+          }
+          if (ast.isNavigateToProperty(prop)) {
+            const viewId = prop.value.view.$refText;
+            if (isTruthy(viewId)) {
+              acc.custom.navigateTo = viewId;
+            }
+            return acc;
+          }
+          if (ast.isElementStringProperty(prop)) {
+            if (isDefined(prop.value)) {
+              acc.custom[prop.key] = removeIndent(prop.value) || "";
+            }
+            return acc;
+          }
+          if (ast.isIconProperty(prop)) {
+            const value = this.parseIconProperty(prop);
+            if (isDefined(value)) {
+              acc.custom[prop.key] = value;
+            }
+            return acc;
+          }
+          if (ast.isColorProperty(prop)) {
+            const value = toColor(prop);
+            if (isDefined(value)) {
+              acc.custom[prop.key] = value;
+            }
+            return acc;
+          }
+          if (ast.isShapeProperty(prop)) {
+            if (isDefined(prop.value)) {
+              acc.custom[prop.key] = prop.value;
+            }
+            return acc;
+          }
+          if (ast.isBorderProperty(prop)) {
+            if (isDefined(prop.value)) {
+              acc.custom[prop.key] = prop.value;
+            }
+            return acc;
+          }
+          if (ast.isOpacityProperty(prop)) {
+            if (isDefined(prop.value)) {
+              acc.custom[prop.key] = parseAstOpacityProperty(prop);
+            }
+            return acc;
+          }
+          if (ast.isNotationProperty(prop)) {
+            if (isTruthy(prop.value)) {
+              acc.custom[prop.key] = removeIndent(prop.value);
+            }
+            return acc;
+          }
+          if (ast.isMultipleProperty(prop)) {
+            if (isBoolean(prop.value)) {
+              acc.custom[prop.key] = prop.value;
+            }
+            return acc;
+          }
+          if (ast.isShapeSizeProperty(prop)) {
+            if (isTruthy(prop.value)) {
+              acc.custom[prop.key] = parseAstSizeValue(prop);
+            }
+            return acc;
+          }
+          if (ast.isTextSizeProperty(prop)) {
+            if (isTruthy(prop.value)) {
+              acc.custom[prop.key] = parseAstSizeValue(prop);
+            }
+            return acc;
+          }
+          if (ast.isPaddingSizeProperty(prop)) {
+            if (isTruthy(prop.value)) {
+              acc.custom[prop.key] = parseAstSizeValue(prop);
+            }
+            return acc;
+          }
+          nonexhaustive(prop);
+        },
+        {
+          custom: {
+            expr
+          }
+        }
+      );
+    }
+    parseFqnExprOrWhere(astNode) {
+      if (ast.isFqnExprWhere(astNode)) {
+        return this.parseFqnExprWhere(astNode);
+      }
+      if (ast.isFqnExpr(astNode)) {
+        return this.parseFqnExpr(astNode);
+      }
+      nonexhaustive(astNode);
+    }
+    parseFqnExprWhere(astNode) {
+      invariant(!ast.isFqnExprWhere(astNode.subject), "FqnExprWhere is not allowed as subject of FqnExprWhere");
+      return {
+        where: {
+          expr: this.parseFqnExpr(astNode.subject),
+          condition: astNode.where ? parseWhereClause(astNode.where) : {
+            kind: { neq: "--always-true--" }
+          }
+        }
+      };
+    }
     parseFqnExpr(astNode) {
       if (ast.isWildcardExpression(astNode)) {
         return {
           wildcard: true
         };
       }
+      if (ast.isElementKindExpression(astNode)) {
+        invariant(astNode.kind?.ref, "ElementKindExpr kind is not resolved: " + astNode.$cstNode?.text);
+        return {
+          elementKind: astNode.kind.ref.name,
+          isEqual: astNode.isEqual
+        };
+      }
+      if (ast.isElementTagExpression(astNode)) {
+        invariant(astNode.tag?.ref, "ElementTagExpr tag is not resolved: " + astNode.$cstNode?.text);
+        let elementTag = astNode.tag.$refText;
+        if (elementTag.startsWith("#")) {
+          elementTag = elementTag.slice(1);
+        }
+        return {
+          elementTag,
+          isEqual: astNode.isEqual
+        };
+      }
       if (ast.isFqnRefExpr(astNode)) {
         return this.parseFqnRefExpr(astNode);
       }
@@ -65,16 +234,6 @@ export function ExpressionV2Parser(B) {
           return { ref };
       }
     }
-    parseElementWhereExpr(astNode) {
-      return {
-        where: {
-          expr: this.parseFqnExpr(astNode.subject),
-          condition: astNode.where ? parseWhereClause(astNode.where) : {
-            kind: { neq: "--always-true--" }
-          }
-        }
-      };
-    }
     parseFqnExpressions(astNode) {
       const exprs = [];
       let iter = astNode;
@@ -90,7 +249,75 @@ export function ExpressionV2Parser(B) {
       }
       return exprs.reverse();
     }
-    parseRelationWhereExpr(astNode) {
+    parseRelationExprOrWith(astNode) {
+      if (ast.isRelationExprWith(astNode)) {
+        return this.parseRelationExprWith(astNode);
+      }
+      if (ast.isRelationExprOrWhere(astNode)) {
+        return this.parseRelationExprOrWhere(astNode);
+      }
+      nonexhaustive(astNode);
+    }
+    parseRelationExprWith(astNode) {
+      const expr = this.parseRelationExprOrWhere(astNode.subject);
+      const props = astNode.custom?.props ?? [];
+      return props.reduce(
+        (acc, prop) => {
+          if (ast.isRelationStringProperty(prop) || ast.isNotationProperty(prop) || ast.isNotesProperty(prop)) {
+            if (isDefined(prop.value)) {
+              acc.customRelation[prop.key] = removeIndent(prop.value) ?? "";
+            }
+            return acc;
+          }
+          if (ast.isArrowProperty(prop)) {
+            if (isTruthy(prop.value)) {
+              acc.customRelation[prop.key] = prop.value;
+            }
+            return acc;
+          }
+          if (ast.isColorProperty(prop)) {
+            const value = toColor(prop);
+            if (isTruthy(value)) {
+              acc.customRelation[prop.key] = value;
+            }
+            return acc;
+          }
+          if (ast.isLineProperty(prop)) {
+            if (isTruthy(prop.value)) {
+              acc.customRelation[prop.key] = prop.value;
+            }
+            return acc;
+          }
+          if (ast.isRelationNavigateToProperty(prop)) {
+            const viewId = prop.value.view.ref?.name;
+            if (isTruthy(viewId)) {
+              acc.customRelation.navigateTo = viewId;
+            }
+            return acc;
+          }
+          nonexhaustive(prop);
+        },
+        {
+          customRelation: {
+            expr
+          }
+        }
+      );
+    }
+    parseRelationExprOrWhere(astNode) {
+      if (ast.isRelationExprWhere(astNode)) {
+        return this.parseRelationExprWhere(astNode);
+      }
+      if (ast.isRelationExpr(astNode)) {
+        return this.parseRelationExpr(astNode);
+      }
+      nonexhaustive(astNode);
+    }
+    parseRelationExprWhere(astNode) {
+      invariant(
+        !ast.isRelationExprWhere(astNode.subject),
+        "RelationExprWhere is not allowed as subject of RelationExprWhere"
+      );
       return {
         where: {
           expr: this.parseRelationExpr(astNode.subject),
@@ -101,31 +328,28 @@ export function ExpressionV2Parser(B) {
       };
     }
     parseRelationExpr(astNode) {
-      if (ast.isRelationPredicateWhere(astNode)) {
-      }
-      if (ast.isDirectedRelationExpr(astNode)) {
-        return {
-          source: this.parseFqnExpr(astNode.source.from),
-          target: this.parseFqnExpr(astNode.target),
-          isBidirectional: astNode.source.isBidirectional
-        };
-      }
-      if (ast.isInOutRelationExpr(astNode)) {
-        return {
-          inout: this.parseFqnExpr(astNode.inout.to)
-        };
-      }
-      if (ast.isOutgoingRelationExpr(astNode)) {
-        return {
-          outgoing: this.parseFqnExpr(astNode.from)
-        };
-      }
-      if (ast.isIncomingRelationExpr(astNode)) {
-        return {
-          incoming: this.parseFqnExpr(astNode.to)
-        };
+      switch (astNode.$type) {
+        case "DirectedRelationExpr":
+          return {
+            source: this.parseFqnExpr(astNode.source.from),
+            target: this.parseFqnExpr(astNode.target),
+            isBidirectional: astNode.source.isBidirectional
+          };
+        case "InOutRelationExpr":
+          return {
+            inout: this.parseFqnExpr(astNode.inout.to)
+          };
+        case "OutgoingRelationExpr":
+          return {
+            outgoing: this.parseFqnExpr(astNode.from)
+          };
+        case "IncomingRelationExpr":
+          return {
+            incoming: this.parseFqnExpr(astNode.to)
+          };
+        default:
+          nonexhaustive(astNode);
       }
-      nonexhaustive(astNode);
     }
   };
 }

package/dist/model/parser/GlobalsParser.d.ts

@@ -16,26 +16,46 @@ export declare function GlobalsParser<TBase extends WithViewsParser>(B: TBase):
         parseViewRuleStyleOrGlobalRef(astRule: ast.ViewRuleStyleOrGlobalRef): c4.ViewRuleStyleOrGlobalRef;
         parseViewRuleGroup(astNode: ast.ViewRuleGroup): c4.ViewRuleGroup;
         parseViewRuleStyle(astRule: ast.ViewRuleStyle | ast.GlobalStyle): c4.ViewRuleStyle;
-        parseRuleStyle(styleProperties: ast.StyleProperty[], elementExpressionsIterator: ast.ElementExpressionsIterator, notationProperty?: ast.NotationProperty): c4.ViewRuleStyle;
+        parseRuleStyle(styleProperties: ast.StyleProperty[], elementExpressionsIterator: ast.FqnExpressions, notationProperty?: ast.NotationProperty): c4.ViewRuleStyle;
         parseViewRuleGlobalStyle(astRule: ast.ViewRuleGlobalStyle): c4.ViewRuleGlobalStyle;
         parseDynamicElementView(astNode: ast.DynamicView, additionalStyles: c4.ViewRuleStyleOrGlobalRef[]): import("../../ast").ParsedAstDynamicView;
         parseDynamicViewRule(astRule: ast.DynamicViewRule): c4.DynamicViewRule;
         parseDynamicViewIncludePredicate(astRule: ast.DynamicViewIncludePredicate): c4.DynamicViewIncludeRule;
         parseDynamicParallelSteps(node: ast.DynamicViewParallelSteps): c4.DynamicViewParallelSteps;
         parseDynamicStep(node: ast.DynamicViewStep): c4.DynamicViewStep;
-        parsePredicate(astNode: ast.Predicate): c4.Expression;
-        parseElementPredicate(astNode: ast.ElementPredicate): c4.ElementPredicateExpression;
-        parseElementExpressionsIterator(astNode: ast.ElementExpressionsIterator): c4.ElementExpression[];
-        parseElementExpression(astNode: ast.ElementExpression): c4.ElementExpression;
-        parseElementPredicateWhere(astNode: ast.ElementPredicateWhere): c4.ElementWhereExpr;
-        parseElementPredicateWith(astNode: ast.ElementPredicateWith): c4.CustomElementExpr;
-        parseRelationPredicate(astNode: ast.RelationPredicate): c4.RelationPredicateExpression;
-        parseRelationPredicateWhere(astNode: ast.RelationPredicateWhere): c4.RelationWhereExpr;
-        parseRelationPredicateWith(astNode: ast.RelationPredicateWith, relation: c4.RelationExpression | c4.RelationWhereExpr): c4.CustomRelationExpr;
-        parseRelationExpression(astNode: ast.RelationExpression): c4.RelationExpression;
+        parsePredicate(astNode: ast.ExpressionV2): c4.ModelLayer.Expression;
+        parseElementPredicate(astNode: ast.FqnExprOrWith): c4.ModelLayer.AnyFqnExpr;
+        parseElementPredicateOrWhere(astNode: ast.FqnExprOrWhere): c4.ModelLayer.FqnExprOrWhere;
+        parseElementExpression(astNode: ast.FqnExpr): c4.ModelLayer.FqnExpr;
+        parseElementPredicateWhere(astNode: ast.FqnExprWhere): c4.ModelLayer.FqnExpr.Where;
+        parseElementPredicateWith(astNode: ast.FqnExprWith): c4.ModelLayer.FqnExpr.Custom;
+        parseRelationPredicate(astNode: ast.RelationExprOrWith): c4.ModelLayer.AnyRelationExpr;
+        parseRelationPredicateOrWhere(astNode: ast.RelationExprOrWhere): c4.ModelLayer.RelationExprOrWhere;
+        parseRelationPredicateWhere(astNode: ast.RelationExprWhere): c4.ModelLayer.RelationExpr.Where;
+        parseRelationPredicateWith(astNode: ast.RelationExprWith): c4.ModelLayer.RelationExpr.Custom;
+        parseRelationExpression(astNode: ast.RelationExpr): c4.ModelLayer.RelationExpr;
+        parseFqnRef(astNode: ast.FqnRef): c4.FqnRef;
+        parseExpressionV2(astNode: ast.ExpressionV2): c4.ExpressionV2;
+        parseFqnExprOrWith(astNode: ast.FqnExprOrWith): c4.FqnExpr.Any;
+        parseFqnExprWith(astNode: ast.FqnExprWith): c4.FqnExpr.Custom;
+        parseFqnExprOrWhere(astNode: ast.FqnExprOrWhere): c4.FqnExpr.OrWhere;
+        parseFqnExprWhere(astNode: ast.FqnExprWhere): c4.FqnExpr.Where;
+        parseFqnExpr(astNode: ast.FqnExpr): c4.FqnExpr;
+        parseFqnRefExpr(astNode: ast.FqnRefExpr): c4.FqnExpr.NonWildcard;
+        parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
+        parseRelationExprOrWith(astNode: ast.RelationExprOrWith): c4.RelationExpr.Any;
+        parseRelationExprWith(astNode: ast.RelationExprWith): c4.RelationExpr.Custom;
+        parseRelationExprOrWhere(astNode: ast.RelationExprOrWhere): c4.RelationExpr.OrWhere;
+        parseRelationExprWhere(astNode: ast.RelationExprWhere): c4.RelationExpr.Where;
+        parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr;
         isValid: import("../../validation").IsValidFn;
         readonly services: import("../..").LikeC4Services;
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
+        readonly project: {
+            id: c4.ProjectId;
+            folder: c4;
+            config: Readonly<import("../../config").ProjectConfig>;
+        };
         resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
         getAstNodePath(node: c4): any;
         getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
@@ -49,21 +69,18 @@ export declare function GlobalsParser<TBase extends WithViewsParser>(B: TBase):
         }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
         convertLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
         parseLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
+        parseIconProperty(prop: ast.IconProperty | undefined): c4.IconUrl | undefined;
+        parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): import("../../ast").ParsedElementStyle;
+        parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): import("../../ast").ParsedElementStyle;
         parseDeploymentView(astNode: ast.DeploymentView): import("../../ast").ParsedAstDeploymentView;
         parseDeploymentViewRule(astRule: ast.DeploymentViewRule): c4.DeploymentViewRule;
         parseDeploymentViewRulePredicate(astRule: ast.DeploymentViewRulePredicate): c4.DeploymentViewRulePredicate;
         parseDeploymentViewRuleStyle(astRule: ast.DeploymentViewRuleStyle): c4.DeploymentViewRuleStyle;
-        parseFqnRef(astNode: ast.FqnRef): c4.FqnRef;
-        parseFqnExpr(astNode: ast.FqnExpr): c4.FqnExpr;
-        parseFqnRefExpr(astNode: ast.FqnRefExpr): c4.FqnExpr.NonWildcard;
-        parseElementWhereExpr(astNode: ast.ElementPredicateWhereV2): c4.RelationExpr;
-        parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
-        parseRelationWhereExpr(astNode: ast.RelationPredicateWhereV2): c4.RelationExpr;
-        parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr;
         parseDeployment(): void;
         parseDeploymentNode(astNode: ast.DeploymentNode): import("../../ast").ParsedAstDeployment.Node;
         parseDeployedInstance(astNode: ast.DeployedInstance): import("../../ast").ParsedAstDeployment.Instance;
         parseExtendDeployment(astNode: ast.ExtendDeployment): import("../../ast").ParsedAstExtend | null;
+        _resolveDeploymentRelationSource(node: ast.DeploymentRelation): c4;
         parseDeploymentRelation(astNode: ast.DeploymentRelation): import("../../ast").ParsedAstDeploymentRelation;
     };
 } & TBase;

package/dist/model/parser/ImportsParser.d.ts

@@ -0,0 +1,32 @@
+import { type ProjectId } from '@likec4/core';
+import type { ast } from '../../ast';
+import type { Base } from './Base';
+export declare function ImportsParser<TBase extends Base>(B: TBase): {
+    new (...args: any[]): {
+        parseImports(): void;
+        isValid: import("../../validation").IsValidFn;
+        readonly services: import("../..").LikeC4Services;
+        readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
+        readonly project: {
+            id: ProjectId;
+            folder: ProjectId;
+            config: Readonly<import("../../config").ProjectConfig>;
+        };
+        resolveFqn(node: ast.FqnReferenceable): ProjectId;
+        getAstNodePath(node: ProjectId): any;
+        getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
+            [key: string]: string;
+        } | undefined;
+        convertTags<E extends {
+            tags?: ast.Tags;
+        }>(withTags?: E | undefined): any;
+        parseTags<E extends {
+            tags?: ast.Tags;
+        }>(withTags?: E): ProjectId<ProjectId> | null;
+        convertLinks(source?: ast.LinkProperty["$container"]): ProjectId[] | undefined;
+        parseLinks(source?: ast.LinkProperty["$container"]): ProjectId[] | undefined;
+        parseIconProperty(prop: ast.IconProperty | undefined): ProjectId | undefined;
+        parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): import("../../ast").ParsedElementStyle;
+        parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): import("../../ast").ParsedElementStyle;
+    };
+} & TBase;

package/dist/model/parser/ImportsParser.js

@@ -0,0 +1,26 @@
+import { nonNullable } from "@likec4/core";
+import { logWarnError } from "../../logger.js";
+export function ImportsParser(B) {
+  return class ImportsParser extends B {
+    parseImports() {
+      const imports = this.doc.parseResult.value.imports ?? [];
+      for (const importsFromPoject of imports) {
+        const project = importsFromPoject.project;
+        let imported = importsFromPoject.imports;
+        while (imported) {
+          try {
+            this.doc.c4Imports.set(
+              project,
+              this.resolveFqn(
+                nonNullable(imported.imported.ref, `ElementRef is empty of imported: ${imported.imported.$refText}`)
+              )
+            );
+          } catch (e) {
+            logWarnError(e);
+          }
+          imported = imported.prev;
+        }
+      }
+    }
+  };
+}

package/dist/model/parser/ModelParser.d.ts

@@ -1,16 +1,37 @@
 import type * as c4 from '@likec4/core';
+import { FqnRef } from '@likec4/core/types';
 import { type ParsedAstElement, type ParsedAstExtend, type ParsedAstRelation, ast } from '../../ast';
-import { type Base } from './Base';
+import type { WithExpressionV2 } from './FqnRefParser';
 export type WithModel = ReturnType<typeof ModelParser>;
-export declare function ModelParser<TBase extends Base>(B: TBase): {
+export declare function ModelParser<TBase extends WithExpressionV2>(B: TBase): {
     new (...args: any[]): {
         parseModel(): void;
         parseElement(astNode: ast.Element): ParsedAstElement;
         parseExtendElement(astNode: ast.ExtendElement): ParsedAstExtend | null;
+        _resolveRelationSource(node: ast.Relation): FqnRef.ModelRef | FqnRef.ImportRef;
         parseRelation(astNode: ast.Relation): ParsedAstRelation;
+        parseFqnRef(astNode: ast.FqnRef): c4.FqnRef;
+        parseExpressionV2(astNode: ast.ExpressionV2): c4.ExpressionV2;
+        parseFqnExprOrWith(astNode: ast.FqnExprOrWith): c4.FqnExpr.Any;
+        parseFqnExprWith(astNode: ast.FqnExprWith): c4.FqnExpr.Custom;
+        parseFqnExprOrWhere(astNode: ast.FqnExprOrWhere): c4.FqnExpr.OrWhere;
+        parseFqnExprWhere(astNode: ast.FqnExprWhere): c4.FqnExpr.Where;
+        parseFqnExpr(astNode: ast.FqnExpr): c4.FqnExpr;
+        parseFqnRefExpr(astNode: ast.FqnRefExpr): c4.FqnExpr.NonWildcard;
+        parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[];
+        parseRelationExprOrWith(astNode: ast.RelationExprOrWith): c4.RelationExpr.Any;
+        parseRelationExprWith(astNode: ast.RelationExprWith): c4.RelationExpr.Custom;
+        parseRelationExprOrWhere(astNode: ast.RelationExprOrWhere): c4.RelationExpr.OrWhere;
+        parseRelationExprWhere(astNode: ast.RelationExprWhere): c4.RelationExpr.Where;
+        parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr;
         isValid: import("../../validation").IsValidFn;
         readonly services: import("../..").LikeC4Services;
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
+        readonly project: {
+            id: c4.ProjectId;
+            folder: c4;
+            config: Readonly<import("../../config").ProjectConfig>;
+        };
         resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
         getAstNodePath(node: c4): any;
         getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
@@ -24,5 +45,8 @@ export declare function ModelParser<TBase extends Base>(B: TBase): {
         }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
         convertLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
         parseLinks(source?: ast.LinkProperty["$container"]): c4.Link[] | undefined;
+        parseIconProperty(prop: ast.IconProperty | undefined): c4.IconUrl | undefined;
+        parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): import("../../ast").ParsedElementStyle;
+        parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): import("../../ast").ParsedElementStyle;
     };
 } & TBase;

package/dist/model/parser/ModelParser.js

@@ -1,39 +1,15 @@
-import { isNonEmptyArray, LinkedList, nonexhaustive, nonNullable } from "@likec4/core";
+import { invariant, isNonEmptyArray, LinkedList, nonexhaustive, nonNullable } from "@likec4/core";
+import { FqnRef } from "@likec4/core/types";
 import { loggable } from "@likec4/log";
 import { filter, first, isDefined, isEmpty, isNonNullish, isTruthy, map, mapToObj, pipe } from "remeda";
 import {
   ast,
-  toElementStyle,
   toRelationshipStyleExcludeDefaults
 } from "../../ast.js";
 import { logger as mainLogger } from "../../logger.js";
-import { elementRef } from "../../utils/elementRef.js";
 import { stringHash } from "../../utils/stringHash.js";
 import { removeIndent, toSingleLine } from "./Base.js";
 const logger = mainLogger.getChild("ModelParser");
-function resolveRelationPoints(node) {
-  const target = elementRef(node.target);
-  if (!target) {
-    throw new Error("RelationRefError: Invalid reference to target");
-  }
-  if (isDefined(node.source)) {
-    const source = elementRef(node.source);
-    if (!source) {
-      throw new Error("RelationRefError: Invalid reference to source");
-    }
-    return {
-      source,
-      target
-    };
-  }
-  if (!ast.isElementBody(node.$container)) {
-    throw new Error("RelationRefError: Invalid container for sourceless relation");
-  }
-  return {
-    source: node.$container.$container,
-    target
-  };
-}
 function* streamModel(doc) {
   const traverseStack = LinkedList.from(doc.parseResult.value.models.flatMap((m) => m.elements));
   const relations = [];
@@ -97,8 +73,7 @@ ${error}`, {
       const id = this.resolveFqn(astNode);
       const kind = nonNullable(astNode.kind.ref, "Element kind is not resolved").name;
       const tags = this.parseTags(astNode.body);
-      const stylePropsAst = astNode.body?.props.find(ast.isElementStyleProperty)?.props;
-      const style = toElementStyle(stylePropsAst, isValid);
+      const style = this.parseElementStyle(astNode.body?.props);
       const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
       const astPath = this.getAstNodePath(astNode);
       let [title, description, technology] = astNode.props ?? [];
@@ -112,13 +87,6 @@ ${error}`, {
       description = removeIndent(bodyProps.description ?? description);
       technology = toSingleLine(bodyProps.technology ?? technology);
       const links = this.parseLinks(astNode.body);
-      const iconProp = astNode.body?.props.find(ast.isIconProperty);
-      if (iconProp && isValid(iconProp)) {
-        const value = iconProp.libicon?.ref?.name ?? iconProp.value;
-        if (isTruthy(value)) {
-          style.icon = value;
-        }
-      }
       return {
         id,
         kind,
@@ -133,7 +101,6 @@ ${error}`, {
       };
     }
     parseExtendElement(astNode) {
-      const isValid = this.isValid;
       const id = this.resolveFqn(astNode);
       const tags = this.parseTags(astNode.body);
       const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
@@ -150,11 +117,24 @@ ${error}`, {
         ...links && isNonEmptyArray(links) && { links }
       };
     }
+    _resolveRelationSource(node) {
+      if (isDefined(node.source)) {
+        const source = this.parseFqnRef(node.source);
+        invariant(FqnRef.isModelRef(source) || FqnRef.isImportRef(source), "Relation source must be a model reference");
+        return source;
+      }
+      if (!ast.isElementBody(node.$container)) {
+        throw new Error("RelationRefError: Invalid container for sourceless relation");
+      }
+      return {
+        model: this.resolveFqn(node.$container.$container)
+      };
+    }
     parseRelation(astNode) {
       const isValid = this.isValid;
-      const coupling = resolveRelationPoints(astNode);
-      const target = this.resolveFqn(coupling.target);
-      const source = this.resolveFqn(coupling.source);
+      const source = this._resolveRelationSource(astNode);
+      const target = this.parseFqnRef(astNode.target);
+      invariant(FqnRef.isModelRef(target) || FqnRef.isImportRef(target), "Target must be a model reference");
       const tags = this.parseTags(astNode) ?? this.parseTags(astNode.body);
       const links = this.parseLinks(astNode.body);
       const kind = astNode.kind?.ref?.name;
@@ -177,8 +157,8 @@ ${error}`, {
       const styleProp = astNode.body?.props.find(ast.isRelationStyleProperty);
       const id = stringHash(
         astPath,
-        source,
-        target
+        source.model,
+        target.model
       );
       return {
         id,