@decocms/mesh 1.0.0-alpha.1

package/dist/server/node_modules/kysely/dist/esm/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 {};

package/dist/server/node_modules/kysely/dist/esm/parser/select-parser.js

@@ -0,0 +1,47 @@
+/// <reference types="./select-parser.d.ts" />
+import { isFunction, isReadonlyArray, isString } from '../util/object-utils.js';
+import { SelectionNode } from '../operation-node/selection-node.js';
+import { parseAliasedStringReference } from './reference-parser.js';
+import { isDynamicReferenceBuilder, } from '../dynamic/dynamic-reference-builder.js';
+import { parseAliasedExpression, } from './expression-parser.js';
+import { parseTable } from './table-parser.js';
+import { expressionBuilder, } from '../expression/expression-builder.js';
+export function parseSelectArg(selection) {
+    if (isFunction(selection)) {
+        return parseSelectArg(selection(expressionBuilder()));
+    }
+    else if (isReadonlyArray(selection)) {
+        return selection.map((it) => parseSelectExpression(it));
+    }
+    else {
+        return [parseSelectExpression(selection)];
+    }
+}
+function parseSelectExpression(selection) {
+    if (isString(selection)) {
+        return SelectionNode.create(parseAliasedStringReference(selection));
+    }
+    else if (isDynamicReferenceBuilder(selection)) {
+        return SelectionNode.create(selection.toOperationNode());
+    }
+    else {
+        return SelectionNode.create(parseAliasedExpression(selection));
+    }
+}
+export function parseSelectAll(table) {
+    if (!table) {
+        return [SelectionNode.createSelectAll()];
+    }
+    else if (Array.isArray(table)) {
+        return table.map(parseSelectAllArg);
+    }
+    else {
+        return [parseSelectAllArg(table)];
+    }
+}
+function parseSelectAllArg(table) {
+    if (isString(table)) {
+        return SelectionNode.createSelectAllFromTable(parseTable(table));
+    }
+    throw new Error(`invalid value selectAll expression: ${JSON.stringify(table)}`);
+}

package/dist/server/node_modules/kysely/dist/esm/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>[];

package/dist/server/node_modules/kysely/dist/esm/parser/set-operation-parser.js

@@ -0,0 +1,14 @@
+/// <reference types="./set-operation-parser.d.ts" />
+import { createExpressionBuilder, } from '../expression/expression-builder.js';
+import { SetOperationNode, } from '../operation-node/set-operation-node.js';
+import { isFunction, isReadonlyArray } from '../util/object-utils.js';
+import { parseExpression } from './expression-parser.js';
+export function parseSetOperations(operator, expression, all) {
+    if (isFunction(expression)) {
+        expression = expression(createExpressionBuilder());
+    }
+    if (!isReadonlyArray(expression)) {
+        expression = [expression];
+    }
+    return expression.map((expr) => SetOperationNode.create(operator, parseExpression(expr), all));
+}

package/dist/server/node_modules/kysely/dist/esm/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 {};

package/dist/server/node_modules/kysely/dist/esm/parser/table-parser.js

@@ -0,0 +1,49 @@
+/// <reference types="./table-parser.d.ts" />
+import { isReadonlyArray, isString } from '../util/object-utils.js';
+import { AliasNode } from '../operation-node/alias-node.js';
+import { TableNode } from '../operation-node/table-node.js';
+import { parseAliasedExpression, } from './expression-parser.js';
+import { IdentifierNode } from '../operation-node/identifier-node.js';
+import { isAliasedDynamicTableBuilder, } from '../dynamic/dynamic-table-builder.js';
+export function parseTableExpressionOrList(table) {
+    if (isReadonlyArray(table)) {
+        return table.map((it) => parseTableExpression(it));
+    }
+    else {
+        return [parseTableExpression(table)];
+    }
+}
+export function parseTableExpression(table) {
+    if (isString(table)) {
+        return parseAliasedTable(table);
+    }
+    else if (isAliasedDynamicTableBuilder(table)) {
+        return table.toOperationNode();
+    }
+    else {
+        return parseAliasedExpression(table);
+    }
+}
+export function parseAliasedTable(from) {
+    const ALIAS_SEPARATOR = ' as ';
+    if (from.includes(ALIAS_SEPARATOR)) {
+        const [table, alias] = from.split(ALIAS_SEPARATOR).map(trim);
+        return AliasNode.create(parseTable(table), IdentifierNode.create(alias));
+    }
+    else {
+        return parseTable(from);
+    }
+}
+export function parseTable(from) {
+    const SCHEMA_SEPARATOR = '.';
+    if (from.includes(SCHEMA_SEPARATOR)) {
+        const [schema, table] = from.split(SCHEMA_SEPARATOR).map(trim);
+        return TableNode.createWithSchema(schema, table);
+    }
+    else {
+        return TableNode.create(from);
+    }
+}
+function trim(str) {
+    return str.trim();
+}

