@likec4/language-server 1.43.0 → 1.44.0

package/dist/model/parser/DeploymentModelParser.js

@@ -0,0 +1,176 @@
+import { exact, FqnRef, invariant, isNonEmptyArray, LinkedList, nameFromFqn, nonexhaustive, nonNullable, } from '@likec4/core';
+import { loggable } from '@likec4/log';
+import { filter, first, isDefined, isEmpty, isTruthy, mapToObj, pipe } from 'remeda';
+import { ast, toRelationshipStyle, } from '../../ast';
+import { serverLogger } from '../../logger';
+import { stringHash } from '../../utils/stringHash';
+const logger = serverLogger.getChild('DeploymentModelParser');
+function* streamDeploymentModel(doc) {
+    const traverseStack = LinkedList.from(doc.parseResult.value.deployments.flatMap(m => m.elements));
+    const relations = [];
+    let el;
+    while ((el = traverseStack.shift())) {
+        if (ast.isDeploymentRelation(el)) {
+            relations.push(el);
+            continue;
+        }
+        if (el.body && el.body.elements.length > 0) {
+            for (const child of el.body.elements) {
+                traverseStack.push(child);
+            }
+        }
+        yield el;
+    }
+    yield* relations;
+    return;
+}
+export function DeploymentModelParser(B) {
+    return class DeploymentModelParser extends B {
+        parseDeployment() {
+            const doc = this.doc;
+            for (const el of streamDeploymentModel(doc)) {
+                try {
+                    switch (true) {
+                        case ast.isDeploymentRelation(el): {
+                            if (this.isValid(el)) {
+                                doc.c4DeploymentRelations.push(this.parseDeploymentRelation(el));
+                            }
+                            break;
+                        }
+                        case ast.isDeployedInstance(el):
+                            doc.c4Deployments.push(this.parseDeployedInstance(el));
+                            break;
+                        case ast.isDeploymentNode(el): {
+                            doc.c4Deployments.push(this.parseDeploymentNode(el));
+                            break;
+                        }
+                        case ast.isExtendDeployment(el): {
+                            const parsed = this.parseExtendDeployment(el);
+                            if (parsed) {
+                                doc.c4ExtendDeployments.push(parsed);
+                            }
+                            break;
+                        }
+                        default:
+                            nonexhaustive(el);
+                    }
+                }
+                catch (e) {
+                    logger.warn(loggable(e));
+                }
+            }
+        }
+        parseDeploymentNode(astNode) {
+            const isValid = this.isValid;
+            const id = this.resolveFqn(astNode);
+            const kind = nonNullable(astNode.kind.ref, 'DeploymentKind not resolved').name;
+            const tags = this.convertTags(astNode.body);
+            const style = this.parseElementStyle(astNode.body?.props);
+            const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
+            const bodyProps = pipe(astNode.body?.props ?? [], filter(isValid), filter(ast.isElementStringProperty), mapToObj(p => [p.key, p.value]));
+            const { title, ...descAndTech } = this.parseBaseProps(bodyProps, {
+                title: astNode.title,
+                summary: astNode.summary,
+            });
+            const links = this.convertLinks(astNode.body);
+            return exact({
+                id,
+                kind,
+                title: title ?? nameFromFqn(id),
+                ...descAndTech,
+                tags: tags ?? undefined,
+                ...(links && isNonEmptyArray(links) && { links }),
+                style,
+                metadata,
+            });
+        }
+        parseDeployedInstance(astNode) {
+            const isValid = this.isValid;
+            const id = this.resolveFqn(astNode);
+            const target = this.parseFqnRef(astNode.target.modelElement);
+            invariant(FqnRef.isModelRef(target) || FqnRef.isImportRef(target), 'Target must be a model reference');
+            // const element = FqnRef.toModelFqn(target)
+            const tags = this.convertTags(astNode.body);
+            const style = this.parseElementStyle(astNode.body?.props);
+            const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
+            const bodyProps = pipe(astNode.body?.props ?? [], filter(isValid), filter(ast.isElementStringProperty), mapToObj(p => [p.key, p.value]));
+            const baseProps = this.parseBaseProps(bodyProps, {
+                title: astNode.title,
+                summary: astNode.summary,
+            });
+            const links = this.convertLinks(astNode.body);
+            return exact({
+                id,
+                element: target,
+                tags: tags ?? undefined,
+                ...(links && isNonEmptyArray(links) && { links }),
+                ...baseProps,
+                style,
+                metadata,
+            });
+        }
+        parseExtendDeployment(astNode) {
+            if (!this.isValid(astNode)) {
+                return null;
+            }
+            const id = this.resolveFqn(astNode);
+            const tags = this.parseTags(astNode.body);
+            const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
+            const astPath = this.getAstNodePath(astNode);
+            const links = this.parseLinks(astNode.body) ?? [];
+            if (!tags && isEmpty(metadata ?? {}) && isEmpty(links)) {
+                return null;
+            }
+            return {
+                id,
+                astPath,
+                ...(metadata && { metadata }),
+                tags,
+                links: isNonEmptyArray(links) ? links : null,
+            };
+        }
+        _resolveDeploymentRelationSource(node) {
+            if (isDefined(node.source)) {
+                return this.parseFqnRef(node.source);
+            }
+            if (node.$container.$type === 'DeploymentNodeBody' || node.$container.$type === 'DeployedInstanceBody') {
+                return {
+                    deployment: this.resolveFqn(node.$container.$container),
+                };
+            }
+            throw new Error('RelationRefError: Invalid container for sourceless relation');
+        }
+        parseDeploymentRelation(astNode) {
+            const isValid = this.isValid;
+            const astPath = this.getAstNodePath(astNode);
+            const source = this._resolveDeploymentRelationSource(astNode);
+            invariant(FqnRef.isDeploymentRef(source), 'Invalid source for deployment relation');
+            const target = this.parseFqnRef(astNode.target);
+            invariant(FqnRef.isDeploymentRef(target), 'Invalid target for deployment relation');
+            const tags = this.convertTags(astNode) ?? this.convertTags(astNode.body);
+            const links = this.convertLinks(astNode.body);
+            const kind = (astNode.kind ?? astNode.dotKind?.kind)?.ref?.name;
+            const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
+            const bodyProps = pipe(astNode.body?.props ?? [], filter(ast.isRelationStringProperty), filter(p => isTruthy(p.value)), mapToObj(p => [p.key, p.value]));
+            const navigateTo = pipe(astNode.body?.props ?? [], filter(ast.isRelationNavigateToProperty), first())?.value.view.ref?.name;
+            const titleDescAndTech = this.parseBaseProps(bodyProps, {
+                title: astNode.title,
+            });
+            const styleProp = astNode.body?.props.find(ast.isRelationStyleProperty);
+            const id = stringHash('deployment', astPath, source.deployment, target.deployment);
+            return exact({
+                id,
+                source,
+                target,
+                ...titleDescAndTech,
+                metadata,
+                kind,
+                tags: tags ?? undefined,
+                ...(isNonEmptyArray(links) && { links }),
+                ...toRelationshipStyle(styleProp?.props, isValid),
+                navigateTo,
+                astPath,
+            });
+        }
+    };
+}

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

