@decocms/mesh 1.0.0-alpha.1

package/dist/server/node_modules/kysely/dist/cjs/operation-node/tuple-node.d.ts

@@ -0,0 +1,14 @@
+import type { OperationNode } from './operation-node.js';
+export interface TupleNode extends OperationNode {
+    readonly kind: 'TupleNode';
+    readonly values: ReadonlyArray<OperationNode>;
+}
+type TupleNodeFactory = Readonly<{
+    is(node: OperationNode): node is TupleNode;
+    create(values: ReadonlyArray<OperationNode>): Readonly<TupleNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const TupleNode: TupleNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/tuple-node.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TupleNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.TupleNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'TupleNode';
+    },
+    create(values) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'TupleNode',
+            values: (0, object_utils_js_1.freeze)(values),
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/cjs/operation-node/unary-operation-node.d.ts

@@ -0,0 +1,15 @@
+import type { OperationNode } from './operation-node.js';
+export interface UnaryOperationNode extends OperationNode {
+    readonly kind: 'UnaryOperationNode';
+    readonly operator: OperationNode;
+    readonly operand: OperationNode;
+}
+type UnaryOperationNodeFactory = Readonly<{
+    is(node: OperationNode): node is UnaryOperationNode;
+    create(operator: OperationNode, operand: OperationNode): Readonly<UnaryOperationNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const UnaryOperationNode: UnaryOperationNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/unary-operation-node.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnaryOperationNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.UnaryOperationNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'UnaryOperationNode';
+    },
+    create(operator, operand) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'UnaryOperationNode',
+            operator,
+            operand,
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/cjs/operation-node/unique-constraint-node.d.ts

@@ -0,0 +1,22 @@
+import { ColumnNode } from './column-node.js';
+import { IdentifierNode } from './identifier-node.js';
+import type { OperationNode } from './operation-node.js';
+export interface UniqueConstraintNode extends OperationNode {
+    readonly kind: 'UniqueConstraintNode';
+    readonly columns: ReadonlyArray<ColumnNode>;
+    readonly name?: IdentifierNode;
+    readonly nullsNotDistinct?: boolean;
+    readonly deferrable?: boolean;
+    readonly initiallyDeferred?: boolean;
+}
+export type UniqueConstraintNodeProps = Omit<Partial<UniqueConstraintNode>, 'kind'>;
+type UniqueConstraintNodeFactory = Readonly<{
+    is(node: OperationNode): node is UniqueConstraintNode;
+    create(columns: string[], constraintName?: string, nullsNotDistinct?: boolean): Readonly<UniqueConstraintNode>;
+    cloneWith(node: UniqueConstraintNode, props: UniqueConstraintNodeProps): Readonly<UniqueConstraintNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const UniqueConstraintNode: UniqueConstraintNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/unique-constraint-node.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniqueConstraintNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const column_node_js_1 = require("./column-node.js");
+const identifier_node_js_1 = require("./identifier-node.js");
+/**
+ * @internal
+ */
+exports.UniqueConstraintNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'UniqueConstraintNode';
+    },
+    create(columns, constraintName, nullsNotDistinct) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'UniqueConstraintNode',
+            columns: (0, object_utils_js_1.freeze)(columns.map(column_node_js_1.ColumnNode.create)),
+            name: constraintName
+                ? identifier_node_js_1.IdentifierNode.create(constraintName)
+                : undefined,
+            nullsNotDistinct,
+        });
+    },
+    cloneWith(node, props) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            ...props,
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/cjs/operation-node/update-query-node.d.ts

