kysely 0.28.17 → 0.28.18

package/dist/esm/kysely.js

@@ -24,7 +24,8 @@ Symbol.asyncDispose ??= Symbol('Symbol.asyncDispose');
  * The main Kysely class.
  *
  * You should create one instance of `Kysely` per database using the {@link Kysely}
- * constructor. Each `Kysely` instance maintains its own connection pool.
+ * constructor. The dialect manages database connections and may use a shared
+ * pool or database instance.
  *
  * ### Examples
  *
@@ -433,7 +434,16 @@ export class Kysely extends QueryCreator {
     /**
      * Releases all resources and disconnects from the database.
      *
-     * You need to call this when you are done using the `Kysely` instance.
+     * Call this when you are done using the `Kysely` instance and Kysely is
+     * responsible for closing its connections, pool, or database instance.
+     *
+     * If the pool or database instance is shared with other consumers or its
+     * lifecycle is managed elsewhere, skip this call. Let the application close it
+     * once all consumers, including Kysely, have finished. No separate cleanup of
+     * the `Kysely` instance is needed.
+     *
+     * The driver is initialized lazily. If initialization hasn't started, this
+     * method does nothing.
      */
     async destroy() {
         await this.#props.driver.destroy();
@@ -606,10 +616,17 @@ export class ControlledTransactionBuilder {
         const settings = { isolationLevel, accessMode };
         validateTransactionSettings(settings);
         const connection = await provideControlledConnection(this.#props.executor);
-        await this.#props.driver.beginTransaction(connection.connection, settings);
+        try {
+            await this.#props.driver.beginTransaction(connection.connection, settings);
+        }
+        catch (error) {
+            connection.release();
+            throw error;
+        }
         return new ControlledTransaction({
             ...props,
             connection,
+            state: { isCommitted: false, isRolledBack: false },
             executor: this.#props.executor.withConnectionProvider(new SingleConnectionProvider(connection.connection)),
         });
     }
@@ -617,29 +634,35 @@ export class ControlledTransactionBuilder {
 export class ControlledTransaction extends Transaction {
     #props;
     #compileQuery;
-    #state;
     constructor(props) {
-        const state = { isCommitted: false, isRolledBack: false };
-        props = {
+        const transactionState = props.state ?? {
+            isCommitted: false,
+            isRolledBack: false,
+        };
+        const controlledProps = {
             ...props,
-            executor: new NotCommittedOrRolledBackAssertingExecutor(props.executor, state),
+            state: transactionState,
+            executor: new NotCommittedOrRolledBackAssertingExecutor(props.executor, transactionState),
         };
-        const { connection, ...transactionProps } = props;
+        const { connection, state, ...transactionProps } = controlledProps;
         super(transactionProps);
-        this.#props = freeze(props);
-        this.#state = state;
+        this.#props = freeze(controlledProps);
         const queryId = createQueryId();
-        this.#compileQuery = (node) => props.executor.compileQuery(node, queryId);
+        this.#compileQuery = (node) => controlledProps.executor.compileQuery(node, queryId);
     }
     get isCommitted() {
-        return this.#state.isCommitted;
+        return this.#props.state.isCommitted;
     }
     get isRolledBack() {
-        return this.#state.isRolledBack;
+        return this.#props.state.isRolledBack;
     }
     /**
      * Commits the transaction.
      *
+     * Waits for ongoing queries to finish. Streams must be exhausted or closed
+     * before awaiting this command. When consuming a stream with `for await`,
+     * exit the loop before committing.
+     *
      * See {@link rollback}.
      *
      * ### Examples
@@ -662,16 +685,24 @@ export class ControlledTransaction extends Transaction {
      * ```
      */
     commit() {
-        assertNotCommittedOrRolledBack(this.#state);
         return new Command(async () => {
-            await this.#props.driver.commitTransaction(this.#props.connection.connection);
-            this.#state.isCommitted = true;
-            this.#props.connection.release();
+            await this.#props.executor.provideConnection(async (connection) => {
+                await this.#props.driver.commitTransaction(connection);
+                this.#props.state.isCommitted = true;
+                this.#props.connection.release();
+            });
         });
     }
     /**
      * Rolls back the transaction.
      *
+     * The connection is released even if the rollback fails, so the transaction
+     * cannot be used afterwards in either case.
+     *
+     * Waits for ongoing queries to finish. Streams must be exhausted or closed
+     * before awaiting this command. When consuming a stream with `for await`,
+     * exit the loop before rolling back.
+     *
      * See {@link commit} and {@link rollbackToSavepoint}.
      *
      * ### Examples
@@ -694,16 +725,26 @@ export class ControlledTransaction extends Transaction {
      * ```
      */
     rollback() {
-        assertNotCommittedOrRolledBack(this.#state);
         return new Command(async () => {
-            await this.#props.driver.rollbackTransaction(this.#props.connection.connection);
-            this.#state.isRolledBack = true;
-            this.#props.connection.release();
+            await this.#props.executor.provideConnection(async (connection) => {
+                // A failed rollback can't be meaningfully retried (e.g. dead connection).
+                try {
+                    await this.#props.driver.rollbackTransaction(connection);
+                }
+                finally {
+                    this.#props.state.isRolledBack = true;
+                    this.#props.connection.release();
+                }
+            });
         });
     }
     /**
      * Creates a savepoint with a given name.
      *
+     * Waits for ongoing queries to finish. Streams must be exhausted or closed
+     * before awaiting this command. When consuming a stream with `for await`,
+     * exit the loop before creating a savepoint.
+     *
      * See {@link rollbackToSavepoint} and {@link releaseSavepoint}.
      *
      * For a type-safe experience, you should use the returned instance from now on.
@@ -731,15 +772,20 @@ export class ControlledTransaction extends Transaction {
      * ```
      */
     savepoint(savepointName) {
-        assertNotCommittedOrRolledBack(this.#state);
         return new Command(async () => {
-            await this.#props.driver.savepoint?.(this.#props.connection.connection, savepointName, this.#compileQuery);
+            await this.#props.executor.provideConnection(async (connection) => {
+                await this.#props.driver.savepoint?.(connection, savepointName, this.#compileQuery);
+            });
             return new ControlledTransaction({ ...this.#props });
         });
     }
     /**
      * Rolls back to a savepoint with a given name.
      *
+     * Waits for ongoing queries to finish. Streams must be exhausted or closed
+     * before awaiting this command. When consuming a stream with `for await`,
+     * exit the loop before rolling back to a savepoint.
+     *
      * See {@link savepoint} and {@link releaseSavepoint}.
      *
      * You must use the same instance returned by {@link savepoint}, or
@@ -768,15 +814,20 @@ export class ControlledTransaction extends Transaction {
      * ```
      */
     rollbackToSavepoint(savepointName) {
-        assertNotCommittedOrRolledBack(this.#state);
         return new Command(async () => {
-            await this.#props.driver.rollbackToSavepoint?.(this.#props.connection.connection, savepointName, this.#compileQuery);
+            await this.#props.executor.provideConnection(async (connection) => {
+                await this.#props.driver.rollbackToSavepoint?.(connection, savepointName, this.#compileQuery);
+            });
             return new ControlledTransaction({ ...this.#props });
         });
     }
     /**
      * Releases a savepoint with a given name.
      *
+     * Waits for ongoing queries to finish. Streams must be exhausted or closed
+     * before awaiting this command. When consuming a stream with `for await`,
+     * exit the loop before releasing a savepoint.
+     *
      * See {@link savepoint} and {@link rollbackToSavepoint}.
      *
      * You must use the same instance returned by {@link savepoint}, or
@@ -810,9 +861,10 @@ export class ControlledTransaction extends Transaction {
      * ```
      */
     releaseSavepoint(savepointName) {
-        assertNotCommittedOrRolledBack(this.#state);
         return new Command(async () => {
-            await this.#props.driver.releaseSavepoint?.(this.#props.connection.connection, savepointName, this.#compileQuery);
+            await this.#props.executor.provideConnection(async (connection) => {
+                await this.#props.driver.releaseSavepoint?.(connection, savepointName, this.#compileQuery);
+            });
             return new ControlledTransaction({ ...this.#props });
         });
     }
@@ -889,15 +941,23 @@ class NotCommittedOrRolledBackAssertingExecutor {
         return this.#executor.compileQuery(node, queryId);
     }
     provideConnection(consumer) {
-        return this.#executor.provideConnection(consumer);
+        assertNotCommittedOrRolledBack(this.#state);
+        return this.#executor.provideConnection(async (connection) => {
+            assertNotCommittedOrRolledBack(this.#state);
+            return await consumer(connection);
+        });
     }
     executeQuery(compiledQuery) {
         assertNotCommittedOrRolledBack(this.#state);
-        return this.#executor.executeQuery(compiledQuery);
+        return this.#executor
+            .withConnectionProvider(this)
+            .executeQuery(compiledQuery);
     }
     stream(compiledQuery, chunkSize) {
         assertNotCommittedOrRolledBack(this.#state);
-        return this.#executor.stream(compiledQuery, chunkSize);
+        return this.#executor
+            .withConnectionProvider(this)
+            .stream(compiledQuery, chunkSize);
     }
     withConnectionProvider(connectionProvider) {
         return new NotCommittedOrRolledBackAssertingExecutor(this.#executor.withConnectionProvider(connectionProvider), this.#state);

package/dist/esm/migration/migrator.js

@@ -410,34 +410,37 @@ export class Migrator {
             lockTableSchema: this.#props.migrationTableSchema,
         });
         const run = async (db) => {
+            const state = await this.#getState(db);
+            if (state.migrations.length === 0) {
+                return { results: [] };
+            }
+            const { direction, step } = getMigrationDirectionAndStep(state);
+            if (step <= 0) {
+                return { results: [] };
+            }
+            if (direction === 'Down') {
+                return await this.#migrateDown(db, state, step);
+            }
+            else if (direction === 'Up') {
+                return await this.#migrateUp(db, state, step);
+            }
+            return { results: [] };
+        };
+        const runWithLock = async (db, cb) => {
             try {
                 await adapter.acquireMigrationLock(db, lockOptions);
-                const state = await this.#getState(db);
-                if (state.migrations.length === 0) {
-                    return { results: [] };
-                }
-                const { direction, step } = getMigrationDirectionAndStep(state);
-                if (step <= 0) {
-                    return { results: [] };
-                }
-                if (direction === 'Down') {
-                    return await this.#migrateDown(db, state, step);
-                }
-                else if (direction === 'Up') {
-                    return await this.#migrateUp(db, state, step);
-                }
-                return { results: [] };
+                return await cb(db);
             }
             finally {
                 await adapter.releaseMigrationLock(db, lockOptions);
             }
         };
         if (adapter.supportsTransactionalDdl && !this.#props.disableTransactions) {
-            return this.#props.db.transaction().execute(run);
-        }
-        else {
-            return this.#props.db.connection().execute(run);
+            return this.#props.db
+                .connection()
+                .execute((db) => runWithLock(db, (db) => db.transaction().execute((trx) => run(trx))));
         }
+        return this.#props.db.connection().execute((db) => runWithLock(db, run));
     }
     async #getState(db) {
         const migrations = await this.#resolveMigrations();

package/dist/esm/query-builder/delete-query-builder.d.ts

@@ -1039,7 +1039,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * delete from `pet` order by `created_at` limit ?
      * ```
      */
-    limit(limit: ValueExpression<DB, TB, number>): DeleteQueryBuilder<DB, TB, O>;
+    limit<VE extends ValueExpression<DB, TB, number>>(limit: VE): DeleteQueryBuilder<DB, TB, O>;
     /**
      * This can be used to add any additional SQL to the end of the query.
      *
@@ -1122,7 +1122,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * }>
      * ```
      */
-    $if<O2>(condition: boolean, func: (qb: this) => DeleteQueryBuilder<any, any, O2>): O2 extends DeleteResult ? DeleteQueryBuilder<DB, TB, DeleteResult> : O2 extends O & infer E ? DeleteQueryBuilder<DB, TB, O & Partial<E>> : DeleteQueryBuilder<DB, TB, Partial<O2>>;
+    $if<O2>(condition: boolean, func: (qb: this) => DeleteQueryBuilder<any, any, O2>): unknown extends O2 ? DeleteQueryBuilder<any, any, O2> : O2 extends DeleteResult ? DeleteQueryBuilder<DB, TB, DeleteResult> : O2 extends O & infer E ? DeleteQueryBuilder<DB, TB, O & Partial<E>> : DeleteQueryBuilder<DB, TB, Partial<O2>>;
     /**
      * Change the output type of the query.
      *

package/dist/esm/query-builder/join-builder.d.ts

@@ -14,14 +14,14 @@ export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNo
      * See {@link WhereInterface.where} for documentation and examples.
      */
     on<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): JoinBuilder<DB, TB>;
-    on(expression: ExpressionOrFactory<DB, TB, SqlBool>): JoinBuilder<DB, TB>;
+    on<E extends ExpressionOrFactory<DB, TB, SqlBool>>(expression: E): JoinBuilder<DB, TB>;
     /**
      * Just like {@link WhereInterface.whereRef} but adds an item to the join's
      * `on` clause instead.
      *
      * See {@link WhereInterface.whereRef} for documentation and examples.
      */
-    onRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): JoinBuilder<DB, TB>;
+    onRef<LRE extends ReferenceExpression<DB, TB>, RRE extends ReferenceExpression<DB, TB>>(lhs: LRE, op: ComparisonOperatorExpression, rhs: RRE): JoinBuilder<DB, TB>;
     /**
      * Adds `on true`.
      */

package/dist/esm/query-builder/on-conflict-builder.d.ts

@@ -506,7 +506,7 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      *  "last_name" = excluded."last_name"
      * ```
      */
-    doUpdateSet(update: UpdateObjectExpression<OnConflictDatabase<DB, TB>, OnConflictTables<TB>, OnConflictTables<TB>>): OnConflictUpdateBuilder<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>;
+    doUpdateSet(update: UpdateObjectExpression<OnConflictUpdateDatabase<DB, TB>, OnConflictTables<TB>, OnConflictTables<TB>>): OnConflictUpdateBuilder<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>;
     /**
      * Simply calls the provided function passing `this` as the only argument. `$call` returns
      * what the provided function returns.
@@ -516,9 +516,12 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
 export interface OnConflictBuilderProps {
     readonly onConflictNode: OnConflictNode;
 }
-export type OnConflictDatabase<DB, TB extends keyof DB> = {
+export type OnConflictUpdateDatabase<DB, TB extends keyof DB> = {
     [K in keyof DB | 'excluded']: Updateable<K extends keyof DB ? DB[K] : DB[TB]>;
 };
+export type OnConflictDatabase<DB, TB extends keyof DB> = {
+    [K in keyof DB | 'excluded']: K extends keyof DB ? DB[K] : DB[TB];
+};
 export type OnConflictTables<TB> = TB | 'excluded';
 export declare class OnConflictDoNothingBuilder<DB, TB extends keyof DB> implements OperationNodeSource {
     #private;

package/dist/esm/query-builder/select-query-builder.d.ts

@@ -1377,7 +1377,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      * select "first_name" from "person" limit $1 offset $2
      * ```
      */
-    limit(limit: ValueExpression<DB, TB, number | bigint | null>): SelectQueryBuilder<DB, TB, O>;
+    limit<VE extends ValueExpression<DB, TB, number | bigint | null>>(limit: VE): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds an `offset` clause to the query.
      *
@@ -1400,7 +1400,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      * select "first_name" from "person" limit $1 offset $2
      * ```
      */
-    offset(offset: ValueExpression<DB, TB, number | bigint>): SelectQueryBuilder<DB, TB, O>;
+    offset<VE extends ValueExpression<DB, TB, number | bigint>>(offset: VE): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds a `fetch` clause to the query.
      *
@@ -2367,22 +2367,44 @@ export interface SelectQueryBuilderProps {
 export interface AliasedSelectQueryBuilder<O = undefined, A extends string = never> extends AliasedExpression<O, A> {
     get isAliasedSelectQueryBuilder(): true;
 }
-export type SelectQueryBuilderWithInnerJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? InnerJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? SelectQueryBuilder<DB, TB | TE, O> : TE extends AliasedExpression<infer QO, infer QA> ? InnerJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? InnerJoinedBuilder<DB, TB, O, QA, QO> : never;
+/**
+ * Guards a join's result type against being computed for an unknown table
+ * expression.
+ *
+ * `TableExpression<DB, TB> extends TE` only holds when `TE` is as wide as its
+ * own constraint, which never happens at a call site - there `TE` is a specific
+ * table name, alias or subquery. It does happen when the compiler asks what a
+ * join returns for an arbitrary table expression, which is what it has to do
+ * whenever it compares two `SelectQueryBuilder` types structurally.
+ *
+ * Without this guard that comparison never terminates on its own: computing the
+ * join result yields a `SelectQueryBuilder` over a wider `DB`, whose own join
+ * methods yield a wider one still, so the compiler only stops when it hits its
+ * internal recursion limit. That limit differs between TypeScript versions - 7.0
+ * searches a level deeper than 5.9 and 6.0 - which made comparing two select
+ * query builders over 6x more expensive there.
+ *
+ * Collapsing to a fixed type makes the recursion converge instead: joining an
+ * unknown table expression again produces the same type, so the compiler
+ * recognises the pair it is already comparing and stops immediately.
+ */
+type JoinResultForUnknownTable<O> = SelectQueryBuilder<any, any, O>;
+export type SelectQueryBuilderWithInnerJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TableExpression<DB, TB> extends TE ? JoinResultForUnknownTable<O> : TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? InnerJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? SelectQueryBuilder<DB, TB | TE, O> : TE extends AliasedExpression<infer QO, infer QA> ? InnerJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? InnerJoinedBuilder<DB, TB, O, QA, QO> : never;
 type InnerJoinedBuilder<DB, TB extends keyof DB, O, A extends string, R> = A extends keyof DB ? SelectQueryBuilder<InnerJoinedDB<DB, A, R>, TB | A, O> : SelectQueryBuilder<DB & ShallowRecord<A, R>, TB | A, O>;
 type InnerJoinedDB<DB, A extends string, R> = DrainOuterGeneric<{
     [C in keyof DB | A]: C extends A ? R : C extends keyof DB ? DB[C] : never;
 }>;
-export type SelectQueryBuilderWithLeftJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? LeftJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? LeftJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? LeftJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? LeftJoinedBuilder<DB, TB, O, QA, QO> : never;
+export type SelectQueryBuilderWithLeftJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TableExpression<DB, TB> extends TE ? JoinResultForUnknownTable<O> : TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? LeftJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? LeftJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? LeftJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? LeftJoinedBuilder<DB, TB, O, QA, QO> : never;
 type LeftJoinedBuilder<DB, TB extends keyof DB, O, A extends keyof any, R> = A extends keyof DB ? SelectQueryBuilder<LeftJoinedDB<DB, A, R>, TB | A, O> : SelectQueryBuilder<DB & ShallowRecord<A, Nullable<R>>, TB | A, O>;
 type LeftJoinedDB<DB, A extends keyof any, R> = DrainOuterGeneric<{
     [C in keyof DB | A]: C extends A ? Nullable<R> : C extends keyof DB ? DB[C] : never;
 }>;
-export type SelectQueryBuilderWithRightJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? RightJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? RightJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? RightJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? RightJoinedBuilder<DB, TB, O, QA, QO> : never;
+export type SelectQueryBuilderWithRightJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TableExpression<DB, TB> extends TE ? JoinResultForUnknownTable<O> : TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? RightJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? RightJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? RightJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? RightJoinedBuilder<DB, TB, O, QA, QO> : never;
 type RightJoinedBuilder<DB, TB extends keyof DB, O, A extends keyof any, R> = SelectQueryBuilder<RightJoinedDB<DB, TB, A, R>, TB | A, O>;
 type RightJoinedDB<DB, TB extends keyof DB, A extends keyof any, R> = DrainOuterGeneric<{
     [C in keyof DB | A]: C extends A ? R : C extends TB ? Nullable<DB[C]> : C extends keyof DB ? DB[C] : never;
 }>;
-export type SelectQueryBuilderWithFullJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? OuterJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? OuterJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? OuterJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? OuterJoinedBuilder<DB, TB, O, QA, QO> : never;
+export type SelectQueryBuilderWithFullJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TableExpression<DB, TB> extends TE ? JoinResultForUnknownTable<O> : TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? OuterJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? OuterJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? OuterJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? OuterJoinedBuilder<DB, TB, O, QA, QO> : never;
 type OuterJoinedBuilder<DB, TB extends keyof DB, O, A extends keyof any, R> = SelectQueryBuilder<OuterJoinedBuilderDB<DB, TB, A, R>, TB | A, O>;
 type OuterJoinedBuilderDB<DB, TB extends keyof DB, A extends keyof any, R> = DrainOuterGeneric<{
     [C in keyof DB | A]: C extends A ? Nullable<R> : C extends TB ? Nullable<DB[C]> : C extends keyof DB ? DB[C] : never;

package/dist/esm/query-builder/update-query-builder.d.ts

@@ -1148,7 +1148,7 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * }>
      * ```
      */
-    $if<O2>(condition: boolean, func: (qb: this) => UpdateQueryBuilder<any, any, any, O2>): O2 extends UpdateResult ? UpdateQueryBuilder<DB, UT, TB, UpdateResult> : O2 extends O & infer E ? UpdateQueryBuilder<DB, UT, TB, O & Partial<E>> : UpdateQueryBuilder<DB, UT, TB, Partial<O2>>;
+    $if<O2>(condition: boolean, func: (qb: this) => UpdateQueryBuilder<any, any, any, O2>): unknown extends O2 ? UpdateQueryBuilder<any, any, any, O2> : O2 extends UpdateResult ? UpdateQueryBuilder<DB, UT, TB, UpdateResult> : O2 extends O & infer E ? UpdateQueryBuilder<DB, UT, TB, O & Partial<E>> : UpdateQueryBuilder<DB, UT, TB, Partial<O2>>;
     /**
      * Change the output type of the query.
      *

package/dist/esm/query-compiler/default-query-compiler.js

@@ -260,6 +260,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' ');
             this.visitNode(node.where);
         }
+        if (node.returning) {
+            this.append(' ');
+            this.visitNode(node.returning);
+        }
         if (node.orderBy) {
             this.append(' ');
             this.visitNode(node.orderBy);
@@ -268,10 +272,6 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.append(' ');
             this.visitNode(node.limit);
         }
-        if (node.returning) {
-            this.append(' ');
-            this.visitNode(node.returning);
-        }
         if (wrapInParens) {
             this.append(')');
         }

package/dist/esm/schema/create-type-builder.d.ts

@@ -9,7 +9,7 @@ export declare class CreateTypeBuilder implements OperationNodeSource, Compilabl
     constructor(props: CreateTypeBuilderProps);
     toOperationNode(): CreateTypeNode;
     /**
-     * Creates an anum type.
+     * Creates an enum type.
      *
      * ### Examples
      *

package/dist/esm/schema/create-type-builder.js

@@ -10,7 +10,7 @@ export class CreateTypeBuilder {
         return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
     }
     /**
-     * Creates an anum type.
+     * Creates an enum type.
      *
      * ### Examples
      *

package/dist/esm/util/column-type.d.ts

@@ -170,7 +170,7 @@ export type Insertable<R> = DrainOuterGeneric<object & {
  * ```
  */
 export type Updateable<R> = DrainOuterGeneric<{
-    [K in UpdateKeys<R>]?: UpdateType<R[K]>;
+    [K in UpdateKeys<R>]?: UpdateType<R[K]> | undefined;
 }>;
 /**
  * Wrap your column type to opt-out from dehydration by {@link ShallowDehydrateValue},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely",
-  "version": "0.28.17",
+  "version": "0.28.18",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",
@@ -70,6 +70,39 @@
     }
   },
   "sideEffects": false,
+  "scripts": {
+    "clean": "rm -rf dist & rm -rf test/node/dist & rm -rf test/browser/bundle.js & rm -rf helpers",
+    "bench:ts": "pnpm build && cd ./test/ts-benchmarks && node --experimental-strip-types ./index.ts",
+    "test": "pnpm build && pnpm test:node:build && pnpm test:node:run && pnpm test:typings && pnpm test:esmimports && pnpm test:exports",
+    "test:node:build": "tsc -p test/node",
+    "test:node": "pnpm build && pnpm test:node:build && pnpm test:node:run",
+    "test:node:run": "mocha --timeout 15000 test/node/dist/**/*.test.js",
+    "test:browser:build": "rm -rf test/browser/bundle.js && esbuild test/browser/main.ts --bundle --outfile=test/browser/bundle.js",
+    "test:browser": "pnpm build && pnpm test:browser:build && node test/browser/test.js",
+    "test:bun": "pnpm build && bun link && cd test/bun && bun install && bun run test",
+    "test:cloudflare-workers": "pnpm build && pnpm -r test --filter kysely-cloudflare-workers-test",
+    "test:deno": "deno run --allow-env --allow-read --allow-net --no-lock test/deno/test.ts",
+    "test:typings": "tsd test/typings",
+    "test:esmimports": "node scripts/check-esm-imports.cjs",
+    "test:esbuild": "esbuild --bundle --platform=node --external:pg-native dist/esm/index.js --outfile=/dev/null",
+    "test:exports": "attw --pack . && node scripts/check-exports.cjs",
+    "test:jsdocs": "deno check --doc-only --no-lock --unstable-sloppy-imports --config=\"deno.check.json\" ./src",
+    "test:outdatedts": "pnpm build && cd test/outdated-ts && pnpm i && pnpm test",
+    "lint:deno": "deno lint --config=\"deno.lint.json\" ./src",
+    "prettier": "prettier --write 'src/**/*.ts' 'test/**/*.ts'",
+    "build": "pnpm clean && (pnpm build:esm & pnpm build:cjs) && pnpm script:module-fixup && pnpm script:copy-interface-doc",
+    "build:esm": "tsc -p tsconfig.json && pnpm script:add-deno-type-references",
+    "build:cjs": "tsc -p tsconfig-cjs.json",
+    "script:module-fixup": "node scripts/module-fixup.cjs",
+    "script:copy-interface-doc": "node scripts/copy-interface-documentation.cjs",
+    "script:add-deno-type-references": "node scripts/add-deno-type-references.cjs",
+    "script:align-versions": "node --experimental-strip-types scripts/align-versions.mts",
+    "script:generate-site-examples": "node scripts/generate-site-examples.cjs",
+    "script:exclude-test-files-for-backwards-compat": "node --experimental-strip-types scripts/exclude-test-files-for-backwards-compat.mts",
+    "script:remove-global-augmentations": "node --experimental-strip-types scripts/remove-global-augmentations.mts",
+    "prepublishOnly": "pnpm build && pnpm test:exports",
+    "version": "pnpm script:align-versions && git add ."
+  },
   "author": "Sami Koskimäki <sami@jakso.me>",
   "license": "MIT",
   "contributors": [
@@ -110,36 +143,5 @@
     "tsd": "0.33.0",
     "typescript": "6.0.2"
   },
-  "scripts": {
-    "clean": "rm -rf dist & rm -rf test/node/dist & rm -rf test/browser/bundle.js & rm -rf helpers",
-    "bench:ts": "pnpm build && cd ./test/ts-benchmarks && node --experimental-strip-types ./index.ts",
-    "test": "pnpm build && pnpm test:node:build && pnpm test:node:run && pnpm test:typings && pnpm test:esmimports && pnpm test:exports",
-    "test:node:build": "tsc -p test/node",
-    "test:node": "pnpm build && pnpm test:node:build && pnpm test:node:run",
-    "test:node:run": "mocha --timeout 15000 test/node/dist/**/*.test.js",
-    "test:browser:build": "rm -rf test/browser/bundle.js && esbuild test/browser/main.ts --bundle --outfile=test/browser/bundle.js",
-    "test:browser": "pnpm build && pnpm test:browser:build && node test/browser/test.js",
-    "test:bun": "pnpm build && bun link && cd test/bun && bun install && bun run test",
-    "test:cloudflare-workers": "pnpm build && pnpm -r test --filter kysely-cloudflare-workers-test",
-    "test:deno": "deno run --allow-env --allow-read --allow-net --no-lock test/deno/test.ts",
-    "test:typings": "tsd test/typings",
-    "test:esmimports": "node scripts/check-esm-imports.cjs",
-    "test:esbuild": "esbuild --bundle --platform=node --external:pg-native dist/esm/index.js --outfile=/dev/null",
-    "test:exports": "attw --pack . && node scripts/check-exports.cjs",
-    "test:jsdocs": "deno check --doc-only --no-lock --unstable-sloppy-imports --config=\"deno.check.json\" ./src",
-    "test:outdatedts": "pnpm build && cd test/outdated-ts && pnpm i && pnpm test",
-    "lint:deno": "deno lint --config=\"deno.lint.json\" ./src",
-    "prettier": "prettier --write 'src/**/*.ts' 'test/**/*.ts'",
-    "build": "pnpm clean && (pnpm build:esm & pnpm build:cjs) && pnpm script:module-fixup && pnpm script:copy-interface-doc",
-    "build:esm": "tsc -p tsconfig.json && pnpm script:add-deno-type-references",
-    "build:cjs": "tsc -p tsconfig-cjs.json",
-    "script:module-fixup": "node scripts/module-fixup.cjs",
-    "script:copy-interface-doc": "node scripts/copy-interface-documentation.cjs",
-    "script:add-deno-type-references": "node scripts/add-deno-type-references.cjs",
-    "script:align-versions": "node --experimental-strip-types scripts/align-versions.mts",
-    "script:generate-site-examples": "node scripts/generate-site-examples.cjs",
-    "script:exclude-test-files-for-backwards-compat": "node --experimental-strip-types scripts/exclude-test-files-for-backwards-compat.mts",
-    "script:remove-global-augmentations": "node --experimental-strip-types scripts/remove-global-augmentations.mts",
-    "version": "pnpm script:align-versions && git add ."
-  }
-}
+  "packageManager": "pnpm@10.33.0+sha512.10568bb4a6afb58c9eb3630da90cc9516417abebd3fabbe6739f0ae795728da1491e9db5a544c76ad8eb7570f5c4bb3d6c637b2cb41bfdcdb47fa823c8649319"
+}