@@ -31,14 +31,14 @@ export declare function DeploymentViewParser<TBase extends WithExpressionV2 & Wi
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
         get project(): import("../../workspace").Project;
         resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
-        getAstNodePath(node: c4): any;
+        getAstNodePath(node: import("langium").AstNode): string;
         getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
             [key: string]: string | string[];
         } | undefined;
         parseMarkdownOrString(markdownOrString: ast.MarkdownOrString | undefined): c4.MarkdownOrString | undefined;
         convertTags<E extends {
             tags?: ast.Tags;
-        }>(withTags?: E | undefined): any;
+        }>(withTags?: E | undefined): c4.NonEmptyArray<c4.Tag<string>> | null;
         parseTags<E extends {
             tags?: ast.Tags;
         }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
@@ -69,7 +69,7 @@ export declare function DeploymentViewParser<TBase extends WithExpressionV2 & Wi
         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;
+        _resolveDeploymentRelationSource(node: ast.DeploymentRelation): c4.FqnRef;
         parseDeploymentRelation(astNode: ast.DeploymentRelation): import("../../ast").ParsedAstDeploymentRelation;
     };
 } & TBase;

package/dist/model/parser/DeploymentViewParser.js

@@ -0,0 +1,86 @@
+import * as c4 from '@likec4/core';
+import { invariant, isNonEmptyArray, nonexhaustive } from '@likec4/core';
+import { filter, isNonNullish, mapToObj, pipe } from 'remeda';
+import { ast, parseMarkdownAsString, toAutoLayout, ViewOps } from '../../ast';
+import { logWarnError } from '../../logger';
+import { stringHash } from '../../utils';
+import { parseViewManualLayout } from '../../view-utils/manual-layout';
+import { removeIndent, toSingleLine } from './Base';
+export function DeploymentViewParser(B) {
+    return class DeploymentViewParser extends B {
+        parseDeploymentView(astNode) {
+            const body = astNode.body;
+            invariant(body, 'DynamicElementView body is not defined');
+            // only valid props
+            const props = body.props.filter(this.isValid);
+            const astPath = this.getAstNodePath(astNode);
+            let id = astNode.name;
+            if (!id) {
+                id = 'deployment_' + stringHash(this.doc.uri.toString(), astPath);
+            }
+            const { title = null, description = null, } = this.parseBaseProps(pipe(props, filter(ast.isViewStringProperty), mapToObj(p => [p.key, p.value])));
+            const tags = this.convertTags(body);
+            const links = this.convertLinks(body);
+            ViewOps.writeId(astNode, id);
+            const manualLayout = parseViewManualLayout(astNode);
+            return {
+                [c4._type]: 'deployment',
+                id: id,
+                astPath,
+                title: toSingleLine(title) ?? null,
+                description,
+                tags,
+                links: isNonEmptyArray(links) ? links : null,
+                rules: body.rules.flatMap(n => {
+                    try {
+                        return this.isValid(n) ? this.parseDeploymentViewRule(n) : [];
+                    }
+                    catch (e) {
+                        logWarnError(e);
+                        return [];
+                    }
+                }),
+                ...(manualLayout && { manualLayout }),
+            };
+        }
+        parseDeploymentViewRule(astRule) {
+            if (ast.isDeploymentViewRulePredicate(astRule)) {
+                return this.parseDeploymentViewRulePredicate(astRule);
+            }
+            if (ast.isViewRuleAutoLayout(astRule)) {
+                return toAutoLayout(astRule);
+            }
+            if (ast.isDeploymentViewRuleStyle(astRule)) {
+                return this.parseDeploymentViewRuleStyle(astRule);
+            }
+            nonexhaustive(astRule);
+        }
+        parseDeploymentViewRulePredicate(astRule) {
+            const exprs = [];
+            let iterator = astRule.expr;
+            while (iterator) {
+                try {
+                    const expr = iterator.value;
+                    if (isNonNullish(expr) && this.isValid(expr)) {
+                        exprs.unshift(this.parseExpressionV2(expr));
+                    }
+                }
+                catch (e) {
+                    logWarnError(e);
+                }
+                iterator = iterator.prev;
+            }
+            return astRule.isInclude ? { include: exprs } : { exclude: exprs };
+        }
+        parseDeploymentViewRuleStyle(astRule) {
+            const style = this.parseStyleProps(astRule.props.filter(ast.isStyleProperty));
+            const notation = removeIndent(parseMarkdownAsString(astRule.props.find(ast.isNotationProperty)?.value));
+            const targets = this.parseFqnExpressions(astRule.targets);
+            return {
+                targets,
+                style,
+                ...(notation && { notation }),
+            };
+        }
+    };
+}

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