@@ -0,0 +1,41 @@
+import type { ColumnUpdateNode } from './column-update-node.js';
+import type { JoinNode } from './join-node.js';
+import type { OperationNode } from './operation-node.js';
+import type { ReturningNode } from './returning-node.js';
+import type { WhereNode } from './where-node.js';
+import type { WithNode } from './with-node.js';
+import { FromNode } from './from-node.js';
+import type { ExplainNode } from './explain-node.js';
+import type { LimitNode } from './limit-node.js';
+import type { TopNode } from './top-node.js';
+import type { OutputNode } from './output-node.js';
+import type { OrderByNode } from './order-by-node.js';
+export interface UpdateQueryNode extends OperationNode {
+    readonly kind: 'UpdateQueryNode';
+    readonly table?: OperationNode;
+    readonly from?: FromNode;
+    readonly joins?: ReadonlyArray<JoinNode>;
+    readonly where?: WhereNode;
+    readonly updates?: ReadonlyArray<ColumnUpdateNode>;
+    readonly returning?: ReturningNode;
+    readonly with?: WithNode;
+    readonly explain?: ExplainNode;
+    readonly endModifiers?: ReadonlyArray<OperationNode>;
+    readonly limit?: LimitNode;
+    readonly top?: TopNode;
+    readonly output?: OutputNode;
+    readonly orderBy?: OrderByNode;
+}
+type UpdateQueryNodeFactory = Readonly<{
+    is(node: OperationNode): node is UpdateQueryNode;
+    create(tables: ReadonlyArray<OperationNode>, withNode?: WithNode): Readonly<UpdateQueryNode>;
+    createWithoutTable(): Readonly<UpdateQueryNode>;
+    cloneWithFromItems(updateQuery: UpdateQueryNode, fromItems: ReadonlyArray<OperationNode>): Readonly<UpdateQueryNode>;
+    cloneWithUpdates(updateQuery: UpdateQueryNode, updates: ReadonlyArray<ColumnUpdateNode>): Readonly<UpdateQueryNode>;
+    cloneWithLimit(updateQuery: UpdateQueryNode, limit: LimitNode): Readonly<UpdateQueryNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const UpdateQueryNode: UpdateQueryNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/update-query-node.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateQueryNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const from_node_js_1 = require("./from-node.js");
+const list_node_js_1 = require("./list-node.js");
+/**
+ * @internal
+ */
+exports.UpdateQueryNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'UpdateQueryNode';
+    },
+    create(tables, withNode) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'UpdateQueryNode',
+            // For backwards compatibility, use the raw table node when there's only one table
+            // and don't rename the property to something like `tables`.
+            table: tables.length === 1 ? tables[0] : list_node_js_1.ListNode.create(tables),
+            ...(withNode && { with: withNode }),
+        });
+    },
+    createWithoutTable() {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'UpdateQueryNode',
+        });
+    },
+    cloneWithFromItems(updateQuery, fromItems) {
+        return (0, object_utils_js_1.freeze)({
+            ...updateQuery,
+            from: updateQuery.from
+                ? from_node_js_1.FromNode.cloneWithFroms(updateQuery.from, fromItems)
+                : from_node_js_1.FromNode.create(fromItems),
+        });
+    },
+    cloneWithUpdates(updateQuery, updates) {
+        return (0, object_utils_js_1.freeze)({
+            ...updateQuery,
+            updates: updateQuery.updates
+                ? (0, object_utils_js_1.freeze)([...updateQuery.updates, ...updates])
+                : updates,
+        });
+    },
+    cloneWithLimit(updateQuery, limit) {
+        return (0, object_utils_js_1.freeze)({
+            ...updateQuery,
+            limit,
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/cjs/operation-node/using-node.d.ts

@@ -0,0 +1,15 @@
+import type { OperationNode } from './operation-node.js';
+export interface UsingNode extends OperationNode {
+    readonly kind: 'UsingNode';
+    readonly tables: ReadonlyArray<OperationNode>;
+}
+type UsingNodeFactory = Readonly<{
+    is(node: OperationNode): node is UsingNode;
+    create(tables: ReadonlyArray<OperationNode>): Readonly<UsingNode>;
+    cloneWithTables(using: UsingNode, tables: ReadonlyArray<OperationNode>): Readonly<UsingNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const UsingNode: UsingNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/using-node.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsingNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.UsingNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'UsingNode';
+    },
+    create(tables) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'UsingNode',
+            tables: (0, object_utils_js_1.freeze)(tables),
+        });
+    },
+    cloneWithTables(using, tables) {
+        return (0, object_utils_js_1.freeze)({
+            ...using,
+            tables: (0, object_utils_js_1.freeze)([...using.tables, ...tables]),
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/cjs/operation-node/value-list-node.d.ts

@@ -0,0 +1,14 @@
+import type { OperationNode } from './operation-node.js';
+export interface ValueListNode extends OperationNode {
+    readonly kind: 'ValueListNode';
+    readonly values: ReadonlyArray<OperationNode>;
+}
+type ValueListNodeFactory = Readonly<{
+    is(node: OperationNode): node is ValueListNode;
+    create(values: ReadonlyArray<OperationNode>): Readonly<ValueListNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const ValueListNode: ValueListNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/value-list-node.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueListNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.ValueListNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'ValueListNode';
+    },
+    create(values) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'ValueListNode',
+            values: (0, object_utils_js_1.freeze)(values),
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/cjs/operation-node/value-node.d.ts

@@ -0,0 +1,16 @@
+import type { OperationNode } from './operation-node.js';
+export interface ValueNode extends OperationNode {
+    readonly kind: 'ValueNode';
+    readonly value: unknown;
+    readonly immediate?: boolean;
+}
+type ValueNodeFactory = Readonly<{
+    is(node: OperationNode): node is ValueNode;
+    create(value: unknown): Readonly<ValueNode>;
+    createImmediate(value: unknown): Readonly<ValueNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const ValueNode: ValueNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/value-node.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.ValueNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'ValueNode';
+    },
+    create(value) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'ValueNode',
+            value,
+        });
+    },
+    createImmediate(value) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'ValueNode',
+            value,
+            immediate: true,
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/cjs/operation-node/values-node.d.ts

