kysely 0.28.16 → 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

@@ -653,10 +653,6 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * On supported databases like PostgreSQL, this method can be chained to
      * `insert`, `update`, `delete` and `merge` queries to return data.
      *
-     * Note that on SQLite you need to give aliases for the expressions to avoid
-     * [this bug](https://sqlite.org/forum/forumpost/033daf0b32) in SQLite.
-     * For example `.returning('id as id')`.
-     *
      * Also see the {@link returningAll} method.
      *
      * ### Examples
@@ -1043,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.
      *
@@ -1126,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/insert-query-builder.d.ts

@@ -752,10 +752,6 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      * On supported databases like PostgreSQL, this method can be chained to
      * `insert`, `update`, `delete` and `merge` queries to return data.
      *
-     * Note that on SQLite you need to give aliases for the expressions to avoid
-     * [this bug](https://sqlite.org/forum/forumpost/033daf0b32) in SQLite.
-     * For example `.returning('id as id')`.
-     *
      * Also see the {@link returningAll} method.
      *
      * ### Examples

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/json-path-builder.js

@@ -7,6 +7,7 @@ import { JSONPathNode } from '../operation-node/json-path-node.js';
 import { JSONReferenceNode } from '../operation-node/json-reference-node.js';
 import { isOperationNodeSource } from '../operation-node/operation-node-source.js';
 import { ValueNode } from '../operation-node/value-node.js';
+const HASH_NEGATIVE_INDEX_REGEX = /^#-\d+$/;
 export class JSONPathBuilder {
     #node;
     constructor(node) {
@@ -80,6 +81,13 @@ export class JSONPathBuilder {
      * ```
      */
     at(index) {
+        if ((typeof index !== 'number' && typeof index !== 'string') ||
+            (typeof index === 'number' && !Number.isInteger(index)) ||
+            (typeof index === 'string' &&
+                index !== 'last' &&
+                !HASH_NEGATIVE_INDEX_REGEX.test(index))) {
+            throw new Error(`Unexpected index value in .at(...): ${index}`);
+        }
         return this.#createBuilderWithPathLeg('ArrayLocation', index);
     }
     /**

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

@@ -130,10 +130,6 @@ export declare class MergeQueryBuilder<DB, TT extends keyof DB, O> implements Mu
      * On supported databases like PostgreSQL, this method can be chained to
      * `insert`, `update`, `delete` and `merge` queries to return data.
      *
-     * Note that on SQLite you need to give aliases for the expressions to avoid
-     * [this bug](https://sqlite.org/forum/forumpost/033daf0b32) in SQLite.
-     * For example `.returning('id as id')`.
-     *
      * Also see the {@link returningAll} method.
      *
      * ### Examples
@@ -527,10 +523,6 @@ export declare class WheneableMergeQueryBuilder<DB, TT extends keyof DB, ST exte
      * On supported databases like PostgreSQL, this method can be chained to
      * `insert`, `update`, `delete` and `merge` queries to return data.
      *
-     * Note that on SQLite you need to give aliases for the expressions to avoid
-     * [this bug](https://sqlite.org/forum/forumpost/033daf0b32) in SQLite.
-     * For example `.returning('id as id')`.
-     *
      * Also see the {@link returningAll} method.
      *
      * ### Examples

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/returning-interface.d.ts

@@ -8,10 +8,6 @@ export interface ReturningInterface<DB, TB extends keyof DB, O> {
      * On supported databases like PostgreSQL, this method can be chained to
      * `insert`, `update`, `delete` and `merge` queries to return data.
      *
-     * Note that on SQLite you need to give aliases for the expressions to avoid
-     * [this bug](https://sqlite.org/forum/forumpost/033daf0b32) in SQLite.
-     * For example `.returning('id as id')`.
-     *
      * Also see the {@link returningAll} method.
      *
      * ### Examples

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

@@ -850,10 +850,6 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * On supported databases like PostgreSQL, this method can be chained to
      * `insert`, `update`, `delete` and `merge` queries to return data.
      *
-     * Note that on SQLite you need to give aliases for the expressions to avoid
-     * [this bug](https://sqlite.org/forum/forumpost/033daf0b32) in SQLite.
-     * For example `.returning('id as id')`.
-     *
      * Also see the {@link returningAll} method.
      *
      * ### Examples
@@ -1152,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.d.ts

@@ -222,6 +222,7 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected getRightExplainOptionsWrapper(): string;
     protected sanitizeIdentifier(identifier: string): string;
     protected sanitizeStringLiteral(value: string): string;
+    protected sanitizeJSONPathMemberValue(value: string): string;
     protected addParameter(parameter: unknown): void;
     protected appendImmediateValue(value: unknown): void;
     protected appendStringLiteral(value: string): void;

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

@@ -11,6 +11,7 @@ import { SetOperationNode } from '../operation-node/set-operation-node.js';
 import { WhenNode } from '../operation-node/when-node.js';
 import { logOnce } from '../util/log-once.js';
 const LIT_WRAP_REGEX = /'/g;
+const JSON_PATH_MEMBER_WRAP_REGEX = /['"]/g;
 export class DefaultQueryCompiler extends OperationNodeVisitor {
     #sql = '';
     #parameters = [];
@@ -259,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);
@@ -267,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(')');
         }
@@ -1166,13 +1167,17 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     }
     visitJSONPathLeg(node) {
         const isArrayLocation = node.type === 'ArrayLocation';
-        this.append(isArrayLocation ? '[' : '.');
-        this.append(typeof node.value === 'string'
-            ? this.sanitizeStringLiteral(node.value)
-            : String(node.value));
+        const value = String(node.value);
         if (isArrayLocation) {
+            this.append('[');
+            this.append(this.sanitizeStringLiteral(value));
             this.append(']');
         }
+        else {
+            this.append('."');
+            this.append(this.sanitizeJSONPathMemberValue(value));
+            this.append('"');
+        }
     }
     visitJSONOperatorChain(node) {
         for (let i = 0, len = node.values.length; i < len; i++) {
@@ -1319,6 +1324,9 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     sanitizeStringLiteral(value) {
         return value.replace(LIT_WRAP_REGEX, "''");
     }
+    sanitizeJSONPathMemberValue(value) {
+        return value.replace(JSON_PATH_MEMBER_WRAP_REGEX, (char) => char === "'" ? "''" : '\\"');
+    }
     addParameter(parameter) {
         this.#parameters.push(parameter);
     }

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},