package/dist/server/node_modules/kysely/dist/esm/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;

package/dist/server/node_modules/kysely/dist/esm/parser/top-parser.js

@@ -0,0 +1,17 @@
+/// <reference types="./top-parser.d.ts" />
+import { TopNode } from '../operation-node/top-node.js';
+import { isBigInt, isNumber, isUndefined } from '../util/object-utils.js';
+export function parseTop(expression, modifiers) {
+    if (!isNumber(expression) && !isBigInt(expression)) {
+        throw new Error(`Invalid top expression: ${expression}`);
+    }
+    if (!isUndefined(modifiers) && !isTopModifiers(modifiers)) {
+        throw new Error(`Invalid top modifiers: ${modifiers}`);
+    }
+    return TopNode.create(expression, modifiers);
+}
+function isTopModifiers(modifiers) {
+    return (modifiers === 'percent' ||
+        modifiers === 'with ties' ||
+        modifiers === 'percent with ties');
+}

package/dist/server/node_modules/kysely/dist/esm/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>
+]>;

package/dist/server/node_modules/kysely/dist/esm/parser/tuple-parser.js

@@ -0,0 +1,2 @@
+/// <reference types="./tuple-parser.d.ts" />
+export {};

package/dist/server/node_modules/kysely/dist/esm/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;

package/dist/server/node_modules/kysely/dist/esm/parser/unary-operation-parser.js

@@ -0,0 +1,13 @@
+/// <reference types="./unary-operation-parser.d.ts" />
+import { OperatorNode, } from '../operation-node/operator-node.js';
+import { UnaryOperationNode } from '../operation-node/unary-operation-node.js';
+import { parseReferenceExpression, } from './reference-parser.js';
+export function parseExists(operand) {
+    return parseUnaryOperation('exists', operand);
+}
+export function parseNotExists(operand) {
+    return parseUnaryOperation('not exists', operand);
+}
+export function parseUnaryOperation(operator, operand) {
+    return UnaryOperationNode.create(OperatorNode.create(operator), parseReferenceExpression(operand));
+}

package/dist/server/node_modules/kysely/dist/esm/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>;

package/dist/server/node_modules/kysely/dist/esm/parser/update-parser.js

@@ -0,0 +1,2 @@
+/// <reference types="./update-parser.d.ts" />
+export {};

package/dist/server/node_modules/kysely/dist/esm/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>;

package/dist/server/node_modules/kysely/dist/esm/parser/update-set-parser.js

@@ -0,0 +1,23 @@
+/// <reference types="./update-set-parser.d.ts" />
+import { ColumnNode } from '../operation-node/column-node.js';
+import { ColumnUpdateNode } from '../operation-node/column-update-node.js';
+import { expressionBuilder, } from '../expression/expression-builder.js';
+import { isFunction } from '../util/object-utils.js';
+import { parseValueExpression } from './value-parser.js';
+import { parseReferenceExpression, } from './reference-parser.js';
+export function parseUpdate(...args) {
+    if (args.length === 2) {
+        return [
+            ColumnUpdateNode.create(parseReferenceExpression(args[0]), parseValueExpression(args[1])),
+        ];
+    }
+    return parseUpdateObjectExpression(args[0]);
+}
+export function parseUpdateObjectExpression(update) {
+    const updateObj = isFunction(update) ? update(expressionBuilder()) : update;
+    return Object.entries(updateObj)
+        .filter(([_, value]) => value !== undefined)
+        .map(([key, value]) => {
+        return ColumnUpdateNode.create(ColumnNode.create(key), parseValueExpression(value));
+    });
+}

package/dist/server/node_modules/kysely/dist/esm/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;

package/dist/server/node_modules/kysely/dist/esm/parser/value-parser.js