@@ -0,0 +1,17 @@
+import type { OperationNode } from './operation-node.js';
+import type { PrimitiveValueListNode } from './primitive-value-list-node.js';
+import type { ValueListNode } from './value-list-node.js';
+export type ValuesItemNode = ValueListNode | PrimitiveValueListNode;
+export interface ValuesNode extends OperationNode {
+    readonly kind: 'ValuesNode';
+    readonly values: ReadonlyArray<ValuesItemNode>;
+}
+type ValuesNodeFactory = Readonly<{
+    is(node: OperationNode): node is ValuesNode;
+    create(values: ReadonlyArray<ValuesItemNode>): Readonly<ValuesNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const ValuesNode: ValuesNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/values-node.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValuesNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.ValuesNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'ValuesNode';
+    },
+    create(values) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'ValuesNode',
+            values: (0, object_utils_js_1.freeze)(values),
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/cjs/operation-node/when-node.d.ts

@@ -0,0 +1,16 @@
+import type { OperationNode } from './operation-node.js';
+export interface WhenNode extends OperationNode {
+    readonly kind: 'WhenNode';
+    readonly condition: OperationNode;
+    readonly result?: OperationNode;
+}
+type WhenNodeFactory = Readonly<{
+    is(node: OperationNode): node is WhenNode;
+    create(condition: OperationNode): Readonly<WhenNode>;
+    cloneWithResult(whenNode: WhenNode, result: OperationNode): Readonly<WhenNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const WhenNode: WhenNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/when-node.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhenNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.WhenNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'WhenNode';
+    },
+    create(condition) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'WhenNode',
+            condition,
+        });
+    },
+    cloneWithResult(whenNode, result) {
+        return (0, object_utils_js_1.freeze)({
+            ...whenNode,
+            result,
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/cjs/operation-node/where-node.d.ts

@@ -0,0 +1,15 @@
+import type { OperationNode } from './operation-node.js';
+export interface WhereNode extends OperationNode {
+    readonly kind: 'WhereNode';
+    readonly where: OperationNode;
+}
+type WhereNodeFactory = Readonly<{
+    is(node: OperationNode): node is WhereNode;
+    create(filter: OperationNode): Readonly<WhereNode>;
+    cloneWithOperation(whereNode: WhereNode, operator: 'And' | 'Or', operation: OperationNode): Readonly<WhereNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const WhereNode: WhereNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/where-node.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhereNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const and_node_js_1 = require("./and-node.js");
+const or_node_js_1 = require("./or-node.js");
+/**
+ * @internal
+ */
+exports.WhereNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'WhereNode';
+    },
+    create(filter) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'WhereNode',
+            where: filter,
+        });
+    },
+    cloneWithOperation(whereNode, operator, operation) {
+        return (0, object_utils_js_1.freeze)({
+            ...whereNode,
+            where: operator === 'And'
+                ? and_node_js_1.AndNode.create(whereNode.where, operation)
+                : or_node_js_1.OrNode.create(whereNode.where, operation),
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/cjs/operation-node/with-node.d.ts

@@ -0,0 +1,18 @@
+import type { OperationNode } from './operation-node.js';
+import type { CommonTableExpressionNode } from './common-table-expression-node.js';
+export type WithNodeParams = Omit<WithNode, 'kind' | 'expressions'>;
+export interface WithNode extends OperationNode {
+    readonly kind: 'WithNode';
+    readonly expressions: ReadonlyArray<CommonTableExpressionNode>;
+    readonly recursive?: boolean;
+}
+type WithNodeFactory = Readonly<{
+    is(node: OperationNode): node is WithNode;
+    create(expression: CommonTableExpressionNode, params?: WithNodeParams): Readonly<WithNode>;
+    cloneWithExpression(withNode: WithNode, expression: CommonTableExpressionNode): Readonly<WithNode>;
+}>;
+/**
+ * @internal
+ */
+export declare const WithNode: WithNodeFactory;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/operation-node/with-node.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WithNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.WithNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'WithNode';
+    },
+    create(expression, params) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'WithNode',
+            expressions: (0, object_utils_js_1.freeze)([expression]),
+            ...params,
+        });
+    },
+    cloneWithExpression(withNode, expression) {
+        return (0, object_utils_js_1.freeze)({
+            ...withNode,
+            expressions: (0, object_utils_js_1.freeze)([...withNode.expressions, expression]),
+        });
+    },
+});

