Initial commit - Event Planner application

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;

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;
+}

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 {};

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

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

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

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

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

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

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;

node_modules/kysely/dist/cjs/parser/data-type-parser.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDataTypeExpression = parseDataTypeExpression;
+const data_type_node_js_1 = require("../operation-node/data-type-node.js");
+const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
+function parseDataTypeExpression(dataType) {
+    if ((0, operation_node_source_js_1.isOperationNodeSource)(dataType)) {
+        return dataType.toOperationNode();
+    }
+    if ((0, data_type_node_js_1.isColumnDataType)(dataType)) {
+        return data_type_node_js_1.DataTypeNode.create(dataType);
+    }
+    throw new Error(`invalid column data type ${JSON.stringify(dataType)}`);
+}

node_modules/kysely/dist/cjs/parser/default-value-parser.d.ts

@@ -0,0 +1,4 @@
+import type { Expression } from '../expression/expression.js';
+import type { OperationNode } from '../operation-node/operation-node.js';
+export type DefaultValueExpression = unknown | Expression<unknown>;
+export declare function parseDefaultValueExpression(value: DefaultValueExpression): OperationNode;

node_modules/kysely/dist/cjs/parser/default-value-parser.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDefaultValueExpression = parseDefaultValueExpression;
+const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
+const value_node_js_1 = require("../operation-node/value-node.js");
+function parseDefaultValueExpression(value) {
+    return (0, operation_node_source_js_1.isOperationNodeSource)(value)
+        ? value.toOperationNode()
+        : value_node_js_1.ValueNode.createImmediate(value);
+}

node_modules/kysely/dist/cjs/parser/delete-from-parser.d.ts

@@ -0,0 +1,9 @@
+import type { DeleteQueryBuilder } from '../query-builder/delete-query-builder.js';
+import type { DeleteResult } from '../query-builder/delete-result.js';
+import type { ShallowRecord } from '../util/type-utils.js';
+import type { ExtractTableAlias, From, FromTables, TableExpressionOrList } from './table-parser.js';
+export type DeleteFrom<DB, TE extends TableExpressionOrList<DB, never>> = [
+    TE
+] extends [keyof DB] ? DeleteQueryBuilder<DB, ExtractTableAlias<DB, TE>, DeleteResult> : [
+    TE
+] extends [`${infer T} as ${infer A}`] ? T extends keyof DB ? DeleteQueryBuilder<DB & ShallowRecord<A, DB[T]>, A, DeleteResult> : never : TE extends ReadonlyArray<infer T> ? DeleteQueryBuilder<From<DB, T>, FromTables<DB, never, T>, DeleteResult> : DeleteQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, DeleteResult>;

node_modules/kysely/dist/cjs/parser/delete-from-parser.js

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

node_modules/kysely/dist/cjs/parser/expression-parser.d.ts

@@ -0,0 +1,20 @@
+import { type AliasedExpression, type Expression } from '../expression/expression.js';
+import type { AliasNode } from '../operation-node/alias-node.js';
+import type { OperationNode } from '../operation-node/operation-node.js';
+import { type ExpressionBuilder } from '../expression/expression-builder.js';
+import type { SelectQueryBuilderExpression } from '../query-builder/select-query-builder-expression.js';
+/**
+ * Like `Expression<V>` but also accepts a select query with an output
+ * type extending `Record<string, V>`. This type is useful because SQL
+ * treats records with a single column as single values.
+ */
+export type OperandExpression<V> = Expression<V> | SelectQueryBuilderExpression<Record<string, V>>;
+export type ExpressionOrFactory<DB, TB extends keyof DB, V> = OperandExpression<V> | OperandExpressionFactory<DB, TB, V>;
+export type AliasedExpressionOrFactory<DB, TB extends keyof DB> = AliasedExpression<any, any> | AliasedExpressionFactory<DB, TB>;
+export type ExpressionFactory<DB, TB extends keyof DB, V> = (eb: ExpressionBuilder<DB, TB>) => Expression<V>;
+type OperandExpressionFactory<DB, TB extends keyof DB, V> = (eb: ExpressionBuilder<DB, TB>) => OperandExpression<V>;
+type AliasedExpressionFactory<DB, TB extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => AliasedExpression<any, any>;
+export declare function parseExpression(exp: ExpressionOrFactory<any, any, any>): OperationNode;
+export declare function parseAliasedExpression(exp: AliasedExpressionOrFactory<any, any>): AliasNode;
+export declare function isExpressionOrFactory(obj: unknown): obj is ExpressionOrFactory<any, any, any>;
+export {};

node_modules/kysely/dist/cjs/parser/expression-parser.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseExpression = parseExpression;
+exports.parseAliasedExpression = parseAliasedExpression;
+exports.isExpressionOrFactory = isExpressionOrFactory;
+const expression_js_1 = require("../expression/expression.js");
+const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
+const expression_builder_js_1 = require("../expression/expression-builder.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+function parseExpression(exp) {
+    if ((0, operation_node_source_js_1.isOperationNodeSource)(exp)) {
+        return exp.toOperationNode();
+    }
+    else if ((0, object_utils_js_1.isFunction)(exp)) {
+        return exp((0, expression_builder_js_1.expressionBuilder)()).toOperationNode();
+    }
+    throw new Error(`invalid expression: ${JSON.stringify(exp)}`);
+}
+function parseAliasedExpression(exp) {
+    if ((0, operation_node_source_js_1.isOperationNodeSource)(exp)) {
+        return exp.toOperationNode();
+    }
+    else if ((0, object_utils_js_1.isFunction)(exp)) {
+        return exp((0, expression_builder_js_1.expressionBuilder)()).toOperationNode();
+    }
+    throw new Error(`invalid aliased expression: ${JSON.stringify(exp)}`);
+}
+function isExpressionOrFactory(obj) {
+    return (0, expression_js_1.isExpression)(obj) || (0, expression_js_1.isAliasedExpression)(obj) || (0, object_utils_js_1.isFunction)(obj);
+}

node_modules/kysely/dist/cjs/parser/fetch-parser.d.ts

@@ -0,0 +1,2 @@
+import { type FetchModifier, FetchNode } from '../operation-node/fetch-node.js';
+export declare function parseFetch(rowCount: number | bigint, modifier: FetchModifier): FetchNode;

node_modules/kysely/dist/cjs/parser/fetch-parser.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFetch = parseFetch;
+const fetch_node_js_1 = require("../operation-node/fetch-node.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+function parseFetch(rowCount, modifier) {
+    if (!(0, object_utils_js_1.isNumber)(rowCount) && !(0, object_utils_js_1.isBigInt)(rowCount)) {
+        throw new Error(`Invalid fetch row count: ${rowCount}`);
+    }
+    if (!isFetchModifier(modifier)) {
+        throw new Error(`Invalid fetch modifier: ${modifier}`);
+    }
+    return fetch_node_js_1.FetchNode.create(rowCount, modifier);
+}
+function isFetchModifier(value) {
+    return value === 'only' || value === 'with ties';
+}

node_modules/kysely/dist/cjs/parser/group-by-parser.d.ts

@@ -0,0 +1,6 @@
+import { GroupByItemNode } from '../operation-node/group-by-item-node.js';
+import { type ExpressionBuilder } from '../expression/expression-builder.js';
+import { type ReferenceExpression } from './reference-parser.js';
+export type GroupByExpression<DB, TB extends keyof DB, O> = ReferenceExpression<DB, TB> | (keyof O & string);
+export type GroupByArg<DB, TB extends keyof DB, O> = GroupByExpression<DB, TB, O> | ReadonlyArray<GroupByExpression<DB, TB, O>> | ((eb: ExpressionBuilder<DB, TB>) => ReadonlyArray<GroupByExpression<DB, TB, O>>);
+export declare function parseGroupBy(groupBy: GroupByArg<any, any, any>): GroupByItemNode[];

