kysely 0.17.0 → 0.17.3

package/dist/cjs/query-executor/noop-query-executor.js

@@ -1,20 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NOOP_QUERY_EXECUTOR = exports.NoopQueryExecutor = void 0;
-const query_executor_js_1 = require("./query-executor.js");
+const query_executor_base_js_1 = require("./query-executor-base.js");
 /**
  * A {@link QueryExecutor} subclass that can be used when you don't
  * have a {@link QueryCompiler}, {@link ConnectionProvider} or any
  * other needed things to actually execute queries.
  */
-class NoopQueryExecutor extends query_executor_js_1.QueryExecutor {
+class NoopQueryExecutor extends query_executor_base_js_1.QueryExecutorBase {
     get adapter() {
         throw new Error('this query cannot be compiled to SQL');
     }
     compileQuery() {
         throw new Error('this query cannot be compiled to SQL');
     }
-    async executeQueryImpl() {
+    provideConnection() {
         throw new Error('this query cannot be executed');
     }
     withConnectionProvider() {

package/dist/cjs/query-executor/query-executor-base.d.ts

@@ -0,0 +1,62 @@
+import { ConnectionProvider } from '../driver/connection-provider.js';
+import { DatabaseConnection, QueryResult } from '../driver/database-connection.js';
+import { CompiledQuery } from '../query-compiler/compiled-query.js';
+import { RootOperationNode } from '../query-compiler/query-compiler.js';
+import { KyselyPlugin } from '../plugin/kysely-plugin.js';
+import { QueryId } from '../util/query-id.js';
+import { DialectAdapter } from '../dialect/dialect-adapter.js';
+import { QueryExecutor } from './query-executor.js';
+export declare abstract class QueryExecutorBase implements QueryExecutor {
+    #private;
+    constructor(plugins?: ReadonlyArray<KyselyPlugin>);
+    abstract get adapter(): DialectAdapter;
+    /**
+     * Returns all installed plugins.
+     */
+    get plugins(): ReadonlyArray<KyselyPlugin>;
+    /**
+     * Given the query the user has built (expressed as an operation node tree)
+     * this method runs it through all plugins' `transformQuery` methods and
+     * returns the result.
+     */
+    transformQuery<T extends RootOperationNode>(node: T, queryId: QueryId): T;
+    /**
+     * Compiles the transformed query into SQL. You usually want to pass
+     * the output of {@link transformQuery} into this method but you can
+     * compile any query using this method.
+     */
+    abstract compileQuery(node: RootOperationNode, queryId: QueryId): CompiledQuery;
+    /**
+     * Provides a connection for the callback and takes care of disposing
+     * the connection after the callback has been run.
+     */
+    abstract provideConnection<T>(consumer: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
+    /**
+     * Executes a compiled query and runs the result through all plugins'
+     * `transformResult` method.
+     */
+    executeQuery<R>(compiledQuery: CompiledQuery, queryId: QueryId): Promise<QueryResult<R>>;
+    /**
+     * Returns a copy of this executor with a new connection provider.
+     */
+    abstract withConnectionProvider(connectionProvider: ConnectionProvider): QueryExecutorBase;
+    /**
+     * Returns a copy of this executor with a plugin added as the
+     * last plugin.
+     */
+    abstract withPlugin(plugin: KyselyPlugin): QueryExecutorBase;
+    /**
+     * Returns a copy of this executor with a list of plugins added
+     * as the last plugins.
+     */
+    abstract withPlugins(plugin: ReadonlyArray<KyselyPlugin>): QueryExecutorBase;
+    /**
+     * Returns a copy of this executor with a plugin added as the
+     * first plugin.
+     */
+    abstract withPluginAtFront(plugin: KyselyPlugin): QueryExecutorBase;
+    /**
+     * Returns a copy of this executor without any plugins.
+     */
+    abstract withoutPlugins(): QueryExecutorBase;
+}

package/dist/cjs/query-executor/query-executor-base.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryExecutorBase = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const NO_PLUGINS = (0, object_utils_js_1.freeze)([]);
+class QueryExecutorBase {
+    #plugins;
+    constructor(plugins = NO_PLUGINS) {
+        this.#plugins = plugins;
+    }
+    get plugins() {
+        return this.#plugins;
+    }
+    transformQuery(node, queryId) {
+        for (const plugin of this.#plugins) {
+            const transformedNode = plugin.transformQuery({ node, queryId });
+            // We need to do a runtime check here. There is no good way
+            // to write types that enforce this constraint.
+            if (transformedNode.kind === node.kind) {
+                node = transformedNode;
+            }
+            else {
+                throw new Error([
+                    `KyselyPlugin.transformQuery must return a node`,
+                    `of the same kind that was given to it.`,
+                    `The plugin was given a ${node.kind}`,
+                    `but it returned a ${transformedNode.kind}`,
+                ].join(' '));
+            }
+        }
+        return node;
+    }
+    async executeQuery(compiledQuery, queryId) {
+        return await this.provideConnection(async (connection) => {
+            const result = await connection.executeQuery(compiledQuery);
+            return this.#transformResult(result, queryId);
+        });
+    }
+    async #transformResult(result, queryId) {
+        for (const plugin of this.#plugins) {
+            result = await plugin.transformResult({ result, queryId });
+        }
+        return result;
+    }
+}
+exports.QueryExecutorBase = QueryExecutorBase;

package/dist/cjs/query-executor/query-executor.d.ts

@@ -6,15 +6,19 @@ import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { QueryId } from '../util/query-id.js';
 import { DialectAdapter } from '../dialect/dialect-adapter.js';
 /**
- * This class abstracts away the details of how to compile a query into SQL
+ * This interface abstracts away the details of how to compile a query into SQL
  * and execute it. Instead of passing around all those details, {@link SelectQueryBuilder}
  * and other classes that execute queries can just pass around and instance of
  * `QueryExecutor`.
  */
-export declare abstract class QueryExecutor {
-    #private;
-    constructor(plugins?: KyselyPlugin[]);
-    abstract get adapter(): DialectAdapter;
+export interface QueryExecutor extends ConnectionProvider {
+    /**
+     * Returns the adapter for the current dialect.
+     */
+    get adapter(): DialectAdapter;
+    /**
+     * Returns all installed plugins.
+     */
     get plugins(): ReadonlyArray<KyselyPlugin>;
     /**
      * Given the query the user has built (expressed as an operation node tree)
@@ -27,37 +31,33 @@ export declare abstract class QueryExecutor {
      * the output of {@link transformQuery} into this method but you can
      * compile any query using this method.
      */
-    abstract compileQuery(node: RootOperationNode, queryId: QueryId): CompiledQuery;
+    compileQuery(node: RootOperationNode, queryId: QueryId): CompiledQuery;
     /**
      * Executes a compiled query and runs the result through all plugins'
      * `transformResult` method.
      */
     executeQuery<R>(compiledQuery: CompiledQuery, queryId: QueryId): Promise<QueryResult<R>>;
-    /**
-     * Executes a compiled query.
-     */
-    protected abstract executeQueryImpl<R>(compiledQuery: CompiledQuery, queryId: QueryId): Promise<QueryResult<R>>;
     /**
      * Returns a copy of this executor with a new connection provider.
      */
-    abstract withConnectionProvider(connectionProvider: ConnectionProvider): QueryExecutor;
+    withConnectionProvider(connectionProvider: ConnectionProvider): QueryExecutor;
     /**
      * Returns a copy of this executor with a plugin added as the
      * last plugin.
      */
-    abstract withPlugin(plugin: KyselyPlugin): QueryExecutor;
+    withPlugin(plugin: KyselyPlugin): QueryExecutor;
     /**
      * Returns a copy of this executor with a list of plugins added
      * as the last plugins.
      */
-    abstract withPlugins(plugin: ReadonlyArray<KyselyPlugin>): QueryExecutor;
+    withPlugins(plugin: ReadonlyArray<KyselyPlugin>): QueryExecutor;
     /**
      * Returns a copy of this executor with a plugin added as the
      * first plugin.
      */
-    abstract withPluginAtFront(plugin: KyselyPlugin): QueryExecutor;
+    withPluginAtFront(plugin: KyselyPlugin): QueryExecutor;
     /**
      * Returns a copy of this executor without any plugins.
      */
-    abstract withoutPlugins(): QueryExecutor;
+    withoutPlugins(): QueryExecutor;
 }

package/dist/cjs/query-executor/query-executor.js

@@ -1,59 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryExecutor = void 0;
-const object_utils_js_1 = require("../util/object-utils.js");
-const NO_PLUGINS = (0, object_utils_js_1.freeze)([]);
-/**
- * This class abstracts away the details of how to compile a query into SQL
- * and execute it. Instead of passing around all those details, {@link SelectQueryBuilder}
- * and other classes that execute queries can just pass around and instance of
- * `QueryExecutor`.
- */
-class QueryExecutor {
-    #plugins;
-    constructor(plugins) {
-        this.#plugins = plugins ?? NO_PLUGINS;
-    }
-    get plugins() {
-        return this.#plugins;
-    }
-    /**
-     * Given the query the user has built (expressed as an operation node tree)
-     * this method runs it through all plugins' `transformQuery` methods and
-     * returns the result.
-     */
-    transformQuery(node, queryId) {
-        for (const plugin of this.#plugins) {
-            const transformedNode = plugin.transformQuery({ node, queryId });
-            // We need to do a runtime check here. There is no good way
-            // to write types that enforce this constraint.
-            if (transformedNode.kind === node.kind) {
-                node = transformedNode;
-            }
-            else {
-                throw new Error([
-                    `KyselyPlugin.transformQuery must return a node`,
-                    `of the same kind that was given to it.`,
-                    `The plugin was given a ${node.kind}`,
-                    `but it returned a ${transformedNode.kind}`,
-                ].join(' '));
-            }
-        }
-        return node;
-    }
-    /**
-     * Executes a compiled query and runs the result through all plugins'
-     * `transformResult` method.
-     */
-    async executeQuery(compiledQuery, queryId) {
-        const result = await this.executeQueryImpl(compiledQuery, queryId);
-        return this.#transformResult(result, queryId);
-    }
-    async #transformResult(result, queryId) {
-        for (const plugin of this.#plugins) {
-            result = await plugin.transformResult({ result, queryId });
-        }
-        return result;
-    }
-}
-exports.QueryExecutor = QueryExecutor;

package/dist/cjs/raw-builder/sql.d.ts

@@ -221,7 +221,7 @@ export interface Sql {
      *   sql.id('first_name')
      * ]
      *
-     * sql`BEFORE ${sql.array(things, sql`::varchar, `)} AFTER`
+     * sql`BEFORE ${sql.join(things, sql`::varchar, `)} AFTER`
      * ```
      *
      * The generated SQL (PostgreSQL):
@@ -281,7 +281,7 @@ export interface Sql {
  * from "person"
  * where birthdate between $1 and $2
  * and "nicknames" @> ARRAY[$3, $4, $5, $6, $7, $8, $9, $10]
- * order by concate(first_name, ' ', last_name)
+ * order by concat(first_name, ' ', last_name)
  * ```
  *
  * SQL snippets can be executed by calling the `execute` method and passing a `Kysely`
@@ -313,7 +313,15 @@ export interface Sql {
  *   .select([
  *     'first_name',
  *     'last_name',
- *     (eb) => sql<string>`concat(${eb.ref('first_name')}, ' ', ${eb.ref('last_name')})`.as('full_name')
+ *     (eb) => {
+ *       // The `eb.ref` method is type-safe and only accepts
+ *       // column references that are possible.
+ *       const firstName = eb.ref('first_name')
+ *       const lastName = eb.ref('last_name')
+ *
+ *       const fullName = sql<string>`concat(${firstName}, ' ', ${lastName})`
+ *       return fullName.as('full_name')
+ *     }
  *   ])
  * ```
  *

package/dist/cjs/raw-builder/sql.js

@@ -58,7 +58,7 @@ const raw_builder_js_1 = require("./raw-builder.js");
  * from "person"
  * where birthdate between $1 and $2
  * and "nicknames" @> ARRAY[$3, $4, $5, $6, $7, $8, $9, $10]
- * order by concate(first_name, ' ', last_name)
+ * order by concat(first_name, ' ', last_name)
  * ```
  *
  * SQL snippets can be executed by calling the `execute` method and passing a `Kysely`
@@ -90,7 +90,15 @@ const raw_builder_js_1 = require("./raw-builder.js");
  *   .select([
  *     'first_name',
  *     'last_name',
- *     (eb) => sql<string>`concat(${eb.ref('first_name')}, ' ', ${eb.ref('last_name')})`.as('full_name')
+ *     (eb) => {
+ *       // The `eb.ref` method is type-safe and only accepts
+ *       // column references that are possible.
+ *       const firstName = eb.ref('first_name')
+ *       const lastName = eb.ref('last_name')
+ *
+ *       const fullName = sql<string>`concat(${firstName}, ' ', ${lastName})`
+ *       return fullName.as('full_name')
+ *     }
  *   ])
  * ```
  *

package/dist/cjs/schema/alter-table-builder.d.ts

@@ -23,6 +23,13 @@ export declare class AlterTableBuilder {
     alterColumn(column: string): AlterColumnBuilder;
     dropColumn(column: string): AlterTableExecutor;
     renameColumn(column: string, newColumn: string): AlterTableExecutor;
+    /**
+     * See {@link CreateTableBuilder.addColumn}
+     *
+     * Unlike {@link CreateTableBuilder.addColumn} this method returns the column builder
+     * and doesn't take a callback as the last argument. This is because you can only
+     * add one column per `ALTER TABLE` query.
+     */
     addColumn(columnName: string, dataType: DataTypeExpression): AlterTableAddColumnBuilder;
     /**
      * Creates an `alter table modify column` query. The `modify column` statement
@@ -30,8 +37,21 @@ export declare class AlterTableBuilder {
      * should use the `alterColumn` method.
      */
     modifyColumn(columnName: string, dataType: DataTypeExpression): AlterTableModifyColumnBuilder;
+    /**
+     * See {@link CreateTableBuilder.addUniqueConstraint}
+     */
     addUniqueConstraint(constraintName: string, columns: string[]): AlterTableExecutor;
+    /**
+     * See {@link CreateTableBuilder.addCheckConstraint}
+     */
     addCheckConstraint(constraintName: string, checkExpression: AnyRawBuilder): AlterTableExecutor;
+    /**
+     * See {@link CreateTableBuilder.addForeignKeyConstraint}
+     *
+     * Unlike {@link CreateTableBuilder.addForeignKeyConstraint} this method returns
+     * the constraint builder and doesn't take a callback as the last argument. This
+     * is because you can only add one column per `ALTER TABLE` query.
+     */
     addForeignKeyConstraint(constraintName: string, columns: string[], targetTable: string, targetColumns: string[]): AlterTableAddForeignKeyConstraintBuilder;
 }
 export interface AlterTableBuilderProps {
@@ -142,7 +162,8 @@ export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuild
      *   .execute()
      * ```
      *
-     * Raw {@link sql} expressions are also supported:
+     * Values passed to `defaultTo` are interpreted as value literals by default. You can define
+     * an arbitrary SQL expression using the {@link sql} template tag:
      *
      * ```ts
      * import { sql } from 'kysely'
@@ -306,7 +327,8 @@ export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBu
      *   .execute()
      * ```
      *
-     * Raw {@link sql} expressions are also supported:
+     * Values passed to `defaultTo` are interpreted as value literals by default. You can define
+     * an arbitrary SQL expression using the {@link sql} template tag:
      *
      * ```ts
      * import { sql } from 'kysely'

package/dist/cjs/schema/alter-table-builder.js

@@ -68,6 +68,13 @@ class AlterTableBuilder {
             }),
         });
     }
+    /**
+     * See {@link CreateTableBuilder.addColumn}
+     *
+     * Unlike {@link CreateTableBuilder.addColumn} this method returns the column builder
+     * and doesn't take a callback as the last argument. This is because you can only
+     * add one column per `ALTER TABLE` query.
+     */
     addColumn(columnName, dataType) {
         return new AlterTableAddColumnBuilder({
             ...this.#props,
@@ -85,6 +92,9 @@ class AlterTableBuilder {
             columnBuilder: new column_definition_builder_js_1.ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.create(columnName, (0, data_type_parser_js_1.parseDataTypeExpression)(dataType))),
         });
     }
+    /**
+     * See {@link CreateTableBuilder.addUniqueConstraint}
+     */
     addUniqueConstraint(constraintName, columns) {
         return new AlterTableExecutor({
             ...this.#props,
@@ -93,6 +103,9 @@ class AlterTableBuilder {
             }),
         });
     }
+    /**
+     * See {@link CreateTableBuilder.addCheckConstraint}
+     */
     addCheckConstraint(constraintName, checkExpression) {
         return new AlterTableExecutor({
             ...this.#props,
@@ -101,6 +114,13 @@ class AlterTableBuilder {
             }),
         });
     }
+    /**
+     * See {@link CreateTableBuilder.addForeignKeyConstraint}
+     *
+     * Unlike {@link CreateTableBuilder.addForeignKeyConstraint} this method returns
+     * the constraint builder and doesn't take a callback as the last argument. This
+     * is because you can only add one column per `ALTER TABLE` query.
+     */
     addForeignKeyConstraint(constraintName, columns, targetTable, targetColumns) {
         return new AlterTableAddForeignKeyConstraintBuilder({
             ...this.#props,

package/dist/cjs/schema/column-definition-builder.d.ts

@@ -83,7 +83,8 @@ export interface ColumnDefinitionBuilderInterface {
      *   .execute()
      * ```
      *
-     * Raw {@link sql} expressions are also supported:
+     * Values passed to `defaultTo` are interpreted as value literals by default. You can define
+     * an arbitrary SQL expression using the {@link sql} template tag:
      *
      * ```ts
      * import { sql } from 'kysely'
@@ -241,7 +242,8 @@ export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderI
      *   .execute()
      * ```
      *
-     * Raw {@link sql} expressions are also supported:
+     * Values passed to `defaultTo` are interpreted as value literals by default. You can define
+     * an arbitrary SQL expression using the {@link sql} template tag:
      *
      * ```ts
      * import { sql } from 'kysely'

package/dist/cjs/schema/create-table-builder.d.ts

@@ -136,7 +136,7 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * )
      * ```
      *
-     * Add constraintfor multiple columns:
+     * Add constraint for multiple columns:
      *
      * ```ts
      * addForeignKeyConstraint(

package/dist/cjs/schema/create-table-builder.js

@@ -186,7 +186,7 @@ class CreateTableBuilder {
      * )
      * ```
      *
-     * Add constraintfor multiple columns:
+     * Add constraint for multiple columns:
      *
      * ```ts
      * addForeignKeyConstraint(

package/dist/cjs/util/type-utils.d.ts

@@ -74,7 +74,7 @@ export declare type ExtractColumnType<DB, TB extends keyof DB, C> = {
  *   movie: Movie
  * }
  *
- * type Columns = AnyColumn<Database, 'person' | 'pet'>
+ * type Columns = AnyColumnWithTable<Database, 'person' | 'pet'>
  *
  * // Columns == 'person.id' | 'pet.name' | 'pet.species'
  * ```

package/dist/esm/dialect/mysql/mysql-dialect-config.d.ts

@@ -162,6 +162,25 @@ export interface MysqlDialectConfig {
      * If keep-alive is enabled users can supply an initial delay.
      */
     keepAliveInitialDelay?: number;
+    charsetNumber?: number;
+    compress?: boolean;
+    authSwitchHandler?: (data: any, callback: () => void) => any;
+    connectAttributes?: {
+        [param: string]: any;
+    };
+    decimalNumbers?: boolean;
+    isServer?: boolean;
+    maxPreparedStatements?: number;
+    namedPlaceholders?: boolean;
+    nestTables?: boolean | string;
+    passwordSha1?: string;
+    pool?: any;
+    stream?: any;
+    uri?: string;
+    Promise?: any;
+    authPlugins?: {
+        [key: string]: any;
+    };
     /**
      * Called once for each created connection.
      *

package/dist/esm/driver/connection-provider.d.ts

@@ -4,5 +4,5 @@ export interface ConnectionProvider {
      * Provides a connection for the callback and takes care of disposing
      * the connection after the callback has been run.
      */
-    withConnection<T>(runner: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
+    provideConnection<T>(consumer: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
 }

package/dist/esm/driver/default-connection-provider.d.ts

@@ -8,5 +8,5 @@ export declare class DefaultConnectionProvider implements ConnectionProvider {
      * Provides a connection for the callback and takes care of disposing
      * the connection after the callback has been run.
      */
-    withConnection<T>(runner: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
+    provideConnection<T>(consumer: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
 }

package/dist/esm/driver/default-connection-provider.js

@@ -4,10 +4,10 @@ export class DefaultConnectionProvider {
     constructor(driver) {
         this.#driver = driver;
     }
-    async withConnection(runner) {
+    async provideConnection(consumer) {
         const connection = await this.#driver.acquireConnection();
         try {
-            return await runner(connection);
+            return await consumer(connection);
         }
         finally {
             await this.#driver.releaseConnection(connection);

package/dist/esm/driver/dummy-driver.d.ts

@@ -27,6 +27,14 @@ import { Driver } from './driver.js';
  *   },
  * })
  * ```
+ *
+ * You can use it to build a query and compile it to SQL but trying to
+ * execute the query will throw an error.
+ *
+ * ```ts
+ * const { sql } = db.selectFrom('person').selectAll().compile()
+ * console.log(sql) // select * from "person"
+ * ```
  */
 export declare class DummyDriver implements Driver {
     /**

package/dist/esm/driver/dummy-driver.js

@@ -26,6 +26,14 @@
  *   },
  * })
  * ```
+ *
+ * You can use it to build a query and compile it to SQL but trying to
+ * execute the query will throw an error.
+ *
+ * ```ts
+ * const { sql } = db.selectFrom('person').selectAll().compile()
+ * console.log(sql) // select * from "person"
+ * ```
  */
 export class DummyDriver {
     async init() {

package/dist/esm/driver/single-connection-provider.d.ts

@@ -7,5 +7,5 @@ export declare class SingleConnectionProvider implements ConnectionProvider {
      * Provides a connection for the callback and takes care of disposing
      * the connection after the callback has been run.
      */
-    withConnection<T>(runner: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
+    provideConnection<T>(consumer: (connection: DatabaseConnection) => Promise<T>): Promise<T>;
 }

package/dist/esm/driver/single-connection-provider.js

@@ -5,11 +5,11 @@ export class SingleConnectionProvider {
     constructor(connection) {
         this.#connection = connection;
     }
-    async withConnection(runner) {
+    async provideConnection(consumer) {
         while (this.#runningPromise) {
             await this.#runningPromise;
         }
-        const promise = this.#run(runner);
+        const promise = this.#run(consumer);
         this.#runningPromise = promise
             .then(() => {
             this.#runningPromise = undefined;

package/dist/esm/kysely.js

@@ -333,18 +333,14 @@ export class ConnectionBuilder {
         this.#props = freeze(props);
     }
     async execute(callback) {
-        const connection = await this.#props.driver.acquireConnection();
-        const connectionProvider = new SingleConnectionProvider(connection);
-        const db = new Kysely({
-            ...this.#props,
-            executor: this.#props.executor.withConnectionProvider(connectionProvider),
-        });
-        try {
+        return this.#props.executor.provideConnection(async (connection) => {
+            const executor = this.#props.executor.withConnectionProvider(new SingleConnectionProvider(connection));
+            const db = new Kysely({
+                ...this.#props,
+                executor,
+            });
             return await callback(db);
-        }
-        finally {
-            await this.#props.driver.releaseConnection(connection);
-        }
+        });
     }
 }
 preventAwait(ConnectionBuilder, "don't await ConnectionBuilder instances directly. To execute the query you need to call the `execute` method");
@@ -363,25 +359,23 @@ export class TransactionBuilder {
         const { isolationLevel, ...kyselyProps } = this.#props;
         const settings = { isolationLevel };
         validateTransactionSettings(settings);
-        const connection = await this.#props.driver.acquireConnection();
-        const connectionProvider = new SingleConnectionProvider(connection);
-        const transaction = new Transaction({
-            ...kyselyProps,
-            executor: this.#props.executor.withConnectionProvider(connectionProvider),
+        return this.#props.executor.provideConnection(async (connection) => {
+            const executor = this.#props.executor.withConnectionProvider(new SingleConnectionProvider(connection));
+            const transaction = new Transaction({
+                ...kyselyProps,
+                executor,
+            });
+            try {
+                await this.#props.driver.beginTransaction(connection, settings);
+                const result = await callback(transaction);
+                await this.#props.driver.commitTransaction(connection);
+                return result;
+            }
+            catch (error) {
+                await this.#props.driver.rollbackTransaction(connection);
+                throw error;
+            }
         });
-        try {
-            await this.#props.driver.beginTransaction(connection, settings);
-            const result = await callback(transaction);
-            await this.#props.driver.commitTransaction(connection);
-            return result;
-        }
-        catch (error) {
-            await this.#props.driver.rollbackTransaction(connection);
-            throw error;
-        }
-        finally {
-            await this.#props.driver.releaseConnection(connection);
-        }
     }
 }
 preventAwait(TransactionBuilder, "don't await TransactionBuilder instances directly. To execute the transaction you need to call the `execute` method");