@likec4/language-server 1.46.4 → 1.48.0

package/dist/model/model-builder.d.ts

@@ -1,52 +0,0 @@
-import { type LayoutedView, type ProjectId, type UnknownComputed, type UnknownParsed, type ViewId } from '@likec4/core';
-import { LikeC4Model } from '@likec4/core/model';
-import type * as c4 from '@likec4/core/types';
-import { type URI, Disposable } from 'langium';
-import type { CancellationToken } from 'vscode-jsonrpc';
-import type { LikeC4Services } from '../module';
-import { ADisposable } from '../utils';
-type ModelParsedListener = (docs: URI[]) => void;
-type ManualLayouts = Record<ViewId, LayoutedView> | null;
-export interface LikeC4ModelBuilder extends Disposable {
-    parseModel(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model<UnknownParsed> | null>;
-    unsafeSyncComputeModel(projectId: ProjectId): LikeC4Model<UnknownComputed>;
-    computeModel(projectId?: ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model<UnknownComputed>>;
-    onModelParsed(callback: ModelParsedListener): Disposable;
-    clearCache(): void;
-}
-export declare class DefaultLikeC4ModelBuilder extends ADisposable implements LikeC4ModelBuilder {
-    private projects;
-    private parser;
-    private listeners;
-    private cache;
-    private DocumentBuilder;
-    private manualLayouts;
-    private mutex;
-    constructor(services: LikeC4Services);
-    /**
-     * WARNING:
-     * This method is internal and should to be called only when all documents are known to be parsed.
-     * Otherwise, the model may be incomplete.
-     *
-     * To avoid circular dependencies, we do not resolve imports here.
-     */
-    private unsafeSyncParseModelData;
-    /**
-     * To avoid circular dependencies, first we parse all documents and then we join them.
-     */
-    private unsafeSyncJoinedModel;
-    parseModel(projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model<UnknownParsed> | null>;
-    private previousViews;
-    /**
-     * WARNING:
-     * This method is internal and should to be called only when all documents are known to be parsed.
-     * Otherwise, the model may be incomplete.
-     */
-    unsafeSyncComputeModel(projectId: c4.ProjectId, manualLayouts?: ManualLayouts): LikeC4Model<UnknownComputed>;
-    computeModel(projectId?: c4.ProjectId | undefined, cancelToken?: CancellationToken): Promise<LikeC4Model<UnknownComputed>>;
-    onModelParsed(callback: ModelParsedListener): Disposable;
-    clearCache(): void;
-    private documents;
-    private notifyListeners;
-}
-export {};

package/dist/model/model-builder.js

@@ -1,224 +0,0 @@
-import { _stage, } from '@likec4/core';
-import { computeView } from '@likec4/core/compute-view';
-import { LikeC4Model } from '@likec4/core/model';
-import { loggable } from '@likec4/log';
-import { deepEqual as eq } from 'fast-equals';
-import { Disposable, DocumentState, interruptAndCheck, WorkspaceCache, } from 'langium';
-import { flatMap, hasAtLeast, isEmpty, mapToObj, pipe, values, } from 'remeda';
-import { isLikeC4Builtin } from '../likec4lib';
-import { logger as mainLogger } from '../logger';
-import { ADisposable, performanceMark } from '../utils';
-import { assignNavigateTo } from '../view-utils';
-import { buildModelData } from './builder/buildModel';
-const parsedWithoutImportsCacheKey = (projectId) => `parsed-without-imports-${projectId}`;
-const parsedModelCacheKey = (projectId) => `parsed-model-${projectId}`;
-const computedModelCacheKey = (projectId) => `computed-model-${projectId}`;
-const builderLogger = mainLogger.getChild('model-builder');
-export class DefaultLikeC4ModelBuilder extends ADisposable {
-    projects;
-    parser;
-    listeners = [];
-    cache;
-    DocumentBuilder;
-    manualLayouts;
-    mutex;
-    constructor(services) {
-        super();
-        this.projects = services.shared.workspace.ProjectsManager;
-        this.parser = services.likec4.ModelParser;
-        this.cache = services.shared.workspace.Cache;
-        this.DocumentBuilder = services.shared.workspace.DocumentBuilder;
-        this.mutex = services.shared.workspace.WorkspaceLock;
-        this.manualLayouts = services.likec4.ManualLayouts;
-        this.onDispose(this.DocumentBuilder.onUpdate((_changed, deleted) => {
-            if (deleted.length > 0) {
-                this.notifyListeners(deleted);
-            }
-        }));
-        this.onDispose(this.DocumentBuilder.onBuildPhase(DocumentState.Validated, (docs, _cancelToken) => {
-            const validated = docs.flatMap(d => isLikeC4Builtin(d.uri) || this.projects.isExcluded(d) ? [] : d.uri);
-            if (validated.length > 0) {
-                this.notifyListeners(validated);
-            }
-        }));
-        builderLogger.debug `created`;
-    }
-    /**
-     * WARNING:
-     * This method is internal and should to be called only when all documents are known to be parsed.
-     * Otherwise, the model may be incomplete.
-     *
-     * To avoid circular dependencies, we do not resolve imports here.
-     */
-    unsafeSyncParseModelData(projectId) {
-        const cache = this.cache;
-        const logger = builderLogger.getChild(projectId);
-        const key = parsedWithoutImportsCacheKey(projectId);
-        if (cache.has(key)) {
-            logger.debug `unsafeSyncParseModelData: from cache`;
-        }
-        return cache.get(key, () => {
-            try {
-                const project = this.projects.getProject(projectId);
-                const docs = this.documents(projectId);
-                if (docs.length === 0) {
-                    logger.debug `unsafeSyncParseModelData: skipped due to no documents`;
-                    return null;
-                }
-                logger.debug `unsafeSyncParseModelData: completed`;
-                return buildModelData(project, docs);
-            }
-            catch (err) {
-                builderLogger.warn(`unsafeSyncParseModelData failed for project ${projectId}`, { err });
-                return null;
-            }
-        });
-    }
-    /**
-     * To avoid circular dependencies, first we parse all documents and then we join them.
-     */
-    unsafeSyncJoinedModel(projectId) {
-        const logger = builderLogger.getChild(projectId);
-        const cache = this.cache;
-        const key = parsedModelCacheKey(projectId);
-        if (cache.has(key)) {
-            logger.debug `unsafeSyncJoinedModel from cache`;
-        }
-        return cache.get(key, () => {
-            const result = this.unsafeSyncParseModelData(projectId);
-            if (!result) {
-                return null;
-            }
-            let parsedData = result.data;
-            if (result.imports.size > 0) {
-                logger.debug `processing imports of ${projectId}`;
-                const imports = [...result.imports.associations()].reduce((acc, [projectId, fqns]) => {
-                    const anotherProject = this.unsafeSyncParseModelData(projectId);
-                    if (anotherProject) {
-                        const imported = pipe([...fqns], flatMap(fqn => anotherProject.data.elements[fqn] ?? []));
-                        if (hasAtLeast(imported, 1)) {
-                            acc[projectId] = imported;
-                        }
-                    }
-                    return acc;
-                }, {});
-                parsedData = {
-                    ...result.data,
-                    imports,
-                };
-            }
-            return LikeC4Model.create(parsedData);
-        });
-    }
-    async parseModel(projectId, cancelToken) {
-        projectId = this.projects.ensureProjectId(projectId);
-        const logger = builderLogger.getChild(projectId);
-        const t0 = performanceMark();
-        return await this.mutex.read(async () => {
-            if (cancelToken?.isCancellationRequested) {
-                await interruptAndCheck(cancelToken);
-            }
-            const parsedModel = this.unsafeSyncJoinedModel(projectId);
-            logger.debug `parseModel in ${t0.pretty}`;
-            return parsedModel;
-        });
-    }
-    previousViews = {};
-    /**
-     * WARNING:
-     * This method is internal and should to be called only when all documents are known to be parsed.
-     * Otherwise, the model may be incomplete.
-     */
-    unsafeSyncComputeModel(projectId, manualLayouts) {
-        const logger = builderLogger.getChild(projectId);
-        const cache = this.cache;
-        const hasManualLayouts = !!manualLayouts && !isEmpty(manualLayouts);
-        const key = computedModelCacheKey(projectId) + (hasManualLayouts ? '+manualLayouts' : '');
-        if (cache.has(key)) {
-            logger.debug `unsafeSyncBuildModel: from cache`;
-        }
-        return cache.get(key, () => {
-            const parsedModel = this.unsafeSyncJoinedModel(projectId);
-            if (!parsedModel) {
-                return LikeC4Model.EMPTY.asComputed;
-            }
-            const allViews = [];
-            for (const view of values(parsedModel.$data.views)) {
-                const result = computeView(view, parsedModel);
-                if (!result.isSuccess) {
-                    logger.warn(loggable(result.error));
-                    continue;
-                }
-                if (manualLayouts?.[view.id]) {
-                    Object.assign(result.view, 
-                    // satisfies enforces that the object has the property
-                    { hasManualLayout: true });
-                }
-                allViews.push(result.view);
-            }
-            assignNavigateTo(allViews);
-            const views = mapToObj(allViews, v => {
-                const key = computedViewKey(projectId, v.id);
-                const previous = this.previousViews[key];
-                const view = previous && eq(v, previous) ? previous : v;
-                this.previousViews[key] = view;
-                return [v.id, view];
-            });
-            const data = {
-                ...parsedModel.$data,
-                [_stage]: 'computed',
-                views,
-            };
-            if (hasManualLayouts) {
-                data.manualLayouts = manualLayouts;
-            }
-            logger.debug `unsafeSyncBuildModel: completed`;
-            return LikeC4Model.create(data);
-        });
-    }
-    async computeModel(projectId, cancelToken) {
-        projectId = this.projects.ensureProjectId(projectId);
-        const logger = builderLogger.getChild(projectId);
-        const t0 = performanceMark();
-        return await this.mutex.read(async () => {
-            if (cancelToken?.isCancellationRequested) {
-                await interruptAndCheck(cancelToken);
-            }
-            const project = this.projects.getProject(projectId);
-            const manualLayouts = await this.manualLayouts.read(project);
-            const result = this.unsafeSyncComputeModel(projectId, manualLayouts);
-            logger.debug(`computeModel in ${t0.pretty}`);
-            return result;
-        });
-    }
-    onModelParsed(callback) {
-        this.listeners.push(callback);
-        return Disposable.create(() => {
-            const index = this.listeners.indexOf(callback);
-            if (index >= 0) {
-                this.listeners.splice(index, 1);
-            }
-        });
-    }
-    clearCache() {
-        builderLogger.debug(`clearCache`);
-        this.cache.clear();
-        this.previousViews = {};
-    }
-    documents(projectId) {
-        return this.parser.documents(projectId).toArray();
-    }
-    notifyListeners(docs) {
-        for (const listener of this.listeners) {
-            try {
-                listener(docs);
-            }
-            catch (e) {
-                builderLogger.warn(loggable(e));
-            }
-        }
-    }
-}
-function computedViewKey(projectId, viewId) {
-    return `computed-view-${projectId}-${viewId}`;
-}

package/dist/model/model-locator.d.ts

@@ -1,39 +0,0 @@
-import type * as c4 from '@likec4/core';
-import type { Cancellation } from 'langium';
-import type { Location, Range } from 'vscode-languageserver-types';
-import { URI } from 'vscode-uri';
-import type { ParsedAstElement, ParsedAstView, ParsedLikeC4LangiumDocument } from '../ast';
-import { ast } from '../ast';
-import type { LikeC4Services } from '../module';
-export type ViewLocateResult = {
-    doc: ParsedLikeC4LangiumDocument;
-    view: ParsedAstView;
-    viewAst: ast.LikeC4View;
-};
-export declare class LikeC4ModelLocator {
-    private services;
-    private fqnIndex;
-    private deploymentsIndex;
-    private langiumDocuments;
-    private parser;
-    private projects;
-    constructor(services: LikeC4Services);
-    private documents;
-    getParsedElement(...args: [ast.Element] | [c4.Fqn] | [c4.Fqn, c4.ProjectId]): ParsedAstElement | null;
-    locateElement(fqn: c4.Fqn, projectId?: c4.ProjectId | undefined): Location | null;
-    locateDeploymentElement(deploymentFqn: c4.DeploymentFqn, projectId?: c4.ProjectId | undefined): Location | null;
-    locateRelation(relationId: c4.RelationId, projectId?: c4.ProjectId): Location | null;
-    locateViewAst(viewId: c4.ViewId, projectId?: c4.ProjectId | undefined): null | ViewLocateResult;
-    locateView(viewId: c4.ViewId, projectId?: c4.ProjectId): Location | null;
-    locateDocumentTags(documentUri: URI, cancelToken?: Cancellation.CancellationToken): Promise<Array<{
-        name: string;
-        color: string;
-        range: Range;
-        isSpecification: boolean;
-    }>>;
-    locateDynamicViewStep(params: {
-        view: c4.ViewId;
-        astPath: string;
-        projectId?: c4.ProjectId | undefined;
-    }): Location | null;
-}

package/dist/model/model-locator.js

@@ -1,240 +0,0 @@
-import { splitGlobalFqn } from '@likec4/core';
-import { ifilter, invariant, toArray } from '@likec4/core/utils';
-import { loggable } from '@likec4/log';
-import { AstUtils, DocumentState, GrammarUtils } from 'langium';
-import { flatMap, isString, pipe } from 'remeda';
-import { URI } from 'vscode-uri';
-import { ast, isLikeC4LangiumDocument } from '../ast';
-import { logger as serverLogger } from '../logger';
-import { projectIdFrom } from '../utils';
-import { MergedSpecification } from './builder/MergedSpecification';
-const { findNodeForKeyword, findNodeForProperty } = GrammarUtils;
-const { getDocument, streamAllContents } = AstUtils;
-const logger = serverLogger.getChild('ModelLocator');
-export class LikeC4ModelLocator {
-    services;
-    fqnIndex;
-    deploymentsIndex;
-    langiumDocuments;
-    parser;
-    projects;
-    constructor(services) {
-        this.services = services;
-        this.fqnIndex = services.likec4.FqnIndex;
-        this.deploymentsIndex = services.likec4.DeploymentsIndex;
-        this.langiumDocuments = services.shared.workspace.LangiumDocuments;
-        this.parser = services.likec4.ModelParser;
-        this.projects = services.shared.workspace.ProjectsManager;
-    }
-    documents(projectId) {
-        return this.parser.documents(projectId);
-    }
-    // public getParsedElement(astNodeOrFqn: ast.Element): ParsedAstElement | null
-    // public getParsedElement(astNodeOrFqn: c4.Fqn, projectId?: c4.ProjectId): ParsedAstElement | null
-    getParsedElement(...args) {
-        let astNodeOrFqn;
-        let projectId;
-        if (args.length === 2) {
-            astNodeOrFqn = args[0];
-            projectId = args[1];
-        }
-        else {
-            astNodeOrFqn = args[0];
-            projectId = isString(astNodeOrFqn) ? this.projects.ensureProjectId() : projectIdFrom(astNodeOrFqn);
-        }
-        if (isString(astNodeOrFqn)) {
-            const fqn = astNodeOrFqn;
-            const entry = this.fqnIndex.byFqn(projectId, fqn).head();
-            if (!entry) {
-                return null;
-            }
-            const doc = this.langiumDocuments.getDocument(entry.documentUri);
-            if (!doc) {
-                return null;
-            }
-            return this.parser.parse(doc).c4Elements.find(e => e.id === fqn) ?? null;
-        }
-        const fqn = this.fqnIndex.getFqn(astNodeOrFqn);
-        const doc = this.parser.parse(getDocument(astNodeOrFqn));
-        return doc.c4Elements.find(e => e.id === fqn) ?? null;
-    }
-    locateElement(fqn, projectId) {
-        let [_projectId, _fqn] = splitGlobalFqn(fqn);
-        _projectId ??= this.projects.ensureProjectId(projectId);
-        const entry = this.fqnIndex.byFqn(_projectId, _fqn).head();
-        const docsegment = entry?.nameSegment ?? entry?.selectionSegment;
-        if (!entry || !docsegment) {
-            return null;
-        }
-        return {
-            uri: entry.documentUri.toString(),
-            range: docsegment.range,
-        };
-    }
-    locateDeploymentElement(deploymentFqn, projectId) {
-        // let [_projectId, _fqn] = splitGlobalFqn(fqn)
-        const _projectId = this.projects.ensureProjectId(projectId);
-        // TODO: remove this cast to Fqn
-        const fqn = deploymentFqn;
-        const entry = this.deploymentsIndex.byFqn(_projectId, fqn).head();
-        const docsegment = entry?.nameSegment ?? entry?.selectionSegment;
-        if (!entry || !docsegment) {
-            return null;
-        }
-        return {
-            uri: entry.documentUri.toString(),
-            range: docsegment.range,
-        };
-    }
-    locateRelation(relationId, projectId) {
-        const project = this.projects.ensureProjectId(projectId);
-        for (const doc of this.documents(project)) {
-            const relation = doc.c4Relations.find(r => r.id === relationId)
-                ?? doc.c4DeploymentRelations.find(r => r.id === relationId);
-            if (!relation) {
-                continue;
-            }
-            const node = this.services.workspace.AstNodeLocator.getAstNode(doc.parseResult.value, relation.astPath);
-            if (!ast.isRelation(node) && !ast.isDeploymentRelation(node)) {
-                continue;
-            }
-            let targetNode = node.kind ? findNodeForProperty(node.$cstNode, 'kind') : undefined;
-            targetNode ??= node.dotKind ? findNodeForProperty(node.$cstNode, 'dotKind') : undefined;
-            targetNode ??= findNodeForKeyword(node.$cstNode, '->');
-            targetNode ??= findNodeForProperty(node.$cstNode, 'title');
-            targetNode ??= findNodeForProperty(node.$cstNode, 'target');
-            targetNode ??= node.$cstNode;
-            if (!targetNode) {
-                continue;
-            }
-            return {
-                uri: doc.uri.toString(),
-                range: {
-                    start: targetNode.range.start,
-                    end: targetNode.range.start,
-                },
-            };
-        }
-        return null;
-    }
-    locateViewAst(viewId, projectId) {
-        const project = this.projects.ensureProjectId(projectId);
-        for (const doc of this.documents(project)) {
-            const view = doc.c4Views.find(r => r.id === viewId);
-            if (!view) {
-                continue;
-            }
-            const viewAst = this.services.workspace.AstNodeLocator.getAstNode(doc.parseResult.value, view.astPath);
-            if (ast.isLikeC4View(viewAst)) {
-                return {
-                    doc,
-                    view,
-                    viewAst,
-                };
-            }
-        }
-        return null;
-    }
-    locateView(viewId, projectId) {
-        const res = this.locateViewAst(viewId, projectId);
-        if (!res) {
-            return null;
-        }
-        const node = res.viewAst;
-        let targetNode = node.name ? findNodeForProperty(node.$cstNode, 'name') : undefined;
-        targetNode ??= findNodeForKeyword(node.$cstNode, 'view');
-        targetNode ??= node.$cstNode;
-        if (!targetNode) {
-            return null;
-        }
-        return {
-            uri: res.doc.uri.toString(),
-            range: {
-                start: targetNode.range.start,
-                end: targetNode.range.start,
-            },
-        };
-    }
-    async locateDocumentTags(documentUri, cancelToken) {
-        const doc = this.langiumDocuments.getDocument(documentUri);
-        if (!doc || !isLikeC4LangiumDocument(doc)) {
-            return [];
-        }
-        if (doc.state < DocumentState.Validated) {
-            logger.debug(`Waiting for document ${doc.uri.path} to be Validated`);
-            await this.services.shared.workspace.DocumentBuilder.waitUntil(DocumentState.Validated, doc.uri, cancelToken);
-        }
-        const projectId = projectIdFrom(doc);
-        logger.debug(`locate document tags for ${doc.uri.path} in project ${projectId}`);
-        try {
-            const tagSpecs = new MergedSpecification(this.documents(projectId).toArray()).tags;
-            logger.debug(`Assigned colors to tags`, { tagSpecs });
-            const tags = pipe(streamAllContents(doc.parseResult.value), ifilter(astNode => ast.isTag(astNode) || ast.isTagRef(astNode)), toArray(), flatMap(tagRef => {
-                let name;
-                let $cstNode;
-                try {
-                    if (ast.isTag(tagRef)) {
-                        name = tagRef.name;
-                        $cstNode = tagRef.$cstNode;
-                    }
-                    else {
-                        name = tagRef.tag.$refText;
-                        $cstNode = tagRef.tag.$refNode;
-                    }
-                    const specification = tagSpecs[name];
-                    invariant(specification, `Tag ${name} not found in merged specification`);
-                    invariant($cstNode, `Tag ${name} does not have a $cstNode`);
-                    return {
-                        name,
-                        color: specification.color,
-                        range: $cstNode.range,
-                        isSpecification: ast.isTag(tagRef),
-                    };
-                }
-                catch (err) {
-                    logger.warn(`Fail on tag ${name}`, { err });
-                    return [];
-                }
-            }));
-            logger.debug(`Found ${tags.length} tags in document ${doc.uri.path}`);
-            return tags;
-        }
-        catch (e) {
-            logger.warn(loggable(e));
-            return [];
-        }
-    }
-    locateDynamicViewStep(params) {
-        const { doc, viewAst } = this.locateViewAst(params.view, params.projectId) ?? {};
-        if (!doc || !viewAst) {
-            return null;
-        }
-        if (!ast.isDynamicView(viewAst) || !viewAst.body) {
-            logger.warn(`View ${params.view} is not a dynamic view`);
-            return null;
-        }
-        const astPath = this.services.workspace.AstNodeLocator.getAstNodePath(viewAst.body) + params.astPath;
-        const node = this.services.workspace.AstNodeLocator.getAstNode(doc.parseResult.value, astPath);
-        if (!node || !ast.isDynamicViewStep(node)) {
-            logger.warn(`Failed to locate dynamic view step ${astPath} in view ${params.view}`);
-            return null;
-        }
-        let targetNode = node.kind ? findNodeForProperty(node.$cstNode, 'kind') : undefined;
-        targetNode ??= node.dotKind ? findNodeForProperty(node.$cstNode, 'dotKind') : undefined;
-        targetNode ??= findNodeForKeyword(node.$cstNode, '->');
-        targetNode ??= findNodeForKeyword(node.$cstNode, '<-');
-        targetNode ??= findNodeForProperty(node.$cstNode, 'title');
-        targetNode ??= findNodeForProperty(node.$cstNode, 'target');
-        targetNode ??= node.$cstNode;
-        if (!targetNode) {
-            return null;
-        }
-        return {
-            uri: doc.uri.toString(),
-            range: {
-                start: targetNode.range.start,
-                end: targetNode.range.start,
-            },
-        };
-    }
-}

package/dist/model/model-parser-where.d.ts

@@ -1,4 +0,0 @@
-import type * as c4 from '@likec4/core';
-import { ast } from '../ast';
-export declare function parseWhereClause(astNode: ast.WhereExpression): c4.WhereOperator;
-export declare function createBinaryOperator(operator: Lowercase<ast.WhereBinaryExpression['operator']>, left: c4.WhereOperator, right: c4.WhereOperator | null): c4.WhereOperator;

package/dist/model/model-parser-where.js

@@ -1,81 +0,0 @@
-import { invariant, isAndOperator, isNonEmptyArray, isOrOperator, nonexhaustive } from '@likec4/core';
-import { ast } from '../ast';
-const parseEquals = ({ operator, not }, value) => {
-    if (operator.startsWith('!=')) {
-        return {
-            neq: value,
-        };
-    }
-    if (operator.startsWith('=')) {
-        return {
-            eq: value,
-        };
-    }
-    return not ? { neq: value } : { eq: value };
-};
-function parseParticipant(astNode) {
-    if (!ast.isWhereRelationParticipantKind(astNode) && !ast.isWhereRelationParticipantTag(astNode)) {
-        return null;
-    }
-    return astNode.participant;
-}
-export function parseWhereClause(astNode) {
-    switch (true) {
-        case ast.isWhereTagEqual(astNode): {
-            const tag = astNode.value.tag.ref?.name;
-            const participant = parseParticipant(astNode);
-            invariant(tag, 'Expected tag name');
-            const tagOperator = { tag: parseEquals(astNode, tag) };
-            return participant ? { participant, operator: tagOperator } : tagOperator;
-        }
-        case ast.isWhereKindEqual(astNode): {
-            const kind = astNode.value?.ref?.name;
-            const participant = parseParticipant(astNode);
-            invariant(kind, 'Expected kind name');
-            const kindOperator = { kind: parseEquals(astNode, kind) };
-            return participant ? { participant, operator: kindOperator } : kindOperator;
-        }
-        case ast.isWhereElementNegation(astNode) || ast.isWhereRelationNegation(astNode): {
-            return {
-                not: parseWhereClause(astNode.value),
-            };
-        }
-        case ast.isWhereBinaryExpression(astNode): {
-            const left = parseWhereClause(astNode.left);
-            const right = parseWhereClause(astNode.right);
-            const operator = astNode.operator.toLowerCase();
-            return createBinaryOperator(operator, left, right);
-        }
-        default:
-            nonexhaustive(astNode);
-    }
-}
-export function createBinaryOperator(operator, left, right) {
-    if (right === null) {
-        return left;
-    }
-    switch (operator) {
-        case 'and': {
-            const operands = [
-                isAndOperator(left) ? left.and : left,
-                isAndOperator(right) ? right.and : right,
-            ].flat();
-            invariant(isNonEmptyArray(operands), 'Expected non-empty array');
-            return {
-                and: operands,
-            };
-        }
-        case 'or': {
-            const operands = [
-                isOrOperator(left) ? left.or : left,
-                isOrOperator(right) ? right.or : right,
-            ].flat();
-            invariant(isNonEmptyArray(operands), 'Expected non-empty array');
-            return {
-                or: operands,
-            };
-        }
-        default:
-            nonexhaustive(operator);
-    }
-}