@@ -28,14 +28,14 @@ export declare function ExpressionV2Parser<TBase extends Base>(B: TBase): {
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
         get project(): import("../../workspace").Project;
         resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
-        getAstNodePath(node: AstNode): any;
+        getAstNodePath(node: AstNode): string;
         getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
             [key: string]: string | string[];
         } | undefined;
         parseMarkdownOrString(markdownOrString: ast.MarkdownOrString | undefined): c4.MarkdownOrString | undefined;
         convertTags<E extends {
             tags?: ast.Tags;
-        }>(withTags?: E | undefined): any;
+        }>(withTags?: E | undefined): c4.NonEmptyArray<c4.Tag<string>> | null;
         parseTags<E extends {
             tags?: ast.Tags;
         }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;

package/dist/model/parser/FqnRefParser.js

@@ -0,0 +1,382 @@
+import { invariant, nonexhaustive, nonNullable } from '@likec4/core';
+import { loggable } from '@likec4/log';
+import { AstUtils } from 'langium';
+import { isBoolean, isDefined, isNonNullish, isTruthy } from 'remeda';
+import { ast, parseAstOpacityProperty, parseAstSizeValue, parseMarkdownAsString, toColor } from '../../ast';
+import { serverLogger } from '../../logger';
+import { projectIdFrom } from '../../utils';
+import { importsRef, instanceRef } from '../../utils/fqnRef';
+import { createBinaryOperator, parseWhereClause } from '../model-parser-where';
+import { removeIndent } from './Base';
+const logger = serverLogger.getChild('ExpressionV2Parser');
+const location = (astNode) => {
+    const cst = astNode.$cstNode;
+    const position = cst ? `:${cst.range.start.line + 1}:${cst.range.start.character + 1}` : '';
+    return `${AstUtils.getDocument(astNode).uri.fsPath}${position}`;
+};
+export function ExpressionV2Parser(B) {
+    return class ExpressionV2Parser extends B {
+        parseFqnRef(astNode) {
+            const refValue = nonNullable(astNode.value?.ref, () => `FqnRef "${astNode.$cstNode?.text}" is empty at ${location(astNode)}`);
+            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 {
+                        model: this.resolveFqn(refValue),
+                    };
+                }
+                const deployment = this.resolveFqn(deployedInstanceAst);
+                const element = this.resolveFqn(refValue);
+                return {
+                    deployment,
+                    element,
+                };
+            }
+            if (ast.isDeploymentElement(refValue)) {
+                return {
+                    deployment: this.resolveFqn(refValue),
+                };
+            }
+            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) && prop.key !== 'summary') {
+                        if (prop.key === 'description') {
+                            const parsed = this.parseMarkdownOrString(prop.value);
+                            if (parsed) {
+                                acc.custom['description'] = parsed;
+                            }
+                        }
+                        else {
+                            acc.custom[prop.key] = removeIndent(parseMarkdownAsString(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)) {
+                    const value = isTruthy(prop.value) ? removeIndent(parseMarkdownAsString(prop.value)) : undefined;
+                    if (value) {
+                        acc.custom[prop.key] = 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.tag.ref, 'ElementTagExpr tag is not resolved: ' + astNode.$cstNode?.text);
+                let elementTag = astNode.tag.tag.$refText;
+                return {
+                    elementTag: elementTag,
+                    isEqual: astNode.isEqual,
+                };
+            }
+            if (ast.isFqnRefExpr(astNode)) {
+                return this.parseFqnRefExpr(astNode);
+            }
+            nonexhaustive(astNode);
+        }
+        parseFqnRefExpr(astNode) {
+            const ref = this.parseFqnRef(astNode.ref);
+            switch (true) {
+                case astNode.selector === '._':
+                    return {
+                        ref,
+                        selector: 'expanded',
+                    };
+                case astNode.selector === '.**':
+                    return {
+                        ref,
+                        selector: 'descendants',
+                    };
+                case astNode.selector === '.*':
+                    return {
+                        ref,
+                        selector: 'children',
+                    };
+                default:
+                    return { ref };
+            }
+        }
+        parseFqnExpressions(astNode) {
+            const exprs = [];
+            let iter = astNode;
+            while (iter) {
+                try {
+                    if (isNonNullish(iter.value) && this.isValid(iter.value)) {
+                        exprs.push(this.parseFqnExpr(iter.value));
+                    }
+                }
+                catch (e) {
+                    logger.warn(loggable(e));
+                }
+                iter = iter.prev;
+            }
+            return exprs.reverse();
+        }
+        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 customProps = this.parseCustomRelationProperties(astNode.custom);
+            return {
+                customRelation: {
+                    ...customProps,
+                    expr,
+                },
+            };
+        }
+        parseCustomRelationProperties(custom) {
+            const props = custom?.props ?? [];
+            return props.reduce((acc, prop) => {
+                if (ast.isRelationStringProperty(prop) || ast.isNotationProperty(prop) || ast.isNotesProperty(prop)) {
+                    const value = isTruthy(prop.value) ? removeIndent(parseMarkdownAsString(prop.value)) : undefined;
+                    if (value) {
+                        acc[prop.key] = value;
+                    }
+                    return acc;
+                }
+                if (ast.isArrowProperty(prop)) {
+                    if (isTruthy(prop.value)) {
+                        acc[prop.key] = prop.value;
+                    }
+                    return acc;
+                }
+                if (ast.isColorProperty(prop)) {
+                    const value = toColor(prop);
+                    if (isTruthy(value)) {
+                        acc[prop.key] = value;
+                    }
+                    return acc;
+                }
+                if (ast.isLineProperty(prop)) {
+                    if (isTruthy(prop.value)) {
+                        acc[prop.key] = prop.value;
+                    }
+                    return acc;
+                }
+                if (ast.isRelationNavigateToProperty(prop)) {
+                    const viewId = prop.value.view.ref?.name;
+                    if (isTruthy(viewId)) {
+                        acc[prop.key] = viewId;
+                    }
+                    return acc;
+                }
+                nonexhaustive(prop);
+            }, {});
+        }
+        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');
+            const relationOrWhereExpr = this.parseRelationExpr(astNode.subject);
+            const expr = relationOrWhereExpr.where?.expr ?? relationOrWhereExpr;
+            const kindCondition = relationOrWhereExpr.where?.condition;
+            const whereCondition = astNode.where ? parseWhereClause(astNode.where) : null;
+            let condition;
+            if (whereCondition && kindCondition) {
+                condition = createBinaryOperator('and', kindCondition, whereCondition);
+            }
+            else {
+                condition = whereCondition
+                    ?? kindCondition
+                    ?? { kind: { neq: '--always-true--' } };
+            }
+            return {
+                where: {
+                    expr: expr,
+                    condition: condition,
+                },
+            };
+        }
+        parseRelationExpr(astNode) {
+            switch (astNode.$type) {
+                case 'DirectedRelationExpr':
+                    return this.wrapInWhere({
+                        source: this.parseFqnExpr(astNode.source.from),
+                        target: this.parseFqnExpr(astNode.target),
+                        isBidirectional: astNode.source.isBidirectional,
+                    }, this.parseInlineKindCondition(astNode.source));
+                case 'InOutRelationExpr':
+                    return {
+                        inout: this.parseFqnExpr(astNode.inout.to),
+                    };
+                case 'OutgoingRelationExpr':
+                    return this.wrapInWhere({ outgoing: this.parseFqnExpr(astNode.from) }, this.parseInlineKindCondition(astNode));
+                case 'IncomingRelationExpr':
+                    return {
+                        incoming: this.parseFqnExpr(astNode.to),
+                    };
+                default:
+                    nonexhaustive(astNode);
+            }
+        }
+        parseInlineKindCondition(astNode) {
+            const kind = astNode.kind ?? astNode.dotKind?.kind;
+            if (kind) {
+                invariant(kind.ref, 'Kind is not resolved: ' + astNode.$cstNode?.text);
+                return { kind: { eq: kind.ref?.name } };
+            }
+            return null;
+        }
+        wrapInWhere(expr, condition) {
+            return condition ? { where: { expr, condition } } : expr;
+        }
+    };
+}