@@ -0,0 +1,33 @@
+/// <reference types="./value-parser.d.ts" />
+import { PrimitiveValueListNode } from '../operation-node/primitive-value-list-node.js';
+import { ValueListNode } from '../operation-node/value-list-node.js';
+import { ValueNode } from '../operation-node/value-node.js';
+import { isBoolean, isNull, isNumber, isReadonlyArray, } from '../util/object-utils.js';
+import { parseExpression, isExpressionOrFactory, } from './expression-parser.js';
+export function parseValueExpressionOrList(arg) {
+    if (isReadonlyArray(arg)) {
+        return parseValueExpressionList(arg);
+    }
+    return parseValueExpression(arg);
+}
+export function parseValueExpression(exp) {
+    if (isExpressionOrFactory(exp)) {
+        return parseExpression(exp);
+    }
+    return ValueNode.create(exp);
+}
+export function isSafeImmediateValue(value) {
+    return isNumber(value) || isBoolean(value) || isNull(value);
+}
+export function parseSafeImmediateValue(value) {
+    if (!isSafeImmediateValue(value)) {
+        throw new Error(`unsafe immediate value ${JSON.stringify(value)}`);
+    }
+    return ValueNode.createImmediate(value);
+}
+function parseValueExpressionList(arg) {
+    if (arg.some(isExpressionOrFactory)) {
+        return ValueListNode.create(arg.map((it) => parseValueExpression(it)));
+    }
+    return PrimitiveValueListNode.create(arg);
+}

package/dist/server/node_modules/kysely/dist/esm/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 {};

package/dist/server/node_modules/kysely/dist/esm/parser/with-parser.js