package/dist/server/node_modules/kysely/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs","sideEffects":false}

package/dist/server/node_modules/kysely/dist/cjs/parser/binary-operation-parser.d.ts

@@ -0,0 +1,21 @@
+import { BinaryOperationNode } from '../operation-node/binary-operation-node.js';
+import { type OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { type ComparisonOperator, type BinaryOperator, type Operator } from '../operation-node/operator-node.js';
+import { type ExtractTypeFromReferenceExpression, type ExtractTypeFromStringReference, type ReferenceExpression, type StringReference } from './reference-parser.js';
+import { type ValueExpression, type ValueExpressionOrList } from './value-parser.js';
+import type { OperationNode } from '../operation-node/operation-node.js';
+import type { Expression } from '../expression/expression.js';
+import type { SelectType } from '../util/column-type.js';
+export type OperandValueExpression<DB, TB extends keyof DB, RE> = ValueExpression<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>;
+export type OperandValueExpressionOrList<DB, TB extends keyof DB, RE> = ValueExpressionOrList<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE> | null>;
+export type OperatorExpression = Operator | Expression<unknown>;
+export type BinaryOperatorExpression = BinaryOperator | Expression<unknown>;
+export type ComparisonOperatorExpression = ComparisonOperator | Expression<unknown>;
+export type FilterObject<DB, TB extends keyof DB> = {
+    [R in StringReference<DB, TB>]?: ValueExpressionOrList<DB, TB, SelectType<ExtractTypeFromStringReference<DB, TB, R>>>;
+};
+export declare function parseValueBinaryOperationOrExpression(args: any[]): OperationNode;
+export declare function parseValueBinaryOperation(left: ReferenceExpression<any, any>, operator: BinaryOperatorExpression, right: OperandValueExpressionOrList<any, any, any>): BinaryOperationNode;
+export declare function parseReferentialBinaryOperation(left: ReferenceExpression<any, any>, operator: BinaryOperatorExpression, right: OperandValueExpressionOrList<any, any, any>): BinaryOperationNode;
+export declare function parseFilterObject(obj: Readonly<FilterObject<any, any>>, combinator: 'and' | 'or'): OperationNode;
+export declare function parseFilterList(list: ReadonlyArray<OperationNodeSource | OperationNode>, combinator: 'and' | 'or', withParens?: boolean): OperationNode;

package/dist/server/node_modules/kysely/dist/cjs/parser/binary-operation-parser.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseValueBinaryOperationOrExpression = parseValueBinaryOperationOrExpression;
+exports.parseValueBinaryOperation = parseValueBinaryOperation;
+exports.parseReferentialBinaryOperation = parseReferentialBinaryOperation;
+exports.parseFilterObject = parseFilterObject;
+exports.parseFilterList = parseFilterList;
+const binary_operation_node_js_1 = require("../operation-node/binary-operation-node.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
+const operator_node_js_1 = require("../operation-node/operator-node.js");
+const reference_parser_js_1 = require("./reference-parser.js");
+const value_parser_js_1 = require("./value-parser.js");
+const value_node_js_1 = require("../operation-node/value-node.js");
+const and_node_js_1 = require("../operation-node/and-node.js");
+const parens_node_js_1 = require("../operation-node/parens-node.js");
+const or_node_js_1 = require("../operation-node/or-node.js");
+function parseValueBinaryOperationOrExpression(args) {
+    if (args.length === 3) {
+        return parseValueBinaryOperation(args[0], args[1], args[2]);
+    }
+    else if (args.length === 1) {
+        return (0, value_parser_js_1.parseValueExpression)(args[0]);
+    }
+    throw new Error(`invalid arguments: ${JSON.stringify(args)}`);
+}
+function parseValueBinaryOperation(left, operator, right) {
+    if (isIsOperator(operator) && needsIsOperator(right)) {
+        return binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(left), parseOperator(operator), value_node_js_1.ValueNode.createImmediate(right));
+    }
+    return binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(left), parseOperator(operator), (0, value_parser_js_1.parseValueExpressionOrList)(right));
+}
+function parseReferentialBinaryOperation(left, operator, right) {
+    return binary_operation_node_js_1.BinaryOperationNode.create((0, reference_parser_js_1.parseReferenceExpression)(left), parseOperator(operator), (0, reference_parser_js_1.parseReferenceExpression)(right));
+}
+function parseFilterObject(obj, combinator) {
+    return parseFilterList(Object.entries(obj)
+        .filter(([, v]) => !(0, object_utils_js_1.isUndefined)(v))
+        .map(([k, v]) => parseValueBinaryOperation(k, needsIsOperator(v) ? 'is' : '=', v)), combinator);
+}
+function parseFilterList(list, combinator, withParens = true) {
+    const combine = combinator === 'and' ? and_node_js_1.AndNode.create : or_node_js_1.OrNode.create;
+    if (list.length === 0) {
+        return binary_operation_node_js_1.BinaryOperationNode.create(value_node_js_1.ValueNode.createImmediate(1), operator_node_js_1.OperatorNode.create('='), value_node_js_1.ValueNode.createImmediate(combinator === 'and' ? 1 : 0));
+    }
+    let node = toOperationNode(list[0]);
+    for (let i = 1; i < list.length; ++i) {
+        node = combine(node, toOperationNode(list[i]));
+    }
+    if (list.length > 1 && withParens) {
+        return parens_node_js_1.ParensNode.create(node);
+    }
+    return node;
+}
+function isIsOperator(operator) {
+    return operator === 'is' || operator === 'is not';
+}
+function needsIsOperator(value) {
+    return (0, object_utils_js_1.isNull)(value) || (0, object_utils_js_1.isBoolean)(value);
+}
+function parseOperator(operator) {
+    if ((0, object_utils_js_1.isString)(operator) && operator_node_js_1.OPERATORS.includes(operator)) {
+        return operator_node_js_1.OperatorNode.create(operator);
+    }
+    if ((0, operation_node_source_js_1.isOperationNodeSource)(operator)) {
+        return operator.toOperationNode();
+    }
+    throw new Error(`invalid operator ${JSON.stringify(operator)}`);
+}
+function toOperationNode(nodeOrSource) {
+    return (0, operation_node_source_js_1.isOperationNodeSource)(nodeOrSource)
+        ? nodeOrSource.toOperationNode()
+        : nodeOrSource;
+}

