kysely 0.28.17 → 0.29.0

package/dist/esm/parser/select-parser.d.ts

@@ -1,36 +0,0 @@
-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/esm/parser/set-operation-parser.d.ts

@@ -1,5 +0,0 @@
-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/esm/parser/table-parser.d.ts

@@ -1,24 +0,0 @@
-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/esm/parser/top-parser.d.ts

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

package/dist/esm/parser/tuple-parser.d.ts

@@ -1,47 +0,0 @@
-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/esm/parser/unary-operation-parser.d.ts

@@ -1,8 +0,0 @@
-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/esm/parser/unary-operation-parser.js

@@ -1,13 +0,0 @@
-/// <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/esm/parser/update-parser.d.ts

@@ -1,9 +0,0 @@
-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/esm/parser/update-set-parser.d.ts

@@ -1,16 +0,0 @@
-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/esm/parser/value-parser.d.ts

@@ -1,13 +0,0 @@
-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/esm/parser/with-parser.d.ts

@@ -1,45 +0,0 @@
-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/esm/parser/with-parser.js

@@ -1,31 +0,0 @@
-/// <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/esm/plugin/camel-case/camel-case-plugin.d.ts

@@ -1,170 +0,0 @@
-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;
-}

package/dist/esm/plugin/camel-case/camel-case-transformer.d.ts

@@ -1,9 +0,0 @@
-import type { IdentifierNode } from '../../operation-node/identifier-node.js';
-import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
-import type { QueryId } from '../../util/query-id.js';
-import type { StringMapper } from './camel-case.js';
-export declare class SnakeCaseTransformer extends OperationNodeTransformer {
-    #private;
-    constructor(snakeCase: StringMapper);
-    protected transformIdentifier(node: IdentifierNode, queryId: QueryId): IdentifierNode;
-}

package/dist/esm/plugin/camel-case/camel-case.d.ts

@@ -1,15 +0,0 @@
-export type StringMapper = (str: string) => string;
-/**
- * Creates a function that transforms camel case strings to snake case.
- */
-export declare function createSnakeCaseMapper({ upperCase, underscoreBeforeDigits, underscoreBetweenUppercaseLetters, }?: {
-    upperCase?: boolean | undefined;
-    underscoreBeforeDigits?: boolean | undefined;
-    underscoreBetweenUppercaseLetters?: boolean | undefined;
-}): StringMapper;
-/**
- * Creates a function that transforms snake case strings to camel case.
- */
-export declare function createCamelCaseMapper({ upperCase, }?: {
-    upperCase?: boolean | undefined;
-}): StringMapper;

package/dist/esm/plugin/deduplicate-joins/deduplicate-joins-plugin.d.ts

@@ -1,70 +0,0 @@
-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';
-/**
- * Plugin that removes duplicate joins from queries.
- *
- * See [this recipe](https://github.com/kysely-org/kysely/blob/master/site/docs/recipes/0008-deduplicate-joins.md)
- */
-export declare class DeduplicateJoinsPlugin implements KyselyPlugin {
-    #private;
-    /**
-     * 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>>;
-}

package/dist/esm/plugin/deduplicate-joins/deduplicate-joins-transformer.d.ts

@@ -1,11 +0,0 @@
-import type { DeleteQueryNode } from '../../operation-node/delete-query-node.js';
-import { OperationNodeTransformer } from '../../operation-node/operation-node-transformer.js';
-import type { SelectQueryNode } from '../../operation-node/select-query-node.js';
-import type { UpdateQueryNode } from '../../operation-node/update-query-node.js';
-import type { QueryId } from '../../util/query-id.js';
-export declare class DeduplicateJoinsTransformer extends OperationNodeTransformer {
-    #private;
-    protected transformSelectQuery(node: SelectQueryNode, queryId: QueryId): SelectQueryNode;
-    protected transformUpdateQuery(node: UpdateQueryNode, queryId: QueryId): UpdateQueryNode;
-    protected transformDeleteQuery(node: DeleteQueryNode, queryId: QueryId): DeleteQueryNode;
-}