kysely 0.23.3 → 0.23.5

package/dist/esm/dialect/sqlite/sqlite-adapter.d.ts

@@ -18,12 +18,38 @@ export declare class SqliteAdapter implements DialectAdapterBase {
      * Most dialects have explicit locks that can be used, like advisory locks
      * in PostgreSQL and the get_lock function in MySQL.
      *
-     * If the dialect doesn't have explicit locks the {@link MIGRATION_LOCK_TABLE}
-     * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
-     * has two columns `id` and `is_locked` and there's only one row in the
-     * table whose id is {@link MIGRATION_LOCK_ID}. `is_locked` is an integer.
-     * Kysely takes care of creating the lock table and inserting the one single
-     * row to it before this method is executed.
+     * If the dialect doesn't have explicit locks the {@link MigrationLockOptions.lockTable}
+     * created by Kysely can be used instead. You can access it through the `options` object.
+     * The lock table has two columns `id` and `is_locked` and there's only one row in the table
+     * whose id is {@link MigrationLockOptions.lockRowId}. `is_locked` is an integer. Kysely
+     * takes care of creating the lock table and inserting the one single row to it before this
+     * method is executed. If the dialect supports schemas and the user has specified a custom
+     * schema in their migration settings, the options object also contains the schema name in
+     * {@link MigrationLockOptions.lockTableSchema}.
+     *
+     * Here's an example of how you might implement this method for a dialect that doesn't
+     * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
+     *
+     * ```ts
+     * {
+     *   async acquireMigrationLock(db, options): Promise<void> {
+     *     const queryDb = options.lockTableSchema
+     *       ? db.withSchema(options.lockTableSchema)
+     *       : db
+     *
+     *     // Since our imaginary dialect supports transactional DDL and has
+     *     // row locks, we can simply take a row lock here and it will guarantee
+     *     // all subsequent calls to this method from other transactions will
+     *     // wait until this transaction finishes.
+     *     await queryDb
+     *       .selectFrom(options.lockTable)
+     *       .selectAll()
+     *       .where('id', '=', options.lockRowId)
+     *       .forUpdate()
+     *       .execute()
+     *   }
+     * }
+     * ```
      *
      * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
      * is a transaction inside which the migrations will be executed. Otherwise

package/dist/esm/dialect/sqlite/sqlite-introspector.d.ts

@@ -8,7 +8,7 @@ export declare class SqliteIntrospector implements DatabaseIntrospector {
      */
     getSchemas(): Promise<SchemaMetadata[]>;
     /**
-     * Get table metadata.
+     * Get tables and views metadata.
      */
     getTables(options?: DatabaseMetadataOptions): Promise<TableMetadata[]>;
     /**

package/dist/esm/dialect/sqlite/sqlite-introspector.js

@@ -13,11 +13,11 @@ export class SqliteIntrospector {
     async getTables(options = { withInternalKyselyTables: false }) {
         let query = this.#db
             .selectFrom('sqlite_schema')
-            .where('type', '=', 'table')
+            .where('type', 'in', ['table', 'view'])
             .where('name', 'not like', 'sqlite_%')
             .select('name')
             .orderBy('name')
-            .castTo();
+            .$castTo();
         if (!options.withInternalKyselyTables) {
             query = query
                 .where('name', '!=', DEFAULT_MIGRATION_TABLE)
@@ -34,14 +34,14 @@ export class SqliteIntrospector {
     async #getTableMetadata(table) {
         const db = this.#db;
         // Get the SQL that was used to create the table.
-        const createSql = await db
+        const tableDefinition = await db
             .selectFrom('sqlite_master')
             .where('name', '=', table)
-            .select('sql')
-            .castTo()
-            .execute();
+            .select(['sql', 'type'])
+            .$castTo()
+            .executeTakeFirstOrThrow();
         // Try to find the name of the column that has `autoincrement` 🤦
-        const autoIncrementCol = createSql[0]?.sql
+        const autoIncrementCol = tableDefinition.sql
             ?.split(/[\(\),]/)
             ?.find((it) => it.toLowerCase().includes('autoincrement'))
             ?.trimStart()
@@ -54,6 +54,7 @@ export class SqliteIntrospector {
             .execute();
         return {
             name: table,
+            isView: tableDefinition.type === 'view',
             columns: columns.map((col) => ({
                 name: col.name,
                 dataType: col.type,

package/dist/esm/index.d.ts

@@ -159,6 +159,7 @@ export * from './operation-node/partition-by-item-node.js';
 export * from './operation-node/set-operation-node.js';
 export * from './operation-node/binary-operation-node.js';
 export * from './operation-node/unary-operation-node.js';
+export * from './operation-node/using-node.js';
 export * from './util/column-type.js';
 export * from './util/compilable.js';
 export * from './util/explainable.js';

package/dist/esm/index.js

@@ -160,6 +160,7 @@ export * from './operation-node/partition-by-item-node.js';
 export * from './operation-node/set-operation-node.js';
 export * from './operation-node/binary-operation-node.js';
 export * from './operation-node/unary-operation-node.js';
+export * from './operation-node/using-node.js';
 export * from './util/column-type.js';
 export * from './util/compilable.js';
 export * from './util/explainable.js';

package/dist/esm/migration/migrator.d.ts

@@ -24,12 +24,17 @@ export interface Migration {
  * other way.
  *
  * ```ts
+ * import { promises as fs } from 'fs'
+ * import path from 'path'
+ *
  * const migrator = new Migrator({
  *   db,
- *   provider: new FileMigrationProvider(
+ *   provider: new FileMigrationProvider({
+ *     fs,
+ *     path,
  *     // Path to the folder that contains all your migrations.
- *     'some/path/to/migrations'
- *   )
+ *     migrationFolder: 'some/path/to/migrations'
+ *   })
  * })
  * ```
  */

package/dist/esm/migration/migrator.js

@@ -17,12 +17,17 @@ export const NO_MIGRATIONS = freeze({ __noMigrations__: true });
  * other way.
  *
  * ```ts
+ * import { promises as fs } from 'fs'
+ * import path from 'path'
+ *
  * const migrator = new Migrator({
  *   db,
- *   provider: new FileMigrationProvider(
+ *   provider: new FileMigrationProvider({
+ *     fs,
+ *     path,
  *     // Path to the folder that contains all your migrations.
- *     'some/path/to/migrations'
- *   )
+ *     migrationFolder: 'some/path/to/migrations'
+ *   })
  * })
  * ```
  */
@@ -316,9 +321,14 @@ export class Migrator {
     }
     async #runMigrations(getTargetMigrationIndex) {
         const adapter = this.#props.db.getExecutor().adapter;
+        const lockOptions = freeze({
+            lockTable: this.#props.migrationLockTableName ?? DEFAULT_MIGRATION_LOCK_TABLE,
+            lockRowId: MIGRATION_LOCK_ID,
+            lockTableSchema: this.#props.migrationTableSchema,
+        });
         const run = async (db) => {
             try {
-                await adapter.acquireMigrationLock(db);
+                await adapter.acquireMigrationLock(db, lockOptions);
                 const state = await this.#getState(db);
                 if (state.migrations.length === 0) {
                     return { results: [] };
@@ -336,7 +346,7 @@ export class Migrator {
                 return { results: [] };
             }
             finally {
-                await adapter.releaseMigrationLock(db);
+                await adapter.releaseMigrationLock(db, lockOptions);
             }
         };
         if (adapter.supportsTransactionalDdl) {

package/dist/esm/operation-node/aggregate-function-node.d.ts

@@ -1,12 +1,13 @@
 import { OperationNode } from './operation-node.js';
 import { OverNode } from './over-node.js';
+import { SelectAllNode } from './select-all-node.js';
 import { SimpleReferenceExpressionNode } from './simple-reference-expression-node.js';
 import { WhereNode } from './where-node.js';
 declare type AggregateFunction = 'avg' | 'count' | 'max' | 'min' | 'sum';
 export interface AggregateFunctionNode extends OperationNode {
     readonly kind: 'AggregateFunctionNode';
     readonly func: AggregateFunction;
-    readonly column: SimpleReferenceExpressionNode;
+    readonly aggregated: SimpleReferenceExpressionNode | SelectAllNode;
     readonly distinct?: boolean;
     readonly filter?: WhereNode;
     readonly over?: OverNode;
@@ -16,7 +17,7 @@ export interface AggregateFunctionNode extends OperationNode {
  */
 export declare const AggregateFunctionNode: Readonly<{
     is(node: OperationNode): node is AggregateFunctionNode;
-    create(aggregateFunction: AggregateFunction, column: SimpleReferenceExpressionNode): AggregateFunctionNode;
+    create(aggregateFunction: AggregateFunction, aggregated: SimpleReferenceExpressionNode | SelectAllNode): AggregateFunctionNode;
     cloneWithDistinct(aggregateFunctionNode: AggregateFunctionNode): AggregateFunctionNode;
     cloneWithFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): AggregateFunctionNode;
     cloneWithOrFilter(aggregateFunctionNode: AggregateFunctionNode, filter: OperationNode): AggregateFunctionNode;

package/dist/esm/operation-node/aggregate-function-node.js

@@ -8,11 +8,11 @@ export const AggregateFunctionNode = freeze({
     is(node) {
         return node.kind === 'AggregateFunctionNode';
     },
-    create(aggregateFunction, column) {
+    create(aggregateFunction, aggregated) {
         return freeze({
             kind: 'AggregateFunctionNode',
             func: aggregateFunction,
-            column,
+            aggregated,
         });
     },
     cloneWithDistinct(aggregateFunctionNode) {

package/dist/esm/operation-node/create-index-node.d.ts

@@ -11,6 +11,7 @@ export interface CreateIndexNode extends OperationNode {
     readonly expression?: OperationNode;
     readonly unique?: boolean;
     readonly using?: RawNode;
+    readonly ifNotExists?: boolean;
 }
 /**
  * @internal

package/dist/esm/operation-node/delete-query-node.d.ts

@@ -8,9 +8,11 @@ import { LimitNode } from './limit-node.js';
 import { OrderByNode } from './order-by-node.js';
 import { OrderByItemNode } from './order-by-item-node.js';
 import { ExplainNode } from './explain-node.js';
+import { UsingNode } from './using-node.js';
 export interface DeleteQueryNode extends OperationNode {
     readonly kind: 'DeleteQueryNode';
     readonly from: FromNode;
+    readonly using?: UsingNode;
     readonly joins?: ReadonlyArray<JoinNode>;
     readonly where?: WhereNode;
     readonly returning?: ReturningNode;
@@ -24,8 +26,9 @@ export interface DeleteQueryNode extends OperationNode {
  */
 export declare const DeleteQueryNode: Readonly<{
     is(node: OperationNode): node is DeleteQueryNode;
-    create(fromItem: OperationNode, withNode?: WithNode): DeleteQueryNode;
+    create(fromItems: OperationNode[], withNode?: WithNode): DeleteQueryNode;
     cloneWithOrderByItem(deleteNode: DeleteQueryNode, item: OrderByItemNode): DeleteQueryNode;
     cloneWithLimit(deleteNode: DeleteQueryNode, limit: LimitNode): DeleteQueryNode;
     cloneWithExplain(deleteNode: DeleteQueryNode, explain: ExplainNode): DeleteQueryNode;
+    cloneWithUsing(deleteNode: DeleteQueryNode, tables: OperationNode[]): DeleteQueryNode;
 }>;

package/dist/esm/operation-node/delete-query-node.js

@@ -2,6 +2,7 @@
 import { freeze } from '../util/object-utils.js';
 import { FromNode } from './from-node.js';
 import { OrderByNode } from './order-by-node.js';
+import { UsingNode } from './using-node.js';
 /**
  * @internal
  */
@@ -9,10 +10,10 @@ export const DeleteQueryNode = freeze({
     is(node) {
         return node.kind === 'DeleteQueryNode';
     },
-    create(fromItem, withNode) {
+    create(fromItems, withNode) {
         return freeze({
             kind: 'DeleteQueryNode',
-            from: FromNode.create([fromItem]),
+            from: FromNode.create(fromItems),
             ...(withNode && { with: withNode }),
         });
     },
@@ -36,4 +37,12 @@ export const DeleteQueryNode = freeze({
             explain,
         });
     },
+    cloneWithUsing(deleteNode, tables) {
+        return freeze({
+            ...deleteNode,
+            using: deleteNode.using !== undefined
+                ? UsingNode.cloneWithTables(deleteNode.using, tables)
+                : UsingNode.create(tables),
+        });
+    },
 });

package/dist/esm/operation-node/operation-node-transformer.d.ts

@@ -76,6 +76,7 @@ import { PartitionByItemNode } from './partition-by-item-node.js';
 import { SetOperationNode } from './set-operation-node.js';
 import { BinaryOperationNode } from './binary-operation-node.js';
 import { UnaryOperationNode } from './unary-operation-node.js';
+import { UsingNode } from './using-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -181,6 +182,7 @@ export declare class OperationNodeTransformer {
     protected transformPartitionByItem(node: PartitionByItemNode): PartitionByItemNode;
     protected transformBinaryOperation(node: BinaryOperationNode): BinaryOperationNode;
     protected transformUnaryOperation(node: UnaryOperationNode): UnaryOperationNode;
+    protected transformUsing(node: UsingNode): UsingNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;

package/dist/esm/operation-node/operation-node-transformer.js

@@ -110,6 +110,7 @@ export class OperationNodeTransformer {
         SetOperationNode: this.transformSetOperation.bind(this),
         BinaryOperationNode: this.transformBinaryOperation.bind(this),
         UnaryOperationNode: this.transformUnaryOperation.bind(this),
+        UsingNode: this.transformUsing.bind(this),
     });
     transformNode(node) {
         if (!node) {
@@ -259,6 +260,7 @@ export class OperationNodeTransformer {
         return requireAllProps({
             kind: 'DeleteQueryNode',
             from: this.transformNode(node.from),
+            using: this.transformNode(node.using),
             joins: this.transformNodeList(node.joins),
             where: this.transformNode(node.where),
             returning: this.transformNode(node.returning),
@@ -402,6 +404,7 @@ export class OperationNodeTransformer {
             expression: this.transformNode(node.expression),
             unique: node.unique,
             using: this.transformNode(node.using),
+            ifNotExists: node.ifNotExists,
         });
     }
     transformList(node) {
@@ -646,7 +649,7 @@ export class OperationNodeTransformer {
     transformAggregateFunction(node) {
         return requireAllProps({
             kind: 'AggregateFunctionNode',
-            column: this.transformNode(node.column),
+            aggregated: this.transformNode(node.aggregated),
             distinct: node.distinct,
             filter: this.transformNode(node.filter),
             func: node.func,
@@ -687,6 +690,12 @@ export class OperationNodeTransformer {
             operand: this.transformNode(node.operand),
         });
     }
+    transformUsing(node) {
+        return requireAllProps({
+            kind: 'UsingNode',
+            tables: this.transformNodeList(node.tables),
+        });
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;

package/dist/esm/operation-node/operation-node-visitor.d.ts

@@ -76,6 +76,7 @@ import { PartitionByItemNode } from './partition-by-item-node.js';
 import { SetOperationNode } from './set-operation-node.js';
 import { BinaryOperationNode } from './binary-operation-node.js';
 import { UnaryOperationNode } from './unary-operation-node.js';
+import { UsingNode } from './using-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -158,4 +159,5 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitSetOperation(node: SetOperationNode): void;
     protected abstract visitBinaryOperation(node: BinaryOperationNode): void;
     protected abstract visitUnaryOperation(node: UnaryOperationNode): void;
+    protected abstract visitUsing(node: UsingNode): void;
 }

package/dist/esm/operation-node/operation-node-visitor.js

@@ -83,6 +83,7 @@ export class OperationNodeVisitor {
         SetOperationNode: this.visitSetOperation.bind(this),
         BinaryOperationNode: this.visitBinaryOperation.bind(this),
         UnaryOperationNode: this.visitUnaryOperation.bind(this),
+        UsingNode: this.visitUsing.bind(this),
     });
     visitNode = (node) => {
         this.nodeStack.push(node);

package/dist/esm/operation-node/operation-node.d.ts

@@ -1,4 +1,4 @@
-export declare type OperationNodeKind = 'IdentifierNode' | 'SchemableIdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode' | 'ExplainNode' | 'DefaultInsertValueNode' | 'AggregateFunctionNode' | 'OverNode' | 'PartitionByNode' | 'PartitionByItemNode' | 'SetOperationNode' | 'BinaryOperationNode' | 'UnaryOperationNode';
+export declare type OperationNodeKind = 'IdentifierNode' | 'SchemableIdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode' | 'ExplainNode' | 'DefaultInsertValueNode' | 'AggregateFunctionNode' | 'OverNode' | 'PartitionByNode' | 'PartitionByItemNode' | 'SetOperationNode' | 'BinaryOperationNode' | 'UnaryOperationNode' | 'UsingNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

package/dist/esm/operation-node/operator-node.d.ts

@@ -1,5 +1,5 @@
 import { OperationNode } from './operation-node.js';
-export declare const COMPARISON_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "ilike", "not ilike", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "&&", "||", "@@", "@@@", "!!", "<->"];
+export declare const COMPARISON_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "&&", "||", "@@", "@@@", "!!", "<->"];
 export declare const UNARY_FILTER_OPERATORS: readonly ["exists", "not exists"];
 export declare type ComparisonOperator = typeof COMPARISON_OPERATORS[number];
 export declare type UnaryFilterOperator = typeof UNARY_FILTER_OPERATORS[number];

package/dist/esm/operation-node/operator-node.js

@@ -15,6 +15,7 @@ export const COMPARISON_OPERATORS = [
     'is not',
     'like',
     'not like',
+    'match',
     'ilike',
     'not ilike',
     '@>',

package/dist/esm/operation-node/using-node.d.ts

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

package/dist/esm/operation-node/using-node.js

@@ -0,0 +1,22 @@
+/// <reference types="./using-node.d.ts" />
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const UsingNode = freeze({
+    is(node) {
+        return node.kind === 'UsingNode';
+    },
+    create(tables) {
+        return freeze({
+            kind: 'UsingNode',
+            tables: freeze(tables),
+        });
+    },
+    cloneWithTables(using, tables) {
+        return freeze({
+            ...using,
+            tables: freeze([...using.tables, ...tables]),
+        });
+    },
+});

package/dist/esm/parser/expression-parser.js

@@ -1,5 +1,5 @@
 /// <reference types="./expression-parser.d.ts" />
-import { isExpression, } from '../expression/expression.js';
+import { isAliasedExpression, isExpression, } from '../expression/expression.js';
 import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
 import { isFunction } from '../util/object-utils.js';
 import { createExpressionBuilder } from './parse-utils.js';
@@ -22,5 +22,5 @@ export function parseAliasedExpression(exp) {
     throw new Error(`invalid aliased expression: ${JSON.stringify(exp)}`);
 }
 export function isExpressionOrFactory(obj) {
-    return isExpression(obj) || isFunction(obj);
+    return isExpression(obj) || isAliasedExpression(obj) || isFunction(obj);
 }

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

@@ -6,6 +6,7 @@ import { AliasedExpression } from '../expression/expression.js';
 export declare type TableExpression<DB, TB extends keyof DB> = TableReference<DB> | AliasedExpressionOrFactory<DB, TB>;
 export declare type TableExpressionOrList<DB, TB extends keyof DB> = TableExpression<DB, TB> | ReadonlyArray<TableExpression<DB, TB>>;
 export declare type TableReference<DB> = AnyAliasedTable<DB> | AnyTable<DB> | AliasedExpression<any, any>;
+export declare type TableReferenceOrList<DB> = TableReference<DB> | ReadonlyArray<TableReference<DB>>;
 export declare type From<DB, TE> = {
     [C in keyof DB | ExtractAliasFromTableExpression<DB, TE>]: C extends ExtractAliasFromTableExpression<DB, TE> ? ExtractRowTypeFromTableExpression<DB, TE, C> : C extends keyof DB ? DB[C] : never;
 };

package/dist/esm/parser/update-set-parser.d.ts

@@ -1,7 +1,7 @@
 import { ColumnUpdateNode } from '../operation-node/column-update-node.js';
 import { UpdateKeys, UpdateType } from '../util/column-type.js';
 import { ValueExpression } from './value-parser.js';
-export declare type UpdateObject<DB, TB extends keyof DB, UT extends keyof DB> = {
+export declare type UpdateObject<DB, TB extends keyof DB, UT extends keyof DB = TB> = {
     [C in UpdateKeys<DB[UT]>]?: ValueExpression<DB, TB, UpdateType<DB[UT][C]>> | undefined;
 };
 export declare function parseUpdateObject(update: UpdateObject<any, any, any>): ReadonlyArray<ColumnUpdateNode>;

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

@@ -26,6 +26,12 @@ export interface CamelCasePluginOptions {
      * 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
@@ -93,6 +99,7 @@ export interface CamelCasePluginOptions {
  */
 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

package/dist/esm/plugin/camel-case/camel-case-plugin.js

@@ -67,10 +67,12 @@ import { createCamelCaseMapper, createSnakeCaseMapper, } from './camel-case.js';
  * ```
  */
 export class CamelCasePlugin {
+    opt;
     #camelCase;
     #snakeCase;
     #snakeCaseTransformer;
     constructor(opt = {}) {
+        this.opt = opt;
         this.#camelCase = createCamelCaseMapper(opt);
         this.#snakeCase = createSnakeCaseMapper(opt);
         this.#snakeCaseTransformer = new SnakeCaseTransformer(this.snakeCase.bind(this));
@@ -91,9 +93,9 @@ export class CamelCasePlugin {
         return Object.keys(row).reduce((obj, key) => {
             let value = row[key];
             if (Array.isArray(value)) {
-                value = value.map((it) => (canMap(it) ? this.mapRow(it) : it));
+                value = value.map((it) => (canMap(it, this.opt) ? this.mapRow(it) : it));
             }
-            else if (canMap(value)) {
+            else if (canMap(value, this.opt)) {
                 value = this.mapRow(value);
             }
             obj[this.camelCase(key)] = value;
@@ -107,6 +109,10 @@ export class CamelCasePlugin {
         return this.#camelCase(str);
     }
 }
-function canMap(obj) {
-    return (isObject(obj) && !isDate(obj) && !isBuffer(obj) && !isArrayBufferOrView(obj));
+function canMap(obj, opt) {
+    return (isObject(obj) &&
+        !isDate(obj) &&
+        !isBuffer(obj) &&
+        !isArrayBufferOrView(obj) &&
+        !opt?.maintainNestedObjectKeys);
 }