node_modules/kysely/dist/cjs/parser/group-by-parser.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseGroupBy = parseGroupBy;
+const group_by_item_node_js_1 = require("../operation-node/group-by-item-node.js");
+const expression_builder_js_1 = require("../expression/expression-builder.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+const reference_parser_js_1 = require("./reference-parser.js");
+function parseGroupBy(groupBy) {
+    groupBy = (0, object_utils_js_1.isFunction)(groupBy) ? groupBy((0, expression_builder_js_1.expressionBuilder)()) : groupBy;
+    return (0, reference_parser_js_1.parseReferenceExpressionOrList)(groupBy).map(group_by_item_node_js_1.GroupByItemNode.create);
+}

node_modules/kysely/dist/cjs/parser/identifier-parser.d.ts

@@ -0,0 +1,2 @@
+import { SchemableIdentifierNode } from '../operation-node/schemable-identifier-node.js';
+export declare function parseSchemableIdentifier(id: string): SchemableIdentifierNode;

node_modules/kysely/dist/cjs/parser/identifier-parser.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSchemableIdentifier = parseSchemableIdentifier;
+const schemable_identifier_node_js_1 = require("../operation-node/schemable-identifier-node.js");
+function parseSchemableIdentifier(id) {
+    const SCHEMA_SEPARATOR = '.';
+    if (id.includes(SCHEMA_SEPARATOR)) {
+        const parts = id.split(SCHEMA_SEPARATOR).map(trim);
+        if (parts.length === 2) {
+            return schemable_identifier_node_js_1.SchemableIdentifierNode.createWithSchema(parts[0], parts[1]);
+        }
+        else {
+            throw new Error(`invalid schemable identifier ${id}`);
+        }
+    }
+    else {
+        return schemable_identifier_node_js_1.SchemableIdentifierNode.create(id);
+    }
+}
+function trim(str) {
+    return str.trim();
+}

node_modules/kysely/dist/cjs/parser/insert-values-parser.d.ts

@@ -0,0 +1,14 @@
+import { ColumnNode } from '../operation-node/column-node.js';
+import { type ValueExpression } from './value-parser.js';
+import { ValuesNode } from '../operation-node/values-node.js';
+import type { NonNullableInsertKeys, NullableInsertKeys, InsertType } from '../util/column-type.js';
+import { type ExpressionBuilder } from '../expression/expression-builder.js';
+export type InsertObject<DB, TB extends keyof DB> = {
+    [C in NonNullableInsertKeys<DB[TB]>]: ValueExpression<DB, TB, InsertType<DB[TB][C]>>;
+} & {
+    [C in NullableInsertKeys<DB[TB]>]?: ValueExpression<DB, TB, InsertType<DB[TB][C]>> | undefined;
+};
+export type InsertObjectOrList<DB, TB extends keyof DB> = InsertObject<DB, TB> | ReadonlyArray<InsertObject<DB, TB>>;
+export type InsertObjectOrListFactory<DB, TB extends keyof DB, UT extends keyof DB = never> = (eb: ExpressionBuilder<DB, TB | UT>) => InsertObjectOrList<DB, TB>;
+export type InsertExpression<DB, TB extends keyof DB, UT extends keyof DB = never> = InsertObjectOrList<DB, TB> | InsertObjectOrListFactory<DB, TB, UT>;
+export declare function parseInsertExpression(arg: InsertExpression<any, any, any>): [ReadonlyArray<ColumnNode>, ValuesNode];

node_modules/kysely/dist/cjs/parser/insert-values-parser.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInsertExpression = parseInsertExpression;
+const column_node_js_1 = require("../operation-node/column-node.js");
+const primitive_value_list_node_js_1 = require("../operation-node/primitive-value-list-node.js");
+const value_list_node_js_1 = require("../operation-node/value-list-node.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+const value_parser_js_1 = require("./value-parser.js");
+const values_node_js_1 = require("../operation-node/values-node.js");
+const expression_parser_js_1 = require("./expression-parser.js");
+const default_insert_value_node_js_1 = require("../operation-node/default-insert-value-node.js");
+const expression_builder_js_1 = require("../expression/expression-builder.js");
+function parseInsertExpression(arg) {
+    const objectOrList = (0, object_utils_js_1.isFunction)(arg) ? arg((0, expression_builder_js_1.expressionBuilder)()) : arg;
+    const list = (0, object_utils_js_1.isReadonlyArray)(objectOrList)
+        ? objectOrList
+        : (0, object_utils_js_1.freeze)([objectOrList]);
+    return parseInsertColumnsAndValues(list);
+}
+function parseInsertColumnsAndValues(rows) {
+    const columns = parseColumnNamesAndIndexes(rows);
+    return [
+        (0, object_utils_js_1.freeze)([...columns.keys()].map(column_node_js_1.ColumnNode.create)),
+        values_node_js_1.ValuesNode.create(rows.map((row) => parseRowValues(row, columns))),
+    ];
+}
+function parseColumnNamesAndIndexes(rows) {
+    const columns = new Map();
+    for (const row of rows) {
+        const cols = Object.keys(row);
+        for (const col of cols) {
+            if (!columns.has(col) && row[col] !== undefined) {
+                columns.set(col, columns.size);
+            }
+        }
+    }
+    return columns;
+}
+function parseRowValues(row, columns) {
+    const rowColumns = Object.keys(row);
+    const rowValues = Array.from({
+        length: columns.size,
+    });
+    let hasUndefinedOrComplexColumns = false;
+    let indexedRowColumns = rowColumns.length;
+    for (const col of rowColumns) {
+        const columnIdx = columns.get(col);
+        if ((0, object_utils_js_1.isUndefined)(columnIdx)) {
+            indexedRowColumns--;
+            continue;
+        }
+        const value = row[col];
+        if ((0, object_utils_js_1.isUndefined)(value) || (0, expression_parser_js_1.isExpressionOrFactory)(value)) {
+            hasUndefinedOrComplexColumns = true;
+        }
+        rowValues[columnIdx] = value;
+    }
+    const hasMissingColumns = indexedRowColumns < columns.size;
+    if (hasMissingColumns || hasUndefinedOrComplexColumns) {
+        const defaultValue = default_insert_value_node_js_1.DefaultInsertValueNode.create();
+        return value_list_node_js_1.ValueListNode.create(rowValues.map((it) => (0, object_utils_js_1.isUndefined)(it) ? defaultValue : (0, value_parser_js_1.parseValueExpression)(it)));
+    }
+    return primitive_value_list_node_js_1.PrimitiveValueListNode.create(rowValues);
+}

node_modules/kysely/dist/cjs/parser/join-parser.d.ts

@@ -0,0 +1,10 @@
+import { JoinNode, type JoinType } from '../operation-node/join-node.js';
+import type { JoinBuilder } from '../query-builder/join-builder.js';
+import type { AnyColumn, AnyColumnWithTable, DrainOuterGeneric } from '../util/type-utils.js';
+import { type From, type FromTables } from './table-parser.js';
+export type JoinReferenceExpression<DB, TB extends keyof DB, TE> = DrainOuterGeneric<AnyJoinColumn<DB, TB, TE> | AnyJoinColumnWithTable<DB, TB, TE>>;
+export type JoinCallbackExpression<DB, TB extends keyof DB, TE> = (join: JoinBuilder<From<DB, TE>, FromTables<DB, TB, TE>>) => JoinBuilder<any, any>;
+type AnyJoinColumn<DB, TB extends keyof DB, TE> = AnyColumn<From<DB, TE>, FromTables<DB, TB, TE>>;
+type AnyJoinColumnWithTable<DB, TB extends keyof DB, TE> = AnyColumnWithTable<From<DB, TE>, FromTables<DB, TB, TE>>;
+export declare function parseJoin(joinType: JoinType, args: any[]): JoinNode;
+export {};

node_modules/kysely/dist/cjs/parser/join-parser.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJoin = parseJoin;
+const join_node_js_1 = require("../operation-node/join-node.js");
+const binary_operation_parser_js_1 = require("./binary-operation-parser.js");
+const parse_utils_js_1 = require("./parse-utils.js");
+const table_parser_js_1 = require("./table-parser.js");
+function parseJoin(joinType, args) {
+    if (args.length === 3) {
+        return parseSingleOnJoin(joinType, args[0], args[1], args[2]);
+    }
+    else if (args.length === 2) {
+        return parseCallbackJoin(joinType, args[0], args[1]);
+    }
+    else if (args.length === 1) {
+        return parseOnlessJoin(joinType, args[0]);
+    }
+    else {
+        throw new Error('not implemented');
+    }
+}
+function parseCallbackJoin(joinType, from, callback) {
+    return callback((0, parse_utils_js_1.createJoinBuilder)(joinType, from)).toOperationNode();
+}
+function parseSingleOnJoin(joinType, from, lhsColumn, rhsColumn) {
+    return join_node_js_1.JoinNode.createWithOn(joinType, (0, table_parser_js_1.parseTableExpression)(from), (0, binary_operation_parser_js_1.parseReferentialBinaryOperation)(lhsColumn, '=', rhsColumn));
+}
+function parseOnlessJoin(joinType, from) {
+    return join_node_js_1.JoinNode.create(joinType, (0, table_parser_js_1.parseTableExpression)(from));
+}

node_modules/kysely/dist/cjs/parser/merge-into-parser.d.ts

@@ -0,0 +1,7 @@
+import type { MergeQueryBuilder } from '../query-builder/merge-query-builder.js';
+import type { MergeResult } from '../query-builder/merge-result.js';
+import type { ShallowRecord } from '../util/type-utils.js';
+import type { ExtractTableAlias, SimpleTableReference } from './table-parser.js';
+export type MergeInto<DB, TE extends SimpleTableReference<DB>> = [TE] extends [
+    keyof DB
+] ? MergeQueryBuilder<DB, ExtractTableAlias<DB, TE>, MergeResult> : [TE] extends [`${infer T} as ${infer A}`] ? T extends keyof DB ? MergeQueryBuilder<DB & ShallowRecord<A, DB[T]>, A, MergeResult> : never : never;

node_modules/kysely/dist/cjs/parser/merge-into-parser.js

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

node_modules/kysely/dist/cjs/parser/merge-parser.d.ts

@@ -0,0 +1,9 @@
+import type { InsertQueryNode } from '../operation-node/insert-query-node.js';
+import { type OperationNodeSource } from '../operation-node/operation-node-source.js';
+import type { OperationNode } from '../operation-node/operation-node.js';
+import { WhenNode } from '../operation-node/when-node.js';
+export declare function parseMergeWhen(type: {
+    isMatched: boolean;
+    bySource?: boolean;
+}, args?: any[], refRight?: boolean): WhenNode;
+export declare function parseMergeThen(result: 'delete' | 'do nothing' | OperationNodeSource | InsertQueryNode): OperationNode;

node_modules/kysely/dist/cjs/parser/merge-parser.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMergeWhen = parseMergeWhen;
+exports.parseMergeThen = parseMergeThen;
+const matched_node_js_1 = require("../operation-node/matched-node.js");
+const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
+const raw_node_js_1 = require("../operation-node/raw-node.js");
+const when_node_js_1 = require("../operation-node/when-node.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+const binary_operation_parser_js_1 = require("./binary-operation-parser.js");
+function parseMergeWhen(type, args, refRight) {
+    return when_node_js_1.WhenNode.create((0, binary_operation_parser_js_1.parseFilterList)([
+        matched_node_js_1.MatchedNode.create(!type.isMatched, type.bySource),
+        ...(args && args.length > 0
+            ? [
+                args.length === 3 && refRight
+                    ? (0, binary_operation_parser_js_1.parseReferentialBinaryOperation)(args[0], args[1], args[2])
+                    : (0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args),
+            ]
+            : []),
+    ], 'and', false));
+}
+function parseMergeThen(result) {
+    if ((0, object_utils_js_1.isString)(result)) {
+        return raw_node_js_1.RawNode.create([result], []);
+    }
+    if ((0, operation_node_source_js_1.isOperationNodeSource)(result)) {
+        return result.toOperationNode();
+    }
+    return result;
+}

node_modules/kysely/dist/cjs/parser/on-commit-action-parse.d.ts

@@ -0,0 +1,2 @@
+import { type OnCommitAction } from '../operation-node/create-table-node.js';
+export declare function parseOnCommitAction(action: OnCommitAction): OnCommitAction;

node_modules/kysely/dist/cjs/parser/on-commit-action-parse.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOnCommitAction = parseOnCommitAction;
+const create_table_node_js_1 = require("../operation-node/create-table-node.js");
+function parseOnCommitAction(action) {
+    if (create_table_node_js_1.ON_COMMIT_ACTIONS.includes(action)) {
+        return action;
+    }
+    throw new Error(`invalid OnCommitAction ${action}`);
+}

node_modules/kysely/dist/cjs/parser/on-modify-action-parser.d.ts

@@ -0,0 +1,2 @@
+import { type OnModifyForeignAction } from '../operation-node/references-node.js';
+export declare function parseOnModifyForeignAction(action: OnModifyForeignAction): OnModifyForeignAction;

node_modules/kysely/dist/cjs/parser/on-modify-action-parser.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOnModifyForeignAction = parseOnModifyForeignAction;
+const references_node_js_1 = require("../operation-node/references-node.js");
+function parseOnModifyForeignAction(action) {
+    if (references_node_js_1.ON_MODIFY_FOREIGN_ACTIONS.includes(action)) {
+        return action;
+    }
+    throw new Error(`invalid OnModifyForeignAction ${action}`);
+}

node_modules/kysely/dist/cjs/parser/order-by-parser.d.ts

@@ -0,0 +1,25 @@
+import { type DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
+import { type Expression } from '../expression/expression.js';
+import { OrderByItemNode } from '../operation-node/order-by-item-node.js';
+import { OrderByItemBuilder } from '../query-builder/order-by-item-builder.js';
+import { type ExpressionOrFactory } from './expression-parser.js';
+import { type ReferenceExpression, type StringReference } from './reference-parser.js';
+export type OrderByExpression<DB, TB extends keyof DB, O> = StringReference<DB, TB> | (keyof O & string) | ExpressionOrFactory<DB, TB, any> | DynamicReferenceBuilder<any>;
+export type OrderByModifiers = OrderByDirection | OrderByModifiersCallbackExpression;
+export type OrderByDirection = 'asc' | 'desc';
+export declare function isOrderByDirection(thing: unknown): thing is OrderByDirection;
+export type OrderByModifiersCallbackExpression = (builder: OrderByItemBuilder) => OrderByItemBuilder;
+/**
+ * @deprecated performance reasons, use {@link OrderByExpression} instead.
+ */
+export type DirectedOrderByStringReference<DB, TB extends keyof DB, O> = `${StringReference<DB, TB> | (keyof O & string)} ${OrderByDirection}`;
+/**
+ * @deprecated replaced with {@link OrderByModifiers}
+ */
+export type OrderByDirectionExpression = OrderByDirection | Expression<any>;
+/**
+ * @deprecated use {@link OrderByExpression} instead.
+ */
+export type UndirectedOrderByExpression<DB, TB extends keyof DB, O> = ReferenceExpression<DB, TB> | (keyof O & string);
+export declare function parseOrderBy(args: any[]): OrderByItemNode[];
+export declare function parseOrderByItem(expr: OrderByExpression<any, any, any>, modifiers?: OrderByModifiers): OrderByItemNode;

node_modules/kysely/dist/cjs/parser/order-by-parser.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isOrderByDirection = isOrderByDirection;
+exports.parseOrderBy = parseOrderBy;
+exports.parseOrderByItem = parseOrderByItem;
+const dynamic_reference_builder_js_1 = require("../dynamic/dynamic-reference-builder.js");
+const expression_js_1 = require("../expression/expression.js");
+const order_by_item_node_js_1 = require("../operation-node/order-by-item-node.js");
+const raw_node_js_1 = require("../operation-node/raw-node.js");
+const order_by_item_builder_js_1 = require("../query-builder/order-by-item-builder.js");
+const log_once_js_1 = require("../util/log-once.js");
+const expression_parser_js_1 = require("./expression-parser.js");
+const reference_parser_js_1 = require("./reference-parser.js");
+function isOrderByDirection(thing) {
+    return thing === 'asc' || thing === 'desc';
+}
+function parseOrderBy(args) {
+    if (args.length === 2) {
+        return [parseOrderByItem(args[0], args[1])];
+    }
+    if (args.length === 1) {
+        const [orderBy] = args;
+        if (Array.isArray(orderBy)) {
+            (0, log_once_js_1.logOnce)('orderBy(array) is deprecated, use multiple orderBy calls instead.');
+            return orderBy.map((item) => parseOrderByItem(item));
+        }
+        return [parseOrderByItem(orderBy)];
+    }
+    throw new Error(`Invalid number of arguments at order by! expected 1-2, received ${args.length}`);
+}
+function parseOrderByItem(expr, modifiers) {
+    const parsedRef = parseOrderByExpression(expr);
+    if (order_by_item_node_js_1.OrderByItemNode.is(parsedRef)) {
+        if (modifiers) {
+            throw new Error('Cannot specify direction twice!');
+        }
+        return parsedRef;
+    }
+    return parseOrderByWithModifiers(parsedRef, modifiers);
+}
+function parseOrderByExpression(expr) {
+    if ((0, expression_parser_js_1.isExpressionOrFactory)(expr)) {
+        return (0, expression_parser_js_1.parseExpression)(expr);
+    }
+    if ((0, dynamic_reference_builder_js_1.isDynamicReferenceBuilder)(expr)) {
+        return expr.toOperationNode();
+    }
+    const [ref, direction] = expr.split(' ');
+    if (direction) {
+        (0, log_once_js_1.logOnce)("`orderBy('column asc')` is deprecated. Use `orderBy('column', 'asc')` instead.");
+        return parseOrderByWithModifiers((0, reference_parser_js_1.parseStringReference)(ref), direction);
+    }
+    return (0, reference_parser_js_1.parseStringReference)(expr);
+}
+function parseOrderByWithModifiers(expr, modifiers) {
+    if (typeof modifiers === 'string') {
+        if (!isOrderByDirection(modifiers)) {
+            throw new Error(`Invalid order by direction: ${modifiers}`);
+        }
+        return order_by_item_node_js_1.OrderByItemNode.create(expr, raw_node_js_1.RawNode.createWithSql(modifiers));
+    }
+    if ((0, expression_js_1.isExpression)(modifiers)) {
+        (0, log_once_js_1.logOnce)("`orderBy(..., expr)` is deprecated. Use `orderBy(..., 'asc')` or `orderBy(..., (ob) => ...)` instead.");
+        return order_by_item_node_js_1.OrderByItemNode.create(expr, modifiers.toOperationNode());
+    }
+    const node = order_by_item_node_js_1.OrderByItemNode.create(expr);
+    if (!modifiers) {
+        return node;
+    }
+    return modifiers(new order_by_item_builder_js_1.OrderByItemBuilder({ node })).toOperationNode();
+}

node_modules/kysely/dist/cjs/parser/parse-utils.d.ts

@@ -0,0 +1,10 @@
+import { type JoinType } from '../operation-node/join-node.js';
+import { JoinBuilder } from '../query-builder/join-builder.js';
+import { OverBuilder } from '../query-builder/over-builder.js';
+import { type SelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import { QueryCreator } from '../query-creator.js';
+import { type TableExpression } from './table-parser.js';
+export declare function createSelectQueryBuilder(): SelectQueryBuilder<any, any, any>;
+export declare function createQueryCreator(): QueryCreator<any>;
+export declare function createJoinBuilder(joinType: JoinType, table: TableExpression<any, any>): JoinBuilder<any, any>;
+export declare function createOverBuilder(): OverBuilder<any, any>;

node_modules/kysely/dist/cjs/parser/parse-utils.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSelectQueryBuilder = createSelectQueryBuilder;
+exports.createQueryCreator = createQueryCreator;
+exports.createJoinBuilder = createJoinBuilder;
+exports.createOverBuilder = createOverBuilder;
+const join_node_js_1 = require("../operation-node/join-node.js");
+const over_node_js_1 = require("../operation-node/over-node.js");
+const select_query_node_js_1 = require("../operation-node/select-query-node.js");
+const join_builder_js_1 = require("../query-builder/join-builder.js");
+const over_builder_js_1 = require("../query-builder/over-builder.js");
+const select_query_builder_js_1 = require("../query-builder/select-query-builder.js");
+const query_creator_js_1 = require("../query-creator.js");
+const noop_query_executor_js_1 = require("../query-executor/noop-query-executor.js");
+const query_id_js_1 = require("../util/query-id.js");
+const table_parser_js_1 = require("./table-parser.js");
+function createSelectQueryBuilder() {
+    return (0, select_query_builder_js_1.createSelectQueryBuilder)({
+        queryId: (0, query_id_js_1.createQueryId)(),
+        executor: noop_query_executor_js_1.NOOP_QUERY_EXECUTOR,
+        queryNode: select_query_node_js_1.SelectQueryNode.createFrom((0, table_parser_js_1.parseTableExpressionOrList)([])),
+    });
+}
+function createQueryCreator() {
+    return new query_creator_js_1.QueryCreator({
+        executor: noop_query_executor_js_1.NOOP_QUERY_EXECUTOR,
+    });
+}
+function createJoinBuilder(joinType, table) {
+    return new join_builder_js_1.JoinBuilder({
+        joinNode: join_node_js_1.JoinNode.create(joinType, (0, table_parser_js_1.parseTableExpression)(table)),
+    });
+}
+function createOverBuilder() {
+    return new over_builder_js_1.OverBuilder({
+        overNode: over_node_js_1.OverNode.create(),
+    });
+}

node_modules/kysely/dist/cjs/parser/partition-by-parser.d.ts

@@ -0,0 +1,6 @@
+import type { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
+import { PartitionByItemNode } from '../operation-node/partition-by-item-node.js';
+import { type StringReference } from './reference-parser.js';
+export type PartitionByExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any>;
+export type PartitionByExpressionOrList<DB, TB extends keyof DB> = ReadonlyArray<PartitionByExpression<DB, TB>> | PartitionByExpression<DB, TB>;
+export declare function parsePartitionBy(partitionBy: PartitionByExpressionOrList<any, any>): PartitionByItemNode[];

node_modules/kysely/dist/cjs/parser/partition-by-parser.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePartitionBy = parsePartitionBy;
+const partition_by_item_node_js_1 = require("../operation-node/partition-by-item-node.js");
+const reference_parser_js_1 = require("./reference-parser.js");
+function parsePartitionBy(partitionBy) {
+    return (0, reference_parser_js_1.parseReferenceExpressionOrList)(partitionBy).map(partition_by_item_node_js_1.PartitionByItemNode.create);
+}

node_modules/kysely/dist/cjs/parser/reference-parser.d.ts

@@ -0,0 +1,31 @@
+import { AliasNode } from '../operation-node/alias-node.js';
+import { ColumnNode } from '../operation-node/column-node.js';
+import { ReferenceNode } from '../operation-node/reference-node.js';
+import type { AnyColumn, AnyColumnWithTable, ExtractColumnType } from '../util/type-utils.js';
+import type { SelectQueryBuilderExpression } from '../query-builder/select-query-builder-expression.js';
+import { type ExpressionOrFactory } from './expression-parser.js';
+import type { DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
+import type { SelectType } from '../util/column-type.js';
+import type { OperationNode } from '../operation-node/operation-node.js';
+import type { Expression } from '../expression/expression.js';
+import type { SimpleReferenceExpressionNode } from '../operation-node/simple-reference-expression-node.js';
+import { type OrderByDirection } from './order-by-parser.js';
+import { type JSONOperatorWith$ } from '../operation-node/operator-node.js';
+import { JSONReferenceNode } from '../operation-node/json-reference-node.js';
+export type StringReference<DB, TB extends keyof DB> = AnyColumn<DB, TB> | AnyColumnWithTable<DB, TB>;
+export type SimpleReferenceExpression<DB, TB extends keyof DB> = StringReference<DB, TB> | DynamicReferenceBuilder<any>;
+export type ReferenceExpression<DB, TB extends keyof DB> = SimpleReferenceExpression<DB, TB> | ExpressionOrFactory<DB, TB, any>;
+export type ReferenceExpressionOrList<DB, TB extends keyof DB> = ReferenceExpression<DB, TB> | ReadonlyArray<ReferenceExpression<DB, TB>>;
+export type ExtractTypeFromReferenceExpression<DB, TB extends keyof DB, RE, DV = unknown> = SelectType<ExtractRawTypeFromReferenceExpression<DB, TB, RE, DV>>;
+export type ExtractRawTypeFromReferenceExpression<DB, TB extends keyof DB, RE, DV = unknown> = RE extends string ? ExtractTypeFromStringReference<DB, TB, RE> : RE extends SelectQueryBuilderExpression<infer O> ? O[keyof O] | null : RE extends (qb: any) => SelectQueryBuilderExpression<infer O> ? O[keyof O] | null : RE extends Expression<infer O> ? O : RE extends (qb: any) => Expression<infer O> ? O : DV;
+export type ExtractTypeFromStringReference<DB, TB extends keyof DB, RE extends string, DV = unknown> = RE extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : RE extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : RE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, RE> : DV;
+export type OrderedColumnName<C extends string> = C extends `${string} ${infer O}` ? O extends OrderByDirection ? C : never : C;
+export type ExtractColumnNameFromOrderedColumnName<C extends string> = C extends `${infer CL} ${infer O}` ? O extends OrderByDirection ? CL : never : C;
+export declare function parseSimpleReferenceExpression(exp: SimpleReferenceExpression<any, any>): SimpleReferenceExpressionNode;
+export declare function parseReferenceExpressionOrList(arg: ReferenceExpressionOrList<any, any>): OperationNode[];
+export declare function parseReferenceExpression(exp: ReferenceExpression<any, any>): OperationNode;
+export declare function parseJSONReference(ref: string, op: JSONOperatorWith$): JSONReferenceNode;
+export declare function parseStringReference(ref: string): ReferenceNode;
+export declare function parseAliasedStringReference(ref: string): SimpleReferenceExpressionNode | AliasNode;
+export declare function parseColumnName(column: AnyColumn<any, any>): ColumnNode;
+export declare function parseOrderedColumnName(column: string): OperationNode;

node_modules/kysely/dist/cjs/parser/reference-parser.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSimpleReferenceExpression = parseSimpleReferenceExpression;
+exports.parseReferenceExpressionOrList = parseReferenceExpressionOrList;
+exports.parseReferenceExpression = parseReferenceExpression;
+exports.parseJSONReference = parseJSONReference;
+exports.parseStringReference = parseStringReference;
+exports.parseAliasedStringReference = parseAliasedStringReference;
+exports.parseColumnName = parseColumnName;
+exports.parseOrderedColumnName = parseOrderedColumnName;
+const alias_node_js_1 = require("../operation-node/alias-node.js");
+const column_node_js_1 = require("../operation-node/column-node.js");
+const reference_node_js_1 = require("../operation-node/reference-node.js");
+const table_node_js_1 = require("../operation-node/table-node.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+const expression_parser_js_1 = require("./expression-parser.js");
+const identifier_node_js_1 = require("../operation-node/identifier-node.js");
+const order_by_parser_js_1 = require("./order-by-parser.js");
+const operator_node_js_1 = require("../operation-node/operator-node.js");
+const json_reference_node_js_1 = require("../operation-node/json-reference-node.js");
+const json_operator_chain_node_js_1 = require("../operation-node/json-operator-chain-node.js");
+const json_path_node_js_1 = require("../operation-node/json-path-node.js");
+function parseSimpleReferenceExpression(exp) {
+    if ((0, object_utils_js_1.isString)(exp)) {
+        return parseStringReference(exp);
+    }
+    return exp.toOperationNode();
+}
+function parseReferenceExpressionOrList(arg) {
+    if ((0, object_utils_js_1.isReadonlyArray)(arg)) {
+        return arg.map((it) => parseReferenceExpression(it));
+    }
+    else {
+        return [parseReferenceExpression(arg)];
+    }
+}
+function parseReferenceExpression(exp) {
+    if ((0, expression_parser_js_1.isExpressionOrFactory)(exp)) {
+        return (0, expression_parser_js_1.parseExpression)(exp);
+    }
+    return parseSimpleReferenceExpression(exp);
+}
+function parseJSONReference(ref, op) {
+    const referenceNode = parseStringReference(ref);
+    if ((0, operator_node_js_1.isJSONOperator)(op)) {
+        return json_reference_node_js_1.JSONReferenceNode.create(referenceNode, json_operator_chain_node_js_1.JSONOperatorChainNode.create(operator_node_js_1.OperatorNode.create(op)));
+    }
+    const opWithoutLastChar = op.slice(0, -1);
+    if ((0, operator_node_js_1.isJSONOperator)(opWithoutLastChar)) {
+        return json_reference_node_js_1.JSONReferenceNode.create(referenceNode, json_path_node_js_1.JSONPathNode.create(operator_node_js_1.OperatorNode.create(opWithoutLastChar)));
+    }
+    throw new Error(`Invalid JSON operator: ${op}`);
+}
+function parseStringReference(ref) {
+    const COLUMN_SEPARATOR = '.';
+    if (!ref.includes(COLUMN_SEPARATOR)) {
+        return reference_node_js_1.ReferenceNode.create(column_node_js_1.ColumnNode.create(ref));
+    }
+    const parts = ref.split(COLUMN_SEPARATOR).map(trim);
+    if (parts.length === 3) {
+        return parseStringReferenceWithTableAndSchema(parts);
+    }
+    if (parts.length === 2) {
+        return parseStringReferenceWithTable(parts);
+    }
+    throw new Error(`invalid column reference ${ref}`);
+}
+function parseAliasedStringReference(ref) {
+    const ALIAS_SEPARATOR = ' as ';
+    if (ref.includes(ALIAS_SEPARATOR)) {
+        const [columnRef, alias] = ref.split(ALIAS_SEPARATOR).map(trim);
+        return alias_node_js_1.AliasNode.create(parseStringReference(columnRef), identifier_node_js_1.IdentifierNode.create(alias));
+    }
+    else {
+        return parseStringReference(ref);
+    }
+}
+function parseColumnName(column) {
+    return column_node_js_1.ColumnNode.create(column);
+}
+function parseOrderedColumnName(column) {
+    const ORDER_SEPARATOR = ' ';
+    if (column.includes(ORDER_SEPARATOR)) {
+        const [columnName, order] = column.split(ORDER_SEPARATOR).map(trim);
+        if (!(0, order_by_parser_js_1.isOrderByDirection)(order)) {
+            throw new Error(`invalid order direction "${order}" next to "${columnName}"`);
+        }
+        return (0, order_by_parser_js_1.parseOrderBy)([columnName, order])[0];
+    }
+    else {
+        return parseColumnName(column);
+    }
+}
+function parseStringReferenceWithTableAndSchema(parts) {
+    const [schema, table, column] = parts;
+    return reference_node_js_1.ReferenceNode.create(column_node_js_1.ColumnNode.create(column), table_node_js_1.TableNode.createWithSchema(schema, table));
+}
+function parseStringReferenceWithTable(parts) {
+    const [table, column] = parts;
+    return reference_node_js_1.ReferenceNode.create(column_node_js_1.ColumnNode.create(column), table_node_js_1.TableNode.create(table));
+}
+function trim(str) {
+    return str.trim();
+}

node_modules/kysely/dist/cjs/parser/returning-parser.d.ts

@@ -0,0 +1,8 @@
+import type { DeleteResult } from '../query-builder/delete-result.js';
+import type { InsertResult } from '../query-builder/insert-result.js';
+import type { MergeResult } from '../query-builder/merge-result.js';
+import type { UpdateResult } from '../query-builder/update-result.js';
+import type { Selection, AllSelection, CallbackSelection } from './select-parser.js';
+export type ReturningRow<DB, TB extends keyof DB, O, SE> = O extends InsertResult | DeleteResult | UpdateResult | MergeResult ? Selection<DB, TB, SE> : O & Selection<DB, TB, SE>;
+export type ReturningCallbackRow<DB, TB extends keyof DB, O, CB> = O extends InsertResult | DeleteResult | UpdateResult | MergeResult ? CallbackSelection<DB, TB, CB> : O & CallbackSelection<DB, TB, CB>;
+export type ReturningAllRow<DB, TB extends keyof DB, O> = O extends InsertResult | DeleteResult | UpdateResult | MergeResult ? AllSelection<DB, TB> : O & AllSelection<DB, TB>;

node_modules/kysely/dist/cjs/parser/returning-parser.js

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

node_modules/kysely/dist/cjs/parser/savepoint-parser.d.ts

@@ -0,0 +1,4 @@
+import { RawNode } from '../operation-node/raw-node.js';
+export type RollbackToSavepoint<S extends string[], SN extends S[number]> = S extends [...infer L, infer R] ? R extends SN ? S : RollbackToSavepoint<L extends string[] ? L : never, SN> : never;
+export type ReleaseSavepoint<S extends string[], SN extends S[number]> = S extends [...infer L, infer R] ? R extends SN ? L : ReleaseSavepoint<L extends string[] ? L : never, SN> : never;
+export declare function parseSavepointCommand(command: string, savepointName: string): RawNode;

node_modules/kysely/dist/cjs/parser/savepoint-parser.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSavepointCommand = parseSavepointCommand;
+const identifier_node_js_1 = require("../operation-node/identifier-node.js");
+const raw_node_js_1 = require("../operation-node/raw-node.js");
+function parseSavepointCommand(command, savepointName) {
+    return raw_node_js_1.RawNode.createWithChildren([
+        raw_node_js_1.RawNode.createWithSql(`${command} `),
+        identifier_node_js_1.IdentifierNode.create(savepointName), // ensures savepointName gets sanitized
+    ]);
+}

node_modules/kysely/dist/cjs/parser/select-from-parser.d.ts

@@ -0,0 +1,6 @@
+import type { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import type { ShallowRecord } from '../util/type-utils.js';
+import type { ExtractTableAlias, From, FromTables, TableExpressionOrList } from './table-parser.js';
+export type SelectFrom<DB, TB extends keyof DB, TE extends TableExpressionOrList<DB, TB>> = [TE] extends [keyof DB] ? SelectQueryBuilder<DB, TB | ExtractTableAlias<DB, TE>, {}> : [
+    TE
+] extends [`${infer T} as ${infer A}`] ? T extends keyof DB ? SelectQueryBuilder<DB & ShallowRecord<A, DB[T]>, TB | A, {}> : never : TE extends ReadonlyArray<infer T> ? SelectQueryBuilder<From<DB, T>, FromTables<DB, TB, T>, {}> : SelectQueryBuilder<From<DB, TE>, FromTables<DB, TB, TE>, {}>;

node_modules/kysely/dist/cjs/parser/select-from-parser.js

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

node_modules/kysely/dist/cjs/parser/select-parser.d.ts

@@ -0,0 +1,36 @@
+import type { AliasedSelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import { SelectionNode } from '../operation-node/selection-node.js';
+import type { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, DrainOuterGeneric, ExtractColumnType } from '../util/type-utils.js';
+import { type DynamicReferenceBuilder } from '../dynamic/dynamic-reference-builder.js';
+import { type AliasedExpressionOrFactory } from './expression-parser.js';
+import type { SelectType } from '../util/column-type.js';
+import type { AliasedExpression } from '../expression/expression.js';
+import { type ExpressionBuilder } from '../expression/expression-builder.js';
+export type SelectExpression<DB, TB extends keyof DB> = AnyAliasedColumnWithTable<DB, TB> | AnyAliasedColumn<DB, TB> | AnyColumnWithTable<DB, TB> | AnyColumn<DB, TB> | DynamicReferenceBuilder<any> | AliasedExpressionOrFactory<DB, TB>;
+export type SelectCallback<DB, TB extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => ReadonlyArray<SelectExpression<DB, TB>>;
+/**
+ * Turns a SelectExpression or a union of them into a selection object.
+ */
+export type Selection<DB, TB extends keyof DB, SE> = [DB] extends [unknown] ? {
+    [E in FlattenSelectExpression<SE> as ExtractAliasFromSelectExpression<E>]: SelectType<ExtractTypeFromSelectExpression<DB, TB, E>>;
+} : {};
+/**
+ * Turns a SelectCallback into a selection object.
+ */
+export type CallbackSelection<DB, TB extends keyof DB, CB> = CB extends (eb: any) => ReadonlyArray<infer SE> ? Selection<DB, TB, SE> : never;
+export type SelectArg<DB, TB extends keyof DB, SE extends SelectExpression<DB, TB>> = SE | ReadonlyArray<SE> | ((eb: ExpressionBuilder<DB, TB>) => ReadonlyArray<SE>);
+type FlattenSelectExpression<SE> = SE extends DynamicReferenceBuilder<infer RA> ? {
+    [R in RA]: DynamicReferenceBuilder<R>;
+}[RA] : SE;
+type ExtractAliasFromSelectExpression<SE> = SE extends string ? ExtractAliasFromStringSelectExpression<SE> : SE extends AliasedExpression<any, infer EA> ? EA : SE extends (qb: any) => AliasedExpression<any, infer EA> ? EA : SE extends DynamicReferenceBuilder<infer RA> ? ExtractAliasFromStringSelectExpression<RA> : never;
+type ExtractAliasFromStringSelectExpression<SE extends string> = SE extends `${string}.${string}.${string} as ${infer A}` ? A : SE extends `${string}.${string} as ${infer A}` ? A : SE extends `${string} as ${infer A}` ? A : SE extends `${string}.${string}.${infer C}` ? C : SE extends `${string}.${infer C}` ? C : SE;
+type ExtractTypeFromSelectExpression<DB, TB extends keyof DB, SE> = SE extends string ? ExtractTypeFromStringSelectExpression<DB, TB, SE> : SE extends AliasedSelectQueryBuilder<infer O, any> ? O[keyof O] | null : SE extends (eb: any) => AliasedSelectQueryBuilder<infer O, any> ? O[keyof O] | null : SE extends AliasedExpression<infer O, any> ? O : SE extends (eb: any) => AliasedExpression<infer O, any> ? O : SE extends DynamicReferenceBuilder<infer RA> ? ExtractTypeFromStringSelectExpression<DB, TB, RA> | undefined : never;
+type ExtractTypeFromStringSelectExpression<DB, TB extends keyof DB, SE extends string> = SE extends `${infer SC}.${infer T}.${infer C} as ${string}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : SE extends `${infer T}.${infer C} as ${string}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : SE extends `${infer C} as ${string}` ? C extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, C> : never : SE extends `${infer SC}.${infer T}.${infer C}` ? `${SC}.${T}` extends TB ? C extends keyof DB[`${SC}.${T}`] ? DB[`${SC}.${T}`][C] : never : never : SE extends `${infer T}.${infer C}` ? T extends TB ? C extends keyof DB[T] ? DB[T][C] : never : never : SE extends AnyColumn<DB, TB> ? ExtractColumnType<DB, TB, SE> : never;
+export type AllSelection<DB, TB extends keyof DB> = DrainOuterGeneric<{
+    [C in AnyColumn<DB, TB>]: {
+        [T in TB]: SelectType<C extends keyof DB[T] ? DB[T][C] : never>;
+    }[TB];
+}>;
+export declare function parseSelectArg(selection: SelectArg<any, any, SelectExpression<any, any>>): SelectionNode[];
+export declare function parseSelectAll(table?: string | string[]): SelectionNode[];
+export {};

node_modules/kysely/dist/cjs/parser/select-parser.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSelectArg = parseSelectArg;
+exports.parseSelectAll = parseSelectAll;
+const object_utils_js_1 = require("../util/object-utils.js");
+const selection_node_js_1 = require("../operation-node/selection-node.js");
+const reference_parser_js_1 = require("./reference-parser.js");
+const dynamic_reference_builder_js_1 = require("../dynamic/dynamic-reference-builder.js");
+const expression_parser_js_1 = require("./expression-parser.js");
+const table_parser_js_1 = require("./table-parser.js");
+const expression_builder_js_1 = require("../expression/expression-builder.js");
+function parseSelectArg(selection) {
+    if ((0, object_utils_js_1.isFunction)(selection)) {
+        return parseSelectArg(selection((0, expression_builder_js_1.expressionBuilder)()));
+    }
+    else if ((0, object_utils_js_1.isReadonlyArray)(selection)) {
+        return selection.map((it) => parseSelectExpression(it));
+    }
+    else {
+        return [parseSelectExpression(selection)];
+    }
+}
+function parseSelectExpression(selection) {
+    if ((0, object_utils_js_1.isString)(selection)) {
+        return selection_node_js_1.SelectionNode.create((0, reference_parser_js_1.parseAliasedStringReference)(selection));
+    }
+    else if ((0, dynamic_reference_builder_js_1.isDynamicReferenceBuilder)(selection)) {
+        return selection_node_js_1.SelectionNode.create(selection.toOperationNode());
+    }
+    else {
+        return selection_node_js_1.SelectionNode.create((0, expression_parser_js_1.parseAliasedExpression)(selection));
+    }
+}
+function parseSelectAll(table) {
+    if (!table) {
+        return [selection_node_js_1.SelectionNode.createSelectAll()];
+    }
+    else if (Array.isArray(table)) {
+        return table.map(parseSelectAllArg);
+    }
+    else {
+        return [parseSelectAllArg(table)];
+    }
+}
+function parseSelectAllArg(table) {
+    if ((0, object_utils_js_1.isString)(table)) {
+        return selection_node_js_1.SelectionNode.createSelectAllFromTable((0, table_parser_js_1.parseTable)(table));
+    }
+    throw new Error(`invalid value selectAll expression: ${JSON.stringify(table)}`);
+}

node_modules/kysely/dist/cjs/parser/set-operation-parser.d.ts

@@ -0,0 +1,5 @@
+import { type ExpressionBuilder } from '../expression/expression-builder.js';
+import type { Expression } from '../expression/expression.js';
+import { type SetOperator, SetOperationNode } from '../operation-node/set-operation-node.js';
+export type SetOperandExpression<DB, O> = Expression<O> | ReadonlyArray<Expression<O>> | ((eb: ExpressionBuilder<DB, never>) => Expression<O> | ReadonlyArray<Expression<O>>);
+export declare function parseSetOperations(operator: SetOperator, expression: SetOperandExpression<any, any>, all: boolean): Readonly<SetOperationNode>[];

node_modules/kysely/dist/cjs/parser/set-operation-parser.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSetOperations = parseSetOperations;
+const expression_builder_js_1 = require("../expression/expression-builder.js");
+const set_operation_node_js_1 = require("../operation-node/set-operation-node.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+const expression_parser_js_1 = require("./expression-parser.js");
+function parseSetOperations(operator, expression, all) {
+    if ((0, object_utils_js_1.isFunction)(expression)) {
+        expression = expression((0, expression_builder_js_1.createExpressionBuilder)());
+    }
+    if (!(0, object_utils_js_1.isReadonlyArray)(expression)) {
+        expression = [expression];
+    }
+    return expression.map((expr) => set_operation_node_js_1.SetOperationNode.create(operator, (0, expression_parser_js_1.parseExpression)(expr), all));
+}

node_modules/kysely/dist/cjs/parser/table-parser.d.ts

@@ -0,0 +1,24 @@
+import { AliasNode } from '../operation-node/alias-node.js';
+import { TableNode } from '../operation-node/table-node.js';
+import { type AliasedExpressionOrFactory } from './expression-parser.js';
+import type { OperationNode } from '../operation-node/operation-node.js';
+import type { AliasedExpression } from '../expression/expression.js';
+import type { DrainOuterGeneric } from '../util/type-utils.js';
+import { type AliasedDynamicTableBuilder } from '../dynamic/dynamic-table-builder.js';
+export type TableExpression<DB, TB extends keyof DB> = AnyAliasedTable<DB> | AnyTable<DB> | AliasedExpressionOrFactory<DB, TB> | AliasedDynamicTableBuilder<any, any>;
+export type TableExpressionOrList<DB, TB extends keyof DB> = TableExpression<DB, TB> | ReadonlyArray<TableExpression<DB, TB>>;
+export type SimpleTableReference<DB> = AnyAliasedTable<DB> | AnyTable<DB>;
+export type AnyAliasedTable<DB> = `${AnyTable<DB>} as ${string}`;
+export type AnyTable<DB> = keyof DB & string;
+export type From<DB, TE> = DrainOuterGeneric<{
+    [C in keyof DB | ExtractAliasFromTableExpression<DB, TE>]: C extends ExtractAliasFromTableExpression<DB, TE> ? ExtractRowTypeFromTableExpression<DB, TE, C> : C extends keyof DB ? DB[C] : never;
+}>;
+export type FromTables<DB, TB extends keyof DB, TE> = DrainOuterGeneric<TB | ExtractAliasFromTableExpression<DB, TE>>;
+export type ExtractTableAlias<DB, TE> = TE extends `${string} as ${infer TA}` ? TA extends keyof DB ? TA : never : TE extends keyof DB ? TE : never;
+type ExtractAliasFromTableExpression<DB, TE> = TE extends string ? TE extends `${string} as ${infer TA}` ? TA : TE extends keyof DB ? TE : never : TE extends AliasedExpression<any, infer QA> ? QA : TE extends (qb: any) => AliasedExpression<any, infer QA> ? QA : TE extends AliasedDynamicTableBuilder<any, infer DA> ? DA : never;
+type ExtractRowTypeFromTableExpression<DB, TE, A extends keyof any> = TE extends `${infer T} as ${infer TA}` ? TA extends A ? T extends keyof DB ? DB[T] : never : never : TE extends A ? TE extends keyof DB ? DB[TE] : never : TE extends AliasedExpression<infer O, infer QA> ? QA extends A ? O : never : TE extends (qb: any) => AliasedExpression<infer O, infer QA> ? QA extends A ? O : never : TE extends AliasedDynamicTableBuilder<infer T, infer DA> ? DA extends A ? T extends keyof DB ? DB[T] : never : never : never;
+export declare function parseTableExpressionOrList(table: TableExpressionOrList<any, any>): OperationNode[];
+export declare function parseTableExpression(table: TableExpression<any, any>): OperationNode;
+export declare function parseAliasedTable(from: string): TableNode | AliasNode;
+export declare function parseTable(from: string): TableNode;
+export {};

node_modules/kysely/dist/cjs/parser/table-parser.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTableExpressionOrList = parseTableExpressionOrList;
+exports.parseTableExpression = parseTableExpression;
+exports.parseAliasedTable = parseAliasedTable;
+exports.parseTable = parseTable;
+const object_utils_js_1 = require("../util/object-utils.js");
+const alias_node_js_1 = require("../operation-node/alias-node.js");
+const table_node_js_1 = require("../operation-node/table-node.js");
+const expression_parser_js_1 = require("./expression-parser.js");
+const identifier_node_js_1 = require("../operation-node/identifier-node.js");
+const dynamic_table_builder_js_1 = require("../dynamic/dynamic-table-builder.js");
+function parseTableExpressionOrList(table) {
+    if ((0, object_utils_js_1.isReadonlyArray)(table)) {
+        return table.map((it) => parseTableExpression(it));
+    }
+    else {
+        return [parseTableExpression(table)];
+    }
+}
+function parseTableExpression(table) {
+    if ((0, object_utils_js_1.isString)(table)) {
+        return parseAliasedTable(table);
+    }
+    else if ((0, dynamic_table_builder_js_1.isAliasedDynamicTableBuilder)(table)) {
+        return table.toOperationNode();
+    }
+    else {
+        return (0, expression_parser_js_1.parseAliasedExpression)(table);
+    }
+}
+function parseAliasedTable(from) {
+    const ALIAS_SEPARATOR = ' as ';
+    if (from.includes(ALIAS_SEPARATOR)) {
+        const [table, alias] = from.split(ALIAS_SEPARATOR).map(trim);
+        return alias_node_js_1.AliasNode.create(parseTable(table), identifier_node_js_1.IdentifierNode.create(alias));
+    }
+    else {
+        return parseTable(from);
+    }
+}
+function parseTable(from) {
+    const SCHEMA_SEPARATOR = '.';
+    if (from.includes(SCHEMA_SEPARATOR)) {
+        const [schema, table] = from.split(SCHEMA_SEPARATOR).map(trim);
+        return table_node_js_1.TableNode.createWithSchema(schema, table);
+    }
+    else {
+        return table_node_js_1.TableNode.create(from);
+    }
+}
+function trim(str) {
+    return str.trim();
+}

node_modules/kysely/dist/cjs/parser/top-parser.d.ts

@@ -0,0 +1,2 @@
+import { type TopModifier, TopNode } from '../operation-node/top-node.js';
+export declare function parseTop(expression: number | bigint, modifiers?: TopModifier): TopNode;

node_modules/kysely/dist/cjs/parser/top-parser.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTop = parseTop;
+const top_node_js_1 = require("../operation-node/top-node.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+function parseTop(expression, modifiers) {
+    if (!(0, object_utils_js_1.isNumber)(expression) && !(0, object_utils_js_1.isBigInt)(expression)) {
+        throw new Error(`Invalid top expression: ${expression}`);
+    }
+    if (!(0, object_utils_js_1.isUndefined)(modifiers) && !isTopModifiers(modifiers)) {
+        throw new Error(`Invalid top modifiers: ${modifiers}`);
+    }
+    return top_node_js_1.TopNode.create(expression, modifiers);
+}
+function isTopModifiers(modifiers) {
+    return (modifiers === 'percent' ||
+        modifiers === 'with ties' ||
+        modifiers === 'percent with ties');
+}

node_modules/kysely/dist/cjs/parser/tuple-parser.d.ts

@@ -0,0 +1,47 @@
+import type { DrainOuterGeneric } from '../util/type-utils.js';
+import type { ExtractTypeFromReferenceExpression } from './reference-parser.js';
+import type { ExtractTypeFromValueExpression } from './value-parser.js';
+export type RefTuple2<DB, TB extends keyof DB, R1, R2> = DrainOuterGeneric<[
+    ExtractTypeFromReferenceExpression<DB, TB, R1>,
+    ExtractTypeFromReferenceExpression<DB, TB, R2>
+]>;
+export type RefTuple3<DB, TB extends keyof DB, R1, R2, R3> = DrainOuterGeneric<[
+    ExtractTypeFromReferenceExpression<DB, TB, R1>,
+    ExtractTypeFromReferenceExpression<DB, TB, R2>,
+    ExtractTypeFromReferenceExpression<DB, TB, R3>
+]>;
+export type RefTuple4<DB, TB extends keyof DB, R1, R2, R3, R4> = DrainOuterGeneric<[
+    ExtractTypeFromReferenceExpression<DB, TB, R1>,
+    ExtractTypeFromReferenceExpression<DB, TB, R2>,
+    ExtractTypeFromReferenceExpression<DB, TB, R3>,
+    ExtractTypeFromReferenceExpression<DB, TB, R4>
+]>;
+export type RefTuple5<DB, TB extends keyof DB, R1, R2, R3, R4, R5> = DrainOuterGeneric<[
+    ExtractTypeFromReferenceExpression<DB, TB, R1>,
+    ExtractTypeFromReferenceExpression<DB, TB, R2>,
+    ExtractTypeFromReferenceExpression<DB, TB, R3>,
+    ExtractTypeFromReferenceExpression<DB, TB, R4>,
+    ExtractTypeFromReferenceExpression<DB, TB, R5>
+]>;
+export type ValTuple2<V1, V2> = DrainOuterGeneric<[
+    ExtractTypeFromValueExpression<V1>,
+    ExtractTypeFromValueExpression<V2>
+]>;
+export type ValTuple3<V1, V2, V3> = DrainOuterGeneric<[
+    ExtractTypeFromValueExpression<V1>,
+    ExtractTypeFromValueExpression<V2>,
+    ExtractTypeFromValueExpression<V3>
+]>;
+export type ValTuple4<V1, V2, V3, V4> = DrainOuterGeneric<[
+    ExtractTypeFromValueExpression<V1>,
+    ExtractTypeFromValueExpression<V2>,
+    ExtractTypeFromValueExpression<V3>,
+    ExtractTypeFromValueExpression<V4>
+]>;
+export type ValTuple5<V1, V2, V3, V4, V5> = DrainOuterGeneric<[
+    ExtractTypeFromValueExpression<V1>,
+    ExtractTypeFromValueExpression<V2>,
+    ExtractTypeFromValueExpression<V3>,
+    ExtractTypeFromValueExpression<V4>,
+    ExtractTypeFromValueExpression<V5>
+]>;

node_modules/kysely/dist/cjs/parser/tuple-parser.js

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

node_modules/kysely/dist/cjs/parser/unary-operation-parser.d.ts

@@ -0,0 +1,8 @@
+import { type UnaryOperator } from '../operation-node/operator-node.js';
+import { UnaryOperationNode } from '../operation-node/unary-operation-node.js';
+import type { ExpressionOrFactory } from './expression-parser.js';
+import { type ReferenceExpression } from './reference-parser.js';
+export type ExistsExpression<DB, TB extends keyof DB> = ExpressionOrFactory<DB, TB, any>;
+export declare function parseExists(operand: ExistsExpression<any, any>): UnaryOperationNode;
+export declare function parseNotExists(operand: ExistsExpression<any, any>): UnaryOperationNode;
+export declare function parseUnaryOperation(operator: UnaryOperator, operand: ReferenceExpression<any, any>): UnaryOperationNode;

node_modules/kysely/dist/cjs/parser/unary-operation-parser.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseExists = parseExists;
+exports.parseNotExists = parseNotExists;
+exports.parseUnaryOperation = parseUnaryOperation;
+const operator_node_js_1 = require("../operation-node/operator-node.js");
+const unary_operation_node_js_1 = require("../operation-node/unary-operation-node.js");
+const reference_parser_js_1 = require("./reference-parser.js");
+function parseExists(operand) {
+    return parseUnaryOperation('exists', operand);
+}
+function parseNotExists(operand) {
+    return parseUnaryOperation('not exists', operand);
+}
+function parseUnaryOperation(operator, operand) {
+    return unary_operation_node_js_1.UnaryOperationNode.create(operator_node_js_1.OperatorNode.create(operator), (0, reference_parser_js_1.parseReferenceExpression)(operand));
+}

node_modules/kysely/dist/cjs/parser/update-parser.d.ts

@@ -0,0 +1,9 @@
+import type { UpdateQueryBuilder } from '../query-builder/update-query-builder.js';
+import type { UpdateResult } from '../query-builder/update-result.js';
+import type { ShallowRecord } from '../util/type-utils.js';
+import type { ExtractTableAlias, From, FromTables, TableExpressionOrList } from './table-parser.js';
+export type UpdateTable<DB, TE extends TableExpressionOrList<DB, never>> = [
+    TE
+] extends [keyof DB] ? UpdateQueryBuilder<DB, ExtractTableAlias<DB, TE>, ExtractTableAlias<DB, TE>, UpdateResult> : [
+    TE
+] extends [`${infer T} as ${infer A}`] ? T extends keyof DB ? UpdateQueryBuilder<DB & ShallowRecord<A, DB[T]>, A, A, UpdateResult> : never : TE extends ReadonlyArray<infer T> ? UpdateQueryBuilder<From<DB, T>, FromTables<DB, never, T>, FromTables<DB, never, T>, UpdateResult> : UpdateQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, FromTables<DB, never, TE>, UpdateResult>;

node_modules/kysely/dist/cjs/parser/update-parser.js

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

node_modules/kysely/dist/cjs/parser/update-set-parser.d.ts

@@ -0,0 +1,16 @@
+import { ColumnUpdateNode } from '../operation-node/column-update-node.js';
+import { type ExpressionBuilder } from '../expression/expression-builder.js';
+import type { UpdateType } from '../util/column-type.js';
+import { type ValueExpression } from './value-parser.js';
+import { type ExtractRawTypeFromReferenceExpression, type ReferenceExpression } from './reference-parser.js';
+import type { AnyColumn, DrainOuterGeneric } from '../util/type-utils.js';
+export type UpdateObject<DB, TB extends keyof DB, UT extends keyof DB = TB> = DrainOuterGeneric<{
+    [C in AnyColumn<DB, UT>]?: {
+        [T in UT]: C extends keyof DB[T] ? ValueExpression<DB, TB, UpdateType<DB[T][C]>> | undefined : never;
+    }[UT];
+}>;
+export type UpdateObjectFactory<DB, TB extends keyof DB, UT extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => UpdateObject<DB, TB, UT>;
+export type UpdateObjectExpression<DB, TB extends keyof DB, UT extends keyof DB = TB> = UpdateObject<DB, TB, UT> | UpdateObjectFactory<DB, TB, UT>;
+export type ExtractUpdateTypeFromReferenceExpression<DB, TB extends keyof DB, RE, DV = unknown> = UpdateType<ExtractRawTypeFromReferenceExpression<DB, TB, RE, DV>>;
+export declare function parseUpdate(...args: [UpdateObjectExpression<any, any, any>] | [ReferenceExpression<any, any>, ValueExpression<any, any, any>]): ReadonlyArray<ColumnUpdateNode>;
+export declare function parseUpdateObjectExpression(update: UpdateObjectExpression<any, any, any>): ReadonlyArray<ColumnUpdateNode>;

node_modules/kysely/dist/cjs/parser/update-set-parser.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseUpdate = parseUpdate;
+exports.parseUpdateObjectExpression = parseUpdateObjectExpression;
+const column_node_js_1 = require("../operation-node/column-node.js");
+const column_update_node_js_1 = require("../operation-node/column-update-node.js");
+const expression_builder_js_1 = require("../expression/expression-builder.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+const value_parser_js_1 = require("./value-parser.js");
+const reference_parser_js_1 = require("./reference-parser.js");
+function parseUpdate(...args) {
+    if (args.length === 2) {
+        return [
+            column_update_node_js_1.ColumnUpdateNode.create((0, reference_parser_js_1.parseReferenceExpression)(args[0]), (0, value_parser_js_1.parseValueExpression)(args[1])),
+        ];
+    }
+    return parseUpdateObjectExpression(args[0]);
+}
+function parseUpdateObjectExpression(update) {
+    const updateObj = (0, object_utils_js_1.isFunction)(update) ? update((0, expression_builder_js_1.expressionBuilder)()) : update;
+    return Object.entries(updateObj)
+        .filter(([_, value]) => value !== undefined)
+        .map(([key, value]) => {
+        return column_update_node_js_1.ColumnUpdateNode.create(column_node_js_1.ColumnNode.create(key), (0, value_parser_js_1.parseValueExpression)(value));
+    });
+}

node_modules/kysely/dist/cjs/parser/value-parser.d.ts

@@ -0,0 +1,13 @@
+import { ValueNode } from '../operation-node/value-node.js';
+import { type ExpressionOrFactory } from './expression-parser.js';
+import type { OperationNode } from '../operation-node/operation-node.js';
+import type { Expression } from '../expression/expression.js';
+import type { SelectQueryBuilderExpression } from '../query-builder/select-query-builder-expression.js';
+export type ValueExpression<DB, TB extends keyof DB, V> = V | ExpressionOrFactory<DB, TB, V>;
+export type ValueExpressionOrList<DB, TB extends keyof DB, V> = ValueExpression<DB, TB, V> | ReadonlyArray<ValueExpression<DB, TB, V>>;
+export type ExtractTypeFromValueExpressionOrList<VE> = VE extends ReadonlyArray<infer AV> ? ExtractTypeFromValueExpression<AV> : ExtractTypeFromValueExpression<VE>;
+export type ExtractTypeFromValueExpression<VE> = VE extends SelectQueryBuilderExpression<Record<string, infer SV>> ? SV : VE extends Expression<infer V> ? V : VE;
+export declare function parseValueExpressionOrList(arg: ValueExpressionOrList<any, any, unknown>): OperationNode;
+export declare function parseValueExpression(exp: ValueExpression<any, any, unknown>): OperationNode;
+export declare function isSafeImmediateValue(value: unknown): value is number | boolean | null;
+export declare function parseSafeImmediateValue(value: number | boolean | null): ValueNode;

node_modules/kysely/dist/cjs/parser/value-parser.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseValueExpressionOrList = parseValueExpressionOrList;
+exports.parseValueExpression = parseValueExpression;
+exports.isSafeImmediateValue = isSafeImmediateValue;
+exports.parseSafeImmediateValue = parseSafeImmediateValue;
+const primitive_value_list_node_js_1 = require("../operation-node/primitive-value-list-node.js");
+const value_list_node_js_1 = require("../operation-node/value-list-node.js");
+const value_node_js_1 = require("../operation-node/value-node.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+const expression_parser_js_1 = require("./expression-parser.js");
+function parseValueExpressionOrList(arg) {
+    if ((0, object_utils_js_1.isReadonlyArray)(arg)) {
+        return parseValueExpressionList(arg);
+    }
+    return parseValueExpression(arg);
+}
+function parseValueExpression(exp) {
+    if ((0, expression_parser_js_1.isExpressionOrFactory)(exp)) {
+        return (0, expression_parser_js_1.parseExpression)(exp);
+    }
+    return value_node_js_1.ValueNode.create(exp);
+}
+function isSafeImmediateValue(value) {
+    return (0, object_utils_js_1.isNumber)(value) || (0, object_utils_js_1.isBoolean)(value) || (0, object_utils_js_1.isNull)(value);
+}
+function parseSafeImmediateValue(value) {
+    if (!isSafeImmediateValue(value)) {
+        throw new Error(`unsafe immediate value ${JSON.stringify(value)}`);
+    }
+    return value_node_js_1.ValueNode.createImmediate(value);
+}
+function parseValueExpressionList(arg) {
+    if (arg.some(expression_parser_js_1.isExpressionOrFactory)) {
+        return value_list_node_js_1.ValueListNode.create(arg.map((it) => parseValueExpression(it)));
+    }
+    return primitive_value_list_node_js_1.PrimitiveValueListNode.create(arg);
+}

node_modules/kysely/dist/cjs/parser/with-parser.d.ts

@@ -0,0 +1,45 @@
+import type { UpdateQueryBuilder } from '../query-builder/update-query-builder.js';
+import type { DeleteQueryBuilder } from '../query-builder/delete-query-builder.js';
+import type { InsertQueryBuilder } from '../query-builder/insert-query-builder.js';
+import type { QueryCreator } from '../query-creator.js';
+import type { Expression } from '../expression/expression.js';
+import type { ShallowRecord } from '../util/type-utils.js';
+import { type CTEBuilderCallback } from '../query-builder/cte-builder.js';
+import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
+export type CommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB>) => CommonTableExpressionOutput<DB, CN>;
+export type RecursiveCommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB & {
+    [K in ExtractTableFromCommonTableExpressionName<CN>]: ExtractRowFromCommonTableExpressionName<CN>;
+}>) => CommonTableExpressionOutput<DB, CN>;
+export type QueryCreatorWithCommonTableExpression<DB, CN extends string, CTE> = QueryCreator<DB & {
+    [K in ExtractTableFromCommonTableExpressionName<CN>]: ExtractRowFromCommonTableExpression<CTE>;
+}>;
+type CommonTableExpressionOutput<DB, CN extends string> = Expression<ExtractRowFromCommonTableExpressionName<CN>> | InsertQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | UpdateQueryBuilder<DB, any, any, ExtractRowFromCommonTableExpressionName<CN>> | DeleteQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>>;
+/**
+ * Given a common CommonTableExpression CTE extracts the row type from it.
+ *
+ * For example a CTE `(db) => db.selectFrom('person').select(['id', 'first_name'])`
+ * would result in `Pick<Person, 'id' | 'first_name'>`.
+ */
+type ExtractRowFromCommonTableExpression<CTE> = CTE extends (creator: QueryCreator<any>) => infer Q ? Q extends Expression<infer QO> ? QO : Q extends InsertQueryBuilder<any, any, infer QO> ? QO : Q extends UpdateQueryBuilder<any, any, any, infer QO> ? QO : Q extends DeleteQueryBuilder<any, any, infer QO> ? QO : never : never;
+/**
+ * Extracts 'person' from a string like 'person(id, first_name)'.
+ */
+type ExtractTableFromCommonTableExpressionName<CN extends string> = CN extends `${infer TB}(${string})` ? TB : CN;
+/**
+ * Parses a string like 'person(id, first_name)' into a type:
+ *
+ * {
+ *   id: any,
+ *   first_name: any
+ * }
+ *
+ */
+type ExtractRowFromCommonTableExpressionName<CN extends string> = CN extends `${string}(${infer CL})` ? {
+    [C in ExtractColumnNamesFromColumnList<CL>]: any;
+} : ShallowRecord<string, any>;
+/**
+ * Parses a string like 'id, first_name' into a type 'id' | 'first_name'
+ */
+type ExtractColumnNamesFromColumnList<R extends string> = R extends `${infer C}, ${infer RS}` ? C | ExtractColumnNamesFromColumnList<RS> : R;
+export declare function parseCommonTableExpression(nameOrBuilderCallback: string | CTEBuilderCallback<string>, expression: CommonTableExpression<any, string>): CommonTableExpressionNode;
+export {};

node_modules/kysely/dist/cjs/parser/with-parser.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCommonTableExpression = parseCommonTableExpression;
+const common_table_expression_name_node_js_1 = require("../operation-node/common-table-expression-name-node.js");
+const parse_utils_js_1 = require("./parse-utils.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+const cte_builder_js_1 = require("../query-builder/cte-builder.js");
+const common_table_expression_node_js_1 = require("../operation-node/common-table-expression-node.js");
+function parseCommonTableExpression(nameOrBuilderCallback, expression) {
+    const expressionNode = expression((0, parse_utils_js_1.createQueryCreator)()).toOperationNode();
+    if ((0, object_utils_js_1.isFunction)(nameOrBuilderCallback)) {
+        return nameOrBuilderCallback(cteBuilderFactory(expressionNode)).toOperationNode();
+    }
+    return common_table_expression_node_js_1.CommonTableExpressionNode.create(parseCommonTableExpressionName(nameOrBuilderCallback), expressionNode);
+}
+function cteBuilderFactory(expressionNode) {
+    return (name) => {
+        return new cte_builder_js_1.CTEBuilder({
+            node: common_table_expression_node_js_1.CommonTableExpressionNode.create(parseCommonTableExpressionName(name), expressionNode),
+        });
+    };
+}
+function parseCommonTableExpressionName(name) {
+    if (name.includes('(')) {
+        const parts = name.split(/[\(\)]/);
+        const table = parts[0];
+        const columns = parts[1].split(',').map((it) => it.trim());
+        return common_table_expression_name_node_js_1.CommonTableExpressionNameNode.create(table, columns);
+    }
+    else {
+        return common_table_expression_name_node_js_1.CommonTableExpressionNameNode.create(name);
+    }
+}