package/dist/server/node_modules/kysely/dist/cjs/parser/coalesce-parser.d.ts

@@ -0,0 +1,12 @@
+import type { ExtractTypeFromReferenceExpression } from './reference-parser.js';
+export type ExtractTypeFromCoalesce1<DB, TB extends keyof DB, R1> = ExtractTypeFromReferenceExpression<DB, TB, R1>;
+export type ExtractTypeFromCoalesce2<DB, TB extends keyof DB, R1, R2> = ExtractTypeFromCoalesceValues2<ExtractTypeFromReferenceExpression<DB, TB, R1>, ExtractTypeFromReferenceExpression<DB, TB, R2>>;
+type ExtractTypeFromCoalesceValues2<V1, V2> = null extends V1 ? null extends V2 ? V1 | V2 : NotNull<V1 | V2> : NotNull<V1>;
+export type ExtractTypeFromCoalesce3<DB, TB extends keyof DB, R1, R2, R3> = ExtractTypeFromCoalesceValues3<ExtractTypeFromReferenceExpression<DB, TB, R1>, ExtractTypeFromReferenceExpression<DB, TB, R2>, ExtractTypeFromReferenceExpression<DB, TB, R3>>;
+type ExtractTypeFromCoalesceValues3<V1, V2, V3> = null extends V1 ? null extends V2 ? null extends V3 ? V1 | V2 | V3 : NotNull<V1 | V2 | V3> : NotNull<V1 | V2> : NotNull<V1>;
+export type ExtractTypeFromCoalesce4<DB, TB extends keyof DB, R1, R2, R3, R4> = ExtractTypeFromCoalesceValues4<ExtractTypeFromReferenceExpression<DB, TB, R1>, ExtractTypeFromReferenceExpression<DB, TB, R2>, ExtractTypeFromReferenceExpression<DB, TB, R3>, ExtractTypeFromReferenceExpression<DB, TB, R4>>;
+type ExtractTypeFromCoalesceValues4<V1, V2, V3, V4> = null extends V1 ? null extends V2 ? null extends V3 ? null extends V4 ? V1 | V2 | V3 | V4 : NotNull<V1 | V2 | V3 | V4> : NotNull<V1 | V2 | V3> : NotNull<V1 | V2> : NotNull<V1>;
+export type ExtractTypeFromCoalesce5<DB, TB extends keyof DB, R1, R2, R3, R4, R5> = ExtractTypeFromCoalesceValues5<ExtractTypeFromReferenceExpression<DB, TB, R1>, ExtractTypeFromReferenceExpression<DB, TB, R2>, ExtractTypeFromReferenceExpression<DB, TB, R3>, ExtractTypeFromReferenceExpression<DB, TB, R4>, ExtractTypeFromReferenceExpression<DB, TB, R5>>;
+type ExtractTypeFromCoalesceValues5<V1, V2, V3, V4, V5> = null extends V1 ? null extends V2 ? null extends V3 ? null extends V4 ? null extends V5 ? V1 | V2 | V3 | V4 | V5 : NotNull<V1 | V2 | V3 | V4 | V5> : NotNull<V1 | V2 | V3 | V4> : NotNull<V1 | V2 | V3> : NotNull<V1 | V2> : NotNull<V1>;
+type NotNull<T> = Exclude<T, null>;
+export {};

package/dist/server/node_modules/kysely/dist/cjs/parser/coalesce-parser.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/node_modules/kysely/dist/cjs/parser/collate-parser.d.ts

@@ -0,0 +1 @@
+export type Collation = 'nocase' | 'binary' | 'rtrim' | (string & {});

package/dist/server/node_modules/kysely/dist/cjs/parser/collate-parser.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/node_modules/kysely/dist/cjs/parser/data-type-parser.d.ts

@@ -0,0 +1,5 @@
+import type { Expression } from '../expression/expression.js';
+import { type ColumnDataType } from '../operation-node/data-type-node.js';
+import type { OperationNode } from '../operation-node/operation-node.js';
+export type DataTypeExpression = ColumnDataType | Expression<any>;
+export declare function parseDataTypeExpression(dataType: DataTypeExpression): OperationNode;