kysely 0.16.4 → 0.16.8

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

@@ -7,11 +7,18 @@ const raw_node_js_1 = require("../operation-node/raw-node.js");
 const value_node_js_1 = require("../operation-node/value-node.js");
 const reference_parser_js_1 = require("../parser/reference-parser.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
+const query_id_js_1 = require("../util/query-id.js");
 const object_utils_js_1 = require("../util/object-utils.js");
+const noop_query_executor_js_1 = require("../query-executor/noop-query-executor.js");
 class RawBuilder {
     #props;
     constructor(props) {
-        this.#props = (0, object_utils_js_1.freeze)(props);
+        this.#props = (0, object_utils_js_1.freeze)({
+            queryId: props.queryId ?? (0, query_id_js_1.createQueryId)(),
+            executor: props.executor ?? new noop_query_executor_js_1.NoopQueryExecutor(),
+            sql: props.sql,
+            parameters: props.parameters,
+        });
     }
     as(alias) {
         return new AliasedRawBuilder(this, alias);

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

@@ -5,13 +5,13 @@ import { OperationNodeSource } from '../operation-node/operation-node-source.js'
 import { OnModifyForeignAction } from '../operation-node/references-node.js';
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { Compilable } from '../util/compilable.js';
-import { PrimitiveValue } from '../util/object-utils.js';
 import { ColumnDefinitionBuilder, ColumnDefinitionBuilderInterface } from './column-definition-builder.js';
 import { AnyRawBuilder } from '../util/type-utils.js';
 import { QueryId } from '../util/query-id.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { DataTypeExpression } from '../parser/data-type-parser.js';
 import { ForeignKeyConstraintBuilder, ForeignKeyConstraintBuilderInterface } from './foreign-key-constraint-builder.js';
+import { DefaultValueExpression } from '../parser/default-value-parser.js';
 /**
  * This builder can be used to create a `alter table` query.
  */
@@ -43,7 +43,7 @@ export declare class AlterColumnBuilder {
     #private;
     constructor(props: AlterColumnBuilderProps);
     setDataType(dataType: ColumnDataType): AlterTableExecutor;
-    setDefault(value: PrimitiveValue | AnyRawBuilder): AlterTableExecutor;
+    setDefault(value: DefaultValueExpression): AlterTableExecutor;
     dropDefault(): AlterTableExecutor;
     setNotNull(): AlterTableExecutor;
     dropNotNull(): AlterTableExecutor;
@@ -141,8 +141,21 @@ export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuild
      *   .addColumn('number_of_legs', 'integer', (col) => col.defaultTo(4))
      *   .execute()
      * ```
+     *
+     * Raw expressions are also supported:
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn(
+     *     'number_of_legs',
+     *     'integer',
+     *     (col) => col.defaultTo(db.raw('any SQL here'))
+     *   )
+     *   .execute()
+     * ```
      */
-    defaultTo(value: PrimitiveValue | AnyRawBuilder): AlterTableAddColumnBuilder;
+    defaultTo(value: DefaultValueExpression): AlterTableAddColumnBuilder;
     /**
      * Adds a check constraint for the column.
      *
@@ -286,8 +299,21 @@ export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBu
      *   .addColumn('number_of_legs', 'integer', (col) => col.defaultTo(4))
      *   .execute()
      * ```
+     *
+     * Raw expressions are also supported:
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn(
+     *     'number_of_legs',
+     *     'integer',
+     *     (col) => col.defaultTo(db.raw('any SQL here'))
+     *   )
+     *   .execute()
+     * ```
      */
-    defaultTo(value: PrimitiveValue | AnyRawBuilder): AlterTableModifyColumnBuilder;
+    defaultTo(value: DefaultValueExpression): AlterTableModifyColumnBuilder;
     /**
      * Adds a check constraint for the column.
      *

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

@@ -8,10 +8,8 @@ const column_definition_node_js_1 = require("../operation-node/column-definition
 const data_type_node_js_1 = require("../operation-node/data-type-node.js");
 const drop_column_node_js_1 = require("../operation-node/drop-column-node.js");
 const identifier_node_js_1 = require("../operation-node/identifier-node.js");
-const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
 const rename_column_node_js_1 = require("../operation-node/rename-column-node.js");
 const table_node_js_1 = require("../operation-node/table-node.js");
-const value_node_js_1 = require("../operation-node/value-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
 const column_definition_builder_js_1 = require("./column-definition-builder.js");
@@ -23,6 +21,7 @@ const unique_constraint_node_js_1 = require("../operation-node/unique-constraint
 const check_constraint_node_js_1 = require("../operation-node/check-constraint-node.js");
 const foreign_key_constraint_node_js_1 = require("../operation-node/foreign-key-constraint-node.js");
 const column_node_js_1 = require("../operation-node/column-node.js");
+const default_value_parser_js_1 = require("../parser/default-value-parser.js");
 /**
  * This builder can be used to create a `alter table` query.
  */
@@ -130,9 +129,7 @@ class AlterColumnBuilder {
             ...this.#props,
             alterTableNode: alter_table_node_js_1.AlterTableNode.cloneWith(this.#props.alterTableNode, {
                 alterColumn: alter_column_node_js_1.AlterColumnNode.cloneWith(this.#props.alterColumnNode, {
-                    setDefault: (0, operation_node_source_js_1.isOperationNodeSource)(value)
-                        ? value.toOperationNode()
-                        : value_node_js_1.ValueNode.createImmediate(value),
+                    setDefault: (0, default_value_parser_js_1.parseDefaultValueExpression)(value),
                 }),
             }),
         });

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