@@ -0,0 +1,31 @@
+/// <reference types="./with-parser.d.ts" />
+import { CommonTableExpressionNameNode } from '../operation-node/common-table-expression-name-node.js';
+import { createQueryCreator } from './parse-utils.js';
+import { isFunction } from '../util/object-utils.js';
+import { CTEBuilder, } from '../query-builder/cte-builder.js';
+import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
+export function parseCommonTableExpression(nameOrBuilderCallback, expression) {
+    const expressionNode = expression(createQueryCreator()).toOperationNode();
+    if (isFunction(nameOrBuilderCallback)) {
+        return nameOrBuilderCallback(cteBuilderFactory(expressionNode)).toOperationNode();
+    }
+    return CommonTableExpressionNode.create(parseCommonTableExpressionName(nameOrBuilderCallback), expressionNode);
+}
+function cteBuilderFactory(expressionNode) {
+    return (name) => {
+        return new CTEBuilder({
+            node: 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 CommonTableExpressionNameNode.create(table, columns);
+    }
+    else {
+        return CommonTableExpressionNameNode.create(name);
+    }
+}

package/dist/server/node_modules/kysely/dist/esm/plugin/camel-case/camel-case-plugin.d.ts

@@ -0,0 +1,170 @@
+import type { QueryResult } from '../../driver/database-connection.js';
+import type { RootOperationNode } from '../../query-compiler/query-compiler.js';
+import type { UnknownRow } from '../../util/type-utils.js';
+import type { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } from '../kysely-plugin.js';
+export interface CamelCasePluginOptions {
+    /**
+     * If true, camelCase is transformed into upper case SNAKE_CASE.
+     * For example `fooBar => FOO_BAR` and `FOO_BAR => fooBar`
+     *
+     * Defaults to false.
+     */
+    upperCase?: boolean;
+    /**
+     * If true, an underscore is added before each digit when converting
+     * camelCase to snake_case. For example `foo12Bar => foo_12_bar` and
+     * `foo_12_bar => foo12Bar`
+     *
+     * Defaults to false.
+     */
+    underscoreBeforeDigits?: boolean;
+    /**
+     * If true, an underscore is added between consecutive upper case
+     * letters when converting from camelCase to snake_case. For example
+     * `fooBAR => foo_b_a_r` and `foo_b_a_r => fooBAR`.
+     *
+     * Defaults to false.
+     */
+    underscoreBetweenUppercaseLetters?: boolean;
+    /**
+     * If true, nested object's keys will not be converted to camel case.
+     *
+     * Defaults to false.
+     */
+    maintainNestedObjectKeys?: boolean;
+}
+/**
+ * A plugin that converts snake_case identifiers in the database into
+ * camelCase in the JavaScript side.
+ *
+ * For example let's assume we have a table called `person_table`
+ * with columns `first_name` and `last_name` in the database. When
+ * using `CamelCasePlugin` we would setup Kysely like this:
+ *
+ * ```ts
+ * import * as Sqlite from 'better-sqlite3'
+ * import { CamelCasePlugin, Kysely, SqliteDialect } from 'kysely'
+ *
+ * interface CamelCasedDatabase {
+ *   userMetadata: {
+ *     firstName: string
+ *     lastName: string
+ *   }
+ * }
+ *
+ * const db = new Kysely<CamelCasedDatabase>({
+ *   dialect: new SqliteDialect({
+ *     database: new Sqlite(':memory:'),
+ *   }),
+ *   plugins: [new CamelCasePlugin()],
+ * })
+ *
+ * const person = await db.selectFrom('userMetadata')
+ *   .where('firstName', '=', 'Arnold')
+ *   .select(['firstName', 'lastName'])
+ *   .executeTakeFirst()
+ *
+ * if (person) {
+ *   console.log(person.firstName)
+ * }
+ * ```
+ *
+ * The generated SQL (SQLite):
+ *
+ * ```sql
+ * select "first_name", "last_name" from "user_metadata" where "first_name" = ?
+ * ```
+ *
+ * As you can see from the example, __everything__ needs to be defined
+ * in camelCase in the TypeScript code: table names, columns, schemas,
+ * __everything__. When using the `CamelCasePlugin` Kysely works as if
+ * the database was defined in camelCase.
+ *
+ * There are various options you can give to the plugin to modify
+ * the way identifiers are converted. See {@link CamelCasePluginOptions}.
+ * If those options are not enough, you can override this plugin's
+ * `snakeCase` and `camelCase` methods to make the conversion exactly
+ * the way you like:
+ *
+ * ```ts
+ * class MyCamelCasePlugin extends CamelCasePlugin {
+ *   protected override snakeCase(str: string): string {
+ *     // ...
+ *
+ *     return str
+ *   }
+ *
+ *   protected override camelCase(str: string): string {
+ *     // ...
+ *
+ *     return str
+ *   }
+ * }
+ * ```
+ */
+export declare class CamelCasePlugin implements KyselyPlugin {
+    #private;
+    readonly opt: CamelCasePluginOptions;
+    constructor(opt?: CamelCasePluginOptions);
+    /**
+     * This is called for each query before it is executed. You can modify the query by
+     * transforming its {@link OperationNode} tree provided in {@link PluginTransformQueryArgs.node | args.node}
+     * and returning the transformed tree. You'd usually want to use an {@link OperationNodeTransformer}
+     * for this.
+     *
+     * If you need to pass some query-related data between this method and `transformResult` you
+     * can use a `WeakMap` with {@link PluginTransformQueryArgs.queryId | args.queryId} as the key:
+     *
+     * ```ts
+     * import type {
+     *   KyselyPlugin,
+     *   QueryResult,
+     *   RootOperationNode,
+     *   UnknownRow
+     * } from 'kysely'
+     *
+     * interface MyData {
+     *   // ...
+     * }
+     * const data = new WeakMap<any, MyData>()
+     *
+     * const plugin = {
+     *   transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
+     *     const something: MyData = {}
+     *
+     *     // ...
+     *
+     *     data.set(args.queryId, something)
+     *
+     *     // ...
+     *
+     *     return args.node
+     *   },
+     *
+     *   async transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>> {
+     *     // ...
+     *
+     *     const something = data.get(args.queryId)
+     *
+     *     // ...
+     *
+     *     return args.result
+     *   }
+     * } satisfies KyselyPlugin
+     * ```
+     *
+     * You should use a `WeakMap` instead of a `Map` or some other strong references because `transformQuery`
+     * is not always matched by a call to `transformResult` which would leave orphaned items in the map
+     * and cause a memory leak.
+     */
+    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    /**
+     * This method is called for each query after it has been executed. The result
+     * of the query can be accessed through {@link PluginTransformResultArgs.result | args.result}.
+     * You can modify the result and return the modifier result.
+     */
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
+    protected mapRow(row: UnknownRow): UnknownRow;
+    protected snakeCase(str: string): string;
+    protected camelCase(str: string): string;
+}