@@ -1,6 +1,5 @@
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { OnModifyForeignAction } from '../operation-node/references-node.js';
-import { PrimitiveValue } from '../util/object-utils.js';
 import { ColumnDefinitionNode } from '../operation-node/column-definition-node.js';
 import { AnyRawBuilder } from '../util/type-utils.js';
 import { DefaultValueExpression } from '../parser/default-value-parser.js';
@@ -83,8 +82,21 @@ export interface ColumnDefinitionBuilderInterface {
      *   .addColumn('number_of_legs', 'integer', (col) => col.defaultTo(4))
      *   .execute()
      * ```
+     *
+     * Raw expressions are also supported:
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn(
+     *     'number_of_legs',
+     *     'integer',
+     *     (col) => col.defaultTo(db.raw('any SQL here'))
+     *   )
+     *   .execute()
+     * ```
      */
-    defaultTo(value: PrimitiveValue | AnyRawBuilder): ColumnDefinitionBuilderInterface;
+    defaultTo(value: DefaultValueExpression): ColumnDefinitionBuilderInterface;
     /**
      * Adds a check constraint for the column.
      *
@@ -222,6 +234,19 @@ export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderI
      *   .addColumn('number_of_legs', 'integer', (col) => col.defaultTo(4))
      *   .execute()
      * ```
+     *
+     * Raw expressions are also supported:
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn(
+     *     'number_of_legs',
+     *     'integer',
+     *     (col) => col.defaultTo(db.raw('any SQL here'))
+     *   )
+     *   .execute()
+     * ```
      */
     defaultTo(value: DefaultValueExpression): ColumnDefinitionBuilder;
     /**

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

@@ -5,7 +5,7 @@ const prevent_await_js_1 = require("../util/prevent-await.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const create_view_node_js_1 = require("../operation-node/create-view-node.js");
 const reference_parser_js_1 = require("../parser/reference-parser.js");
-const immediate_value_plugin_js_1 = require("../plugin/immediate-value.ts/immediate-value-plugin.js");
+const immediate_value_plugin_js_1 = require("../plugin/immediate-value/immediate-value-plugin.js");
 class CreateViewBuilder {
     #props;
     constructor(props) {

package/dist/cjs/util/log.d.ts

@@ -17,6 +17,7 @@ export declare type LogConfig = ReadonlyArray<LogLevel> | Logger;
 export declare class Log {
     #private;
     constructor(config: LogConfig);
+    isLevelEnabled(level: LogLevel): boolean;
     query(getEvent: () => QueryLogEvent): void;
     error(getEvent: () => ErrorLogEvent): void;
 }

package/dist/cjs/util/log.js

@@ -22,6 +22,9 @@ class Log {
             });
         }
     }
+    isLevelEnabled(level) {
+        return this.#levels[level];
+    }
     query(getEvent) {
         if (this.#levels.query) {
             this.#logger(getEvent());

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

@@ -1,14 +1,13 @@
-/// <reference types="node" />
-export declare type PrimitiveValue = string | number | boolean | null | Date | Buffer | BigInt;
-export declare function isEmpty(obj: ArrayLike<unknown> | string | object | Buffer): boolean;
+export declare function isEmpty(obj: ArrayLike<unknown> | string | object): boolean;
 export declare function isString(obj: unknown): obj is string;
 export declare function isNumber(obj: unknown): obj is number;
 export declare function isBoolean(obj: unknown): obj is boolean;
 export declare function isNull(obj: unknown): obj is null;
 export declare function isDate(obj: unknown): obj is Date;
 export declare function isBigInt(obj: unknown): obj is BigInt;
-export declare function isBuffer(obj: unknown): obj is Buffer;
-export declare function isPrimitive(obj: unknown): obj is PrimitiveValue;
+export declare function isBuffer(obj: unknown): obj is {
+    length: number;
+};
 export declare function isFunction(obj: unknown): obj is Function;
 export declare function isObject(obj: unknown): obj is Record<string, unknown>;
 export declare function getLast<T>(arr: ArrayLike<T>): T | undefined;
@@ -17,3 +16,4 @@ export declare function asArray<T>(arg: T | T[]): T[];
 export declare function asReadonlyArray<T>(arg: T | ReadonlyArray<T>): ReadonlyArray<T>;
 export declare function isReadonlyArray(arg: unknown): arg is ReadonlyArray<unknown>;
 export declare function noop<T>(obj: T): T;
+export declare function compare(obj1: unknown, obj2: unknown): boolean;

package/dist/cjs/util/object-utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.noop = exports.isReadonlyArray = exports.asReadonlyArray = exports.asArray = exports.freeze = exports.getLast = exports.isObject = exports.isFunction = exports.isPrimitive = exports.isBuffer = exports.isBigInt = exports.isDate = exports.isNull = exports.isBoolean = exports.isNumber = exports.isString = exports.isEmpty = void 0;
+exports.compare = exports.noop = exports.isReadonlyArray = exports.asReadonlyArray = exports.asArray = exports.freeze = exports.getLast = exports.isObject = exports.isFunction = exports.isBuffer = exports.isBigInt = exports.isDate = exports.isNull = exports.isBoolean = exports.isNumber = exports.isString = exports.isEmpty = void 0;
 function isEmpty(obj) {
     if (Array.isArray(obj) || isString(obj) || isBuffer(obj)) {
         return obj.length === 0;
@@ -35,20 +35,12 @@ function isBigInt(obj) {
     return typeof obj === 'bigint';
 }
 exports.isBigInt = isBigInt;
+// Don't change the returnd type to `obj is Buffer` to not create a
+// hard dependency to node.
 function isBuffer(obj) {
     return typeof Buffer !== 'undefined' && Buffer.isBuffer(obj);
 }
 exports.isBuffer = isBuffer;
-function isPrimitive(obj) {
-    return (isString(obj) ||
-        isNumber(obj) ||
-        isBoolean(obj) ||
-        isNull(obj) ||
-        isDate(obj) ||
-        isBigInt(obj) ||
-        isBuffer(obj));
-}
-exports.isPrimitive = isPrimitive;
 function isFunction(obj) {
     return typeof obj === 'function';
 }
@@ -91,3 +83,52 @@ function noop(obj) {
     return obj;
 }
 exports.noop = noop;
+function compare(obj1, obj2) {
+    if (isReadonlyArray(obj1) && isReadonlyArray(obj2)) {
+        return compareArrays(obj1, obj2);
+    }
+    else if (isObject(obj1) && isObject(obj2)) {
+        return compareObjects(obj1, obj2);
+    }
+    return obj1 === obj2;
+}
+exports.compare = compare;
+function compareArrays(arr1, arr2) {
+    if (arr1.length !== arr2.length) {
+        return false;
+    }
+    for (let i = 0; i < arr1.length; ++i) {
+        if (!compare(arr1[i], arr2[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+function compareObjects(obj1, obj2) {
+    if (isBuffer(obj1) && isBuffer(obj2)) {
+        return compareBuffers(obj1, obj2);
+    }
+    else if (isDate(obj1) && isDate(obj2)) {
+        return compareDates(obj1, obj2);
+    }
+    return compareGenericObjects(obj1, obj2);
+}
+function compareBuffers(buf1, buf2) {
+    return Buffer.compare(buf1, buf2) === 0;
+}
+function compareDates(date1, date2) {
+    return date1.getTime() === date2.getTime();
+}
+function compareGenericObjects(obj1, obj2) {
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    if (keys1.length !== keys2.length) {
+        return false;
+    }
+    for (const key of keys1) {
+        if (!compare(obj1[key], obj2[key])) {
+            return false;
+        }
+    }
+    return true;
+}

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

@@ -111,3 +111,24 @@ export declare type UnknownRow = Record<string, unknown>;
 export declare type Nullable<T> = {
     [P in keyof T]: T[P] | null;
 };
+/**
+ * Takes all properties from T1 and merges all properties from T2
+ * that don't exist in T1 as optional properties.
+ *
+ * Example:
+ *
+ * interface Person {
+ *   name: string
+ *   age: number
+ * }
+ *
+ * interface Pet {
+ *   name: string
+ *   species: 'cat' | 'dog'
+ * }
+ *
+ * type Merged = MergePartial<Person, Pet>
+ *
+ * // { name: string, age: number, species?: 'cat' | 'dog' }
+ */
+export declare type MergePartial<T1, T2> = T1 & Partial<Omit<T2, keyof T1>>;

package/dist/esm/dialect/mysql/mysql-dialect.js

@@ -3,6 +3,7 @@ import { MysqlDriver } from './mysql-driver.js';
 import { MysqlQueryCompiler } from './mysql-query-compiler.js';
 import { MysqlIntrospector } from './mysql-introspector.js';
 import { MysqlAdapter } from './mysql-adapter.js';
+import { freeze } from '../../util/object-utils.js';
 /**
  * MySQL dialect that uses the [mysql2](https://github.com/sidorares/node-mysql2#readme) library.
  *
@@ -13,7 +14,7 @@ import { MysqlAdapter } from './mysql-adapter.js';
 export class MysqlDialect {
     #config;
     constructor(config) {
-        this.#config = config;
+        this.#config = freeze({ ...config });
     }
     createDriver() {
         return new MysqlDriver(this.#config);

package/dist/esm/dialect/mysql/mysql-driver.js

@@ -1,13 +1,13 @@
 /// <reference types="./mysql-driver.d.ts" />
 import { CompiledQuery } from '../../query-compiler/compiled-query.js';
-import { isFunction, isObject } from '../../util/object-utils.js';
+import { isFunction, isObject, freeze } from '../../util/object-utils.js';
 const PRIVATE_RELEASE_METHOD = Symbol();
 export class MysqlDriver {
     #config;
     #connections = new WeakMap();
     #pool;
     constructor(config) {
-        this.#config = config;
+        this.#config = freeze({ ...config });
     }
     async init() {
         // Import the `mysql2` module here instead at the top of the file

package/dist/esm/dialect/postgres/postgres-dialect.js

@@ -3,6 +3,7 @@ import { PostgresDriver } from './postgres-driver.js';
 import { PostgresIntrospector } from './postgres-introspector.js';
 import { PostgresQueryCompiler } from './postgres-query-compiler.js';
 import { PostgresAdapter } from './postgres-adapter.js';
+import { freeze } from '../../util/object-utils.js';
 /**
  * PostgreSQL dialect that uses the [pg](https://node-postgres.com/) library.
  *
@@ -16,7 +17,7 @@ import { PostgresAdapter } from './postgres-adapter.js';
 export class PostgresDialect {
     #config;
     constructor(config) {
-        this.#config = config;
+        this.#config = freeze({ ...config });
     }
     createDriver() {
         return new PostgresDriver(this.#config);

package/dist/esm/dialect/postgres/postgres-driver.js

@@ -1,13 +1,13 @@
 /// <reference types="./postgres-driver.d.ts" />
 import { CompiledQuery } from '../../query-compiler/compiled-query.js';
-import { isFunction } from '../../util/object-utils.js';
+import { isFunction, freeze } from '../../util/object-utils.js';
 const PRIVATE_RELEASE_METHOD = Symbol();
 export class PostgresDriver {
     #config;
     #connections = new WeakMap();
     #pool = null;
     constructor(config) {
-        this.#config = config;
+        this.#config = freeze({ ...config });
     }
     async init() {
         // Import the `pg` module here instead at the top of the file

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

@@ -3,6 +3,7 @@ import { SqliteDriver } from './sqlite-driver.js';
 import { SqliteQueryCompiler } from './sqlite-query-compiler.js';
 import { SqliteIntrospector } from './sqlite-introspector.js';
 import { SqliteAdapter } from './sqlite-adapter.js';
+import { freeze } from '../../util/object-utils.js';
 /**
  * SQLite dialect that uses the [better-sqlite3](https://github.com/JoshuaWise/better-sqlite3) library.
  *
@@ -13,7 +14,7 @@ import { SqliteAdapter } from './sqlite-adapter.js';
 export class SqliteDialect {
     #config;
     constructor(config) {
-        this.#config = config;
+        this.#config = freeze({ ...config });
     }
     createDriver() {
         return new SqliteDriver(this.#config);

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

@@ -1,13 +1,13 @@
 /// <reference types="./sqlite-driver.d.ts" />
 import { CompiledQuery } from '../../query-compiler/compiled-query.js';
-import { isBoolean, isFunction, isNumber } from '../../util/object-utils.js';
+import { freeze, isBoolean, isFunction, isNumber, } from '../../util/object-utils.js';
 export class SqliteDriver {
     #config;
     #connectionMutex = new ConnectionMutex();
     #db;
     #connection;
     constructor(config) {
-        this.#config = config;
+        this.#config = freeze({ ...config });
     }
     async init() {
         // Import the `better-sqlite3` module here instead at the top of the file

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

@@ -0,0 +1,68 @@
+import { DatabaseConnection } from './database-connection.js';
+import { Driver } from './driver.js';
+/**
+ * A driver that does absolutely nothing.
+ *
+ * You can use this to create Kysely instances solely for building queries
+ *
+ * ### Examples
+ *
+ * This example creates a Kysely instance for building postgres queries:
+ *
+ * ```ts
+ * const db = new Kysely<Database>({
+ *   dialect: {
+ *     createAdapter() {
+ *       return new PostgresAdapter()
+ *     },
+ *     createDriver() {
+ *       return new DummyDriver()
+ *     },
+ *     createIntrospector(db: Kysely<any>) {
+ *       return new PostgresIntrospector(db)
+ *     },
+ *     createQueryCompiler() {
+ *       return new PostgresQueryCompiler()
+ *     },
+ *   },
+ * })
+ * ```
+ */
+export declare class DummyDriver implements Driver {
+    /**
+     * Initializes the driver.
+     *
+     * After calling this method the driver should be usable and `acquireConnection` etc.
+     * methods should be callable.
+     *
+     * IMPORTANT: The underlying database engine driver (like [pg](https://node-postgres.com/))
+     * should be imported inside this function, not at the top of the driver file! This is
+     * important so that Kysely is usable without installing all database driver libraries
+     * it supports.
+     */
+    init(): Promise<void>;
+    /**
+     * Acquires a new connection from the pool.
+     */
+    acquireConnection(): Promise<DatabaseConnection>;
+    /**
+     * Begins a transaction.
+     */
+    beginTransaction(): Promise<void>;
+    /**
+     * Commits a transaction.
+     */
+    commitTransaction(): Promise<void>;
+    /**
+     * Rolls back a transaction.
+     */
+    rollbackTransaction(): Promise<void>;
+    /**
+     * Releases a connection back to the pool.
+     */
+    releaseConnection(): Promise<void>;
+    /**
+     * Destroys the driver and releases all resources.
+     */
+    destroy(): Promise<void>;
+}

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

@@ -0,0 +1,59 @@
+/// <reference types="./dummy-driver.d.ts" />
+/**
+ * A driver that does absolutely nothing.
+ *
+ * You can use this to create Kysely instances solely for building queries
+ *
+ * ### Examples
+ *
+ * This example creates a Kysely instance for building postgres queries:
+ *
+ * ```ts
+ * const db = new Kysely<Database>({
+ *   dialect: {
+ *     createAdapter() {
+ *       return new PostgresAdapter()
+ *     },
+ *     createDriver() {
+ *       return new DummyDriver()
+ *     },
+ *     createIntrospector(db: Kysely<any>) {
+ *       return new PostgresIntrospector(db)
+ *     },
+ *     createQueryCompiler() {
+ *       return new PostgresQueryCompiler()
+ *     },
+ *   },
+ * })
+ * ```
+ */
+export class DummyDriver {
+    async init() {
+        // Nothing to do here.
+    }
+    async acquireConnection() {
+        return new DummyConnection();
+    }
+    async beginTransaction() {
+        // Nothing to do here.
+    }
+    async commitTransaction() {
+        // Nothing to do here.
+    }
+    async rollbackTransaction() {
+        // Nothing to do here.
+    }
+    async releaseConnection() {
+        // Nothing to do here.
+    }
+    async destroy() {
+        // Nothing to do here.
+    }
+}
+class DummyConnection {
+    async executeQuery() {
+        return {
+            rows: [],
+        };
+    }
+}

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

@@ -28,7 +28,7 @@ export declare class RuntimeDriver implements Driver {
     /**
      * Releases a connection back to the pool.
      */
-    releaseConnection(runtimeConnection: DatabaseConnection): Promise<void>;
+    releaseConnection(connection: DatabaseConnection): Promise<void>;
     /**
      * Begins a transaction.
      */

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

@@ -10,7 +10,7 @@ export class RuntimeDriver {
     #log;
     #initPromise;
     #destroyPromise;
-    #connections = new WeakMap();
+    #connections = new WeakSet();
     constructor(driver, log) {
         this.#driver = driver;
         this.#log = log;
@@ -27,17 +27,16 @@ export class RuntimeDriver {
     async acquireConnection() {
         await this.init();
         const connection = await this.#driver.acquireConnection();
-        let runtimeConnection = this.#connections.get(connection);
-        if (!runtimeConnection) {
-            runtimeConnection = new RuntimeConnection(connection, this.#log);
-            this.#connections.set(connection, runtimeConnection);
+        if (!this.#connections.has(connection)) {
+            if (this.#needsLogging()) {
+                this.#addLogging(connection);
+            }
+            this.#connections.add(connection);
         }
-        return runtimeConnection;
+        return connection;
     }
-    async releaseConnection(runtimeConnection) {
-        if (runtimeConnection instanceof RuntimeConnection) {
-            await this.#driver.releaseConnection(runtimeConnection.connection);
-        }
+    async releaseConnection(connection) {
+        await this.#driver.releaseConnection(connection);
     }
     beginTransaction(connection, settings) {
         return this.#driver.beginTransaction(connection, settings);
@@ -61,29 +60,27 @@ export class RuntimeDriver {
         }
         await this.#destroyPromise;
     }
-}
-class RuntimeConnection {
-    #connection;
-    #log;
-    get connection() {
-        return this.#connection;
-    }
-    constructor(connection, log) {
-        this.#connection = connection;
-        this.#log = log;
+    #needsLogging() {
+        return (this.#log.isLevelEnabled('query') || this.#log.isLevelEnabled('error'));
     }
-    async executeQuery(compiledQuery) {
-        const startTime = performanceNow();
-        try {
-            return await this.#connection.executeQuery(compiledQuery);
-        }
-        catch (error) {
-            this.#logError(error);
-            throw error;
-        }
-        finally {
-            this.#logQuery(compiledQuery, startTime);
-        }
+    // This method monkey patches the database connection's executeQuery method
+    // by adding logging code around it. Monkey patching is not pretty, but it's
+    // the best option in this case.
+    #addLogging(connection) {
+        const executeQuery = connection.executeQuery;
+        connection.executeQuery = async (compiledQuery) => {
+            const startTime = performanceNow();
+            try {
+                return await executeQuery.call(connection, compiledQuery);
+            }
+            catch (error) {
+                this.#logError(error);
+                throw error;
+            }
+            finally {
+                this.#logQuery(compiledQuery, startTime);
+            }
+        };
     }
     #logError(error) {
         this.#log.error(() => ({