kysely 0.28.17 → 0.29.0

package/dist/dialect/pglite/pglite-dialect.js

@@ -0,0 +1,47 @@
+/// <reference types="./pglite-dialect.d.ts" />
+import { PostgresIntrospector } from '../postgres/postgres-introspector.js';
+import { PostgresQueryCompiler } from '../postgres/postgres-query-compiler.js';
+import { PGliteAdapter } from './pglite-adapter.js';
+import { PGliteDriver } from './pglite-driver.js';
+/**
+ * PGlite dialect.
+ *
+ * The constructor takes an instance of {@link PGliteDialectConfig}.
+ *
+ * ```ts
+ * import { PGlite } from '@electric-sql/pglite'
+ *
+ * new PGliteDialect({
+ *   pglite: new PGlite()
+ * })
+ * ```
+ *
+ * If you want the client to only be created once it's first used, `pglite`
+ * can be a function:
+ *
+ * ```ts
+ * import { PGlite } from '@electric-sql/pglite'
+ *
+ * new PGliteDialect({
+ *   pglite: () => new PGlite()
+ * })
+ * ```
+ */
+export class PGliteDialect {
+    #config;
+    constructor(config) {
+        this.#config = config;
+    }
+    createAdapter() {
+        return new PGliteAdapter();
+    }
+    createDriver() {
+        return new PGliteDriver(this.#config);
+    }
+    createIntrospector(db) {
+        return new PostgresIntrospector(db);
+    }
+    createQueryCompiler() {
+        return new PostgresQueryCompiler();
+    }
+}

package/dist/dialect/pglite/pglite-driver.d.ts

@@ -0,0 +1,57 @@
+import type { DatabaseConnection, QueryResult } from '../../driver/database-connection.js';
+import type { Driver } from '../../driver/driver.js';
+import type { CompiledQuery } from '../../query-compiler/compiled-query.js';
+import type { QueryCompiler } from '../../query-compiler/query-compiler.js';
+import { type AbortableOperationOptions } from '../../util/abort.js';
+import type { PGlite, PGliteDialectConfig } from './pglite-dialect-config.js';
+declare const PRIVATE_BEGIN_TRANSACTION_METHOD: unique symbol;
+declare const PRIVATE_COMMIT_TRANSACTION_METHOD: unique symbol;
+declare const PRIVATE_ROLLBACK_TRANSACTION_METHOD: unique symbol;
+export declare class PGliteDriver implements Driver {
+    #private;
+    constructor(config: PGliteDialectConfig);
+    /**
+     * Acquires a new connection from the pool.
+     */
+    acquireConnection(): Promise<DatabaseConnection>;
+    /**
+     * Begins a transaction.
+     */
+    beginTransaction(connection: PGliteConnection): Promise<void>;
+    /**
+     * Commits a transaction.
+     */
+    commitTransaction(connection: PGliteConnection): Promise<void>;
+    /**
+     * Destroys the driver and releases all resources.
+     */
+    destroy(): Promise<void>;
+    /**
+     * Initializes the driver.
+     *
+     * After calling this method the driver should be usable and `acquireConnection` etc.
+     * methods should be callable.
+     */
+    init(options?: AbortableOperationOptions): Promise<void>;
+    /**
+     * Releases a connection back to the pool.
+     */
+    releaseConnection(): Promise<void>;
+    releaseSavepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    rollbackToSavepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    /**
+     * Rolls back a transaction.
+     */
+    rollbackTransaction(connection: PGliteConnection): Promise<void>;
+    savepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+}
+declare class PGliteConnection implements DatabaseConnection {
+    #private;
+    constructor(pglite: PGlite);
+    executeQuery<R>(compiledQuery: CompiledQuery): Promise<QueryResult<R>>;
+    streamQuery<R>(): AsyncIterableIterator<QueryResult<R>>;
+    [PRIVATE_BEGIN_TRANSACTION_METHOD](): Promise<void>;
+    [PRIVATE_COMMIT_TRANSACTION_METHOD](): Promise<void>;
+    [PRIVATE_ROLLBACK_TRANSACTION_METHOD](): Promise<void>;
+}
+export {};

package/dist/dialect/pglite/pglite-driver.js

@@ -0,0 +1,119 @@
+/// <reference types="./pglite-driver.d.ts" />
+import { parseSavepointCommand } from '../../parser/savepoint-parser.js';
+import { waitOrAbort, } from '../../util/abort.js';
+import { Deferred } from '../../util/deferred.js';
+import { freeze, isFunction } from '../../util/object-utils.js';
+import { createQueryId } from '../../util/query-id.js';
+import { extendStackTrace } from '../../util/stack-trace-utils.js';
+const PRIVATE_BEGIN_TRANSACTION_METHOD = Symbol();
+const PRIVATE_COMMIT_TRANSACTION_METHOD = Symbol();
+const PRIVATE_ROLLBACK_TRANSACTION_METHOD = Symbol();
+export class PGliteDriver {
+    #config;
+    #connection;
+    #pglite;
+    constructor(config) {
+        this.#config = freeze({ ...config });
+    }
+    async acquireConnection() {
+        return this.#connection;
+    }
+    async beginTransaction(connection) {
+        await connection[PRIVATE_BEGIN_TRANSACTION_METHOD]();
+    }
+    async commitTransaction(connection) {
+        await connection[PRIVATE_COMMIT_TRANSACTION_METHOD]();
+    }
+    async destroy() {
+        if (!this.#pglite?.closed) {
+            await this.#pglite?.close();
+        }
+    }
+    async init(options) {
+        this.#pglite ??= isFunction(this.#config.pglite)
+            ? await this.#config.pglite(options)
+            : this.#config.pglite;
+        if (this.#pglite.closed) {
+            throw new Error('PGlite instance is already closed.');
+        }
+        if (!this.#pglite.ready) {
+            await waitOrAbort(this.#pglite.waitReady, options?.signal, 'wait ready');
+        }
+        this.#connection = new PGliteConnection(this.#pglite);
+        if (this.#config.onCreateConnection) {
+            await this.#config.onCreateConnection(this.#connection, options);
+        }
+    }
+    async releaseConnection() {
+        // noop
+    }
+    async releaseSavepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('release', savepointName), createQueryId()));
+    }
+    async rollbackToSavepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('rollback to', savepointName), createQueryId()));
+    }
+    async rollbackTransaction(connection) {
+        await connection[PRIVATE_ROLLBACK_TRANSACTION_METHOD]();
+    }
+    async savepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('savepoint', savepointName), createQueryId()));
+    }
+}
+class PGliteConnection {
+    #pglite;
+    #commitTransaction;
+    #rollbackTransaction;
+    #transaction;
+    #transactionClosedPromise;
+    constructor(pglite) {
+        this.#pglite = pglite;
+    }
+    async executeQuery(compiledQuery) {
+        try {
+            const { affectedRows, rows } = await (this.#transaction || this.#pglite).query(compiledQuery.sql, compiledQuery.parameters, {
+                rowMode: 'object',
+            });
+            return {
+                numAffectedRows: affectedRows != null ? BigInt(affectedRows) : undefined,
+                rows: rows || [],
+            };
+        }
+        catch (error) {
+            throw extendStackTrace(error, new Error());
+        }
+    }
+    async *streamQuery() {
+        throw new Error('Streaming is not supported by PGlite.');
+    }
+    async [PRIVATE_BEGIN_TRANSACTION_METHOD]() {
+        const { promise: waitForCommit, reject: rollback, resolve: commit, } = new Deferred();
+        const { promise: waitForBegin, resolve: hasBegun } = new Deferred();
+        this.#commitTransaction = commit;
+        this.#rollbackTransaction = rollback;
+        // we want to use PGlite's exclusive transaction mode, to lock the instance,
+        // in case this dialect is not the only one using it.
+        this.#transactionClosedPromise = this.#pglite.transaction(async (tx) => {
+            this.#transaction = tx;
+            hasBegun();
+            await waitForCommit;
+        });
+        await waitForBegin;
+    }
+    async [PRIVATE_COMMIT_TRANSACTION_METHOD]() {
+        this.#commitTransaction?.();
+        await this.#transactionClosedPromise;
+        this.#commitTransaction = undefined;
+        this.#rollbackTransaction = undefined;
+        this.#transaction = undefined;
+        this.#transactionClosedPromise = undefined;
+    }
+    async [PRIVATE_ROLLBACK_TRANSACTION_METHOD]() {
+        this.#rollbackTransaction?.();
+        await this.#transactionClosedPromise?.catch(() => { });
+        this.#commitTransaction = undefined;
+        this.#rollbackTransaction = undefined;
+        this.#transaction = undefined;
+        this.#transactionClosedPromise = undefined;
+    }
+}

package/dist/dialect/postgres/postgres-adapter.d.ts

@@ -0,0 +1,71 @@
+import type { Kysely } from '../../kysely.js';
+import { DialectAdapterBase } from '../dialect-adapter-base.js';
+import type { MigrationLockOptions } from '../dialect-adapter.js';
+export declare class PostgresAdapter extends DialectAdapterBase {
+    get supportsTransactionalDdl(): boolean;
+    get supportsReturning(): boolean;
+    /**
+     * This method is used to acquire a lock for the migrations so that
+     * it's not possible for two migration operations to run in parallel.
+     *
+     * Most dialects have explicit locks that can be used, like advisory locks
+     * in PostgreSQL and the get_lock function in MySQL.
+     *
+     * If the dialect doesn't have explicit locks the {@link MigrationLockOptions.lockTable}
+     * created by Kysely can be used instead. You can access it through the `options` object.
+     * The lock table has two columns `id` and `is_locked` and there's only one row in the table
+     * whose id is {@link MigrationLockOptions.lockRowId}. `is_locked` is an integer. Kysely
+     * takes care of creating the lock table and inserting the one single row to it before this
+     * method is executed. If the dialect supports schemas and the user has specified a custom
+     * schema in their migration settings, the options object also contains the schema name in
+     * {@link MigrationLockOptions.lockTableSchema}.
+     *
+     * Here's an example of how you might implement this method for a dialect that doesn't
+     * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
+     *
+     * ```ts
+     * import { DialectAdapterBase, type MigrationLockOptions, Kysely } from 'kysely'
+     *
+     * export class MyAdapter extends DialectAdapterBase {
+     *   override async acquireMigrationLock(
+     *     db: Kysely<any>,
+     *     options: MigrationLockOptions
+     *   ): Promise<void> {
+     *     const queryDb = options.lockTableSchema
+     *       ? db.withSchema(options.lockTableSchema)
+     *       : db
+     *
+     *     // Since our imaginary dialect supports transactional DDL and has
+     *     // row locks, we can simply take a row lock here and it will guarantee
+     *     // all subsequent calls to this method from other transactions will
+     *     // wait until this transaction finishes.
+     *     await queryDb
+     *       .selectFrom(options.lockTable)
+     *       .selectAll()
+     *       .where('id', '=', options.lockRowId)
+     *       .forUpdate()
+     *       .execute()
+     *   }
+     *
+     *   override async releaseMigrationLock() {
+     *     // noop
+     *   }
+     * }
+     * ```
+     *
+     * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
+     * is a transaction inside which the migrations will be executed. Otherwise
+     * `db` is a single connection (session) that will be used to execute the
+     * migrations.
+     */
+    acquireMigrationLock(db: Kysely<any>, _opt: MigrationLockOptions): Promise<void>;
+    /**
+     * Releases the migration lock. See {@link acquireMigrationLock}.
+     *
+     * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
+     * is a transaction inside which the migrations were executed. Otherwise `db`
+     * is a single connection (session) that was used to execute the migrations
+     * and the `acquireMigrationLock` call.
+     */
+    releaseMigrationLock(_db: Kysely<any>, _opt: MigrationLockOptions): Promise<void>;
+}

package/dist/dialect/postgres/postgres-dialect-config.d.ts

@@ -0,0 +1,123 @@
+import type { DatabaseConnection } from '../../driver/database-connection.js';
+import type { AbortableOperationOptions } from '../../util/abort.js';
+/**
+ * Config for the PostgreSQL dialect.
+ */
+export interface PostgresDialectConfig {
+    /**
+     * A `pg` `Client` constructor, to be used for connecting to the database
+     * outside of the `pool` to avoid waiting for an idle connection.
+     *
+     * This is useful for cancelling queries on the database side.
+     *
+     * Defaults to the `Pool`'s undocumented `Client` member, if it exists.
+     */
+    controlClient?: PostgresClientConstructor;
+    /**
+     * https://github.com/brianc/node-postgres/tree/master/packages/pg-cursor
+     *
+     * ```ts
+     * import { PostgresDialect } from 'kysely'
+     * import { Pool } from 'pg'
+     * import Cursor from 'pg-cursor'
+     * // or import * as Cursor from 'pg-cursor'
+     *
+     * new PostgresDialect({
+     *  cursor: Cursor,
+     *  pool: new Pool('postgres://localhost:5432/mydb')
+     * })
+     * ```
+     */
+    cursor?: PostgresCursorConstructor;
+    /**
+     * Called once for each created connection.
+     */
+    onCreateConnection?: (connection: DatabaseConnection, options?: AbortableOperationOptions) => Promise<void>;
+    /**
+     * Called every time a connection is acquired from the pool.
+     */
+    onReserveConnection?: (connection: DatabaseConnection, options?: AbortableOperationOptions) => Promise<void>;
+    /**
+     * A postgres `Pool` instance or a function that returns one.
+     *
+     * If a function is provided, it's called once when the first query is executed.
+     *
+     * https://node-postgres.com/apis/pool
+     */
+    pool: PostgresPool | ((options?: AbortableOperationOptions) => Promise<PostgresPool>);
+}
+/**
+ * This interface is the subset of pg driver's `Pool` class that
+ * kysely needs.
+ *
+ * We don't use the type from `pg` here to not have a dependency to it.
+ *
+ * https://node-postgres.com/apis/pool
+ */
+export interface PostgresPool {
+    Client?: PostgresClientConstructor;
+    connect(): Promise<PostgresPoolClient>;
+    end(): Promise<void>;
+    options: object;
+}
+/**
+ * This interface is the subset of pg driver's `Client` class that
+ * kysely needs.
+ *
+ * We don't use the type from `pg` here to not have a dependency to it.
+ *
+ * https://node-postgres.com/apis/client
+ */
+export interface PostgresClient {
+    connect(): Promise<PostgresClient>;
+    end(): void;
+    processID?: number;
+    query<R>(sql: string, parameters: ReadonlyArray<unknown>): Promise<PostgresQueryResult<R>>;
+    query<R>(cursor: PostgresCursor<R>): PostgresCursor<R>;
+}
+export type PostgresClientConstructor = new (options: any) => PostgresClient;
+/**
+ * This interface is the subset of pg driver's `Client` class that
+ * is returned by the `Pool` class, and that kysely needs.
+ *
+ * We don't use the type from `pg` here to not have a dependency to it.
+ *
+ * https://node-postgres.com/apis/pool#releasing-clients
+ */
+export interface PostgresPoolClient extends Omit<PostgresClient, 'connect' | 'end'> {
+    release(): void;
+}
+/**
+ * This interface is pg driver's `Cursor` class that kysely needs.
+ *
+ * We don't use the type from `pg-cursor` here to not have a dependency to it.
+ *
+ * https://node-postgres.com/apis/cursor
+ */
+export interface PostgresCursor<T> {
+    read(rowsCount: number): Promise<T[]>;
+    close(): Promise<void>;
+}
+/**
+ * This interface is pg driver's `Cursor` class constructor that kysely needs.
+ *
+ * We don't use the type from `pg-cursor` here to not have a dependency to it.
+ *
+ * https://node-postgres.com/apis/cursor#constructor
+ */
+export type PostgresCursorConstructor = new <T>(sql: string, parameters: unknown[]) => PostgresCursor<T>;
+/**
+ * This interface is the subset of pg driver's `Result` shape that kysely needs.
+ *
+ * We don't use the type from `pg` here to not have a dependency to it.
+ *
+ * https://node-postgres.com/apis/result
+ */
+export interface PostgresQueryResult<R> {
+    command: 'UPDATE' | 'DELETE' | 'INSERT' | 'SELECT' | 'MERGE';
+    rowCount: number;
+    rows: R[];
+}
+export interface PostgresStream<T> {
+    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+}

package/dist/dialect/postgres/postgres-driver.d.ts

@@ -0,0 +1,61 @@
+import type { ControlConnectionProvider, DatabaseConnection, QueryResult } from '../../driver/database-connection.js';
+import type { Driver, TransactionSettings } from '../../driver/driver.js';
+import { CompiledQuery } from '../../query-compiler/compiled-query.js';
+import type { QueryCompiler } from '../../query-compiler/query-compiler.js';
+import type { AbortableOperationOptions } from '../../util/abort.js';
+import type { PostgresClientConstructor, PostgresCursorConstructor, PostgresDialectConfig, PostgresPoolClient } from './postgres-dialect-config.js';
+declare const PRIVATE_RELEASE_METHOD: unique symbol;
+export declare class PostgresDriver implements Driver {
+    #private;
+    constructor(config: PostgresDialectConfig);
+    /**
+     * Initializes the driver.
+     *
+     * After calling this method the driver should be usable and `acquireConnection` etc.
+     * methods should be callable.
+     */
+    init(options?: AbortableOperationOptions): Promise<void>;
+    /**
+     * Acquires a new connection from the pool.
+     */
+    acquireConnection(options?: AbortableOperationOptions): Promise<DatabaseConnection>;
+    /**
+     * Begins a transaction.
+     */
+    beginTransaction(connection: DatabaseConnection, settings: TransactionSettings): Promise<void>;
+    /**
+     * Commits a transaction.
+     */
+    commitTransaction(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Rolls back a transaction.
+     */
+    rollbackTransaction(connection: DatabaseConnection): Promise<void>;
+    savepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    rollbackToSavepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    releaseSavepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    /**
+     * Releases a connection back to the pool.
+     */
+    releaseConnection(connection: PostgresConnection): Promise<void>;
+    /**
+     * Destroys the driver and releases all resources.
+     */
+    destroy(): Promise<void>;
+}
+interface PostgresConnectionOptions {
+    controlClient?: PostgresClientConstructor;
+    cursor: PostgresCursorConstructor | null;
+    poolOptions: object;
+}
+declare class PostgresConnection implements DatabaseConnection {
+    #private;
+    constructor(client: PostgresPoolClient, options: PostgresConnectionOptions);
+    cancelQuery(controlConnectionProvider: ControlConnectionProvider): Promise<void>;
+    collectSessionInfo(): Promise<void>;
+    executeQuery<O>(compiledQuery: CompiledQuery): Promise<QueryResult<O>>;
+    killSession(controlConnectionProvider: ControlConnectionProvider): Promise<void>;
+    streamQuery<O>(compiledQuery: CompiledQuery, chunkSize: number): AsyncIterableIterator<QueryResult<O>>;
+    [PRIVATE_RELEASE_METHOD](): void;
+}
+export {};

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

@@ -0,0 +1,194 @@
+/// <reference types="./postgres-driver.d.ts" />
+import { parseSavepointCommand } from '../../parser/savepoint-parser.js';
+import { CompiledQuery } from '../../query-compiler/compiled-query.js';
+import { isFunction, freeze } from '../../util/object-utils.js';
+import { createQueryId } from '../../util/query-id.js';
+import { extendStackTrace } from '../../util/stack-trace-utils.js';
+const PRIVATE_RELEASE_METHOD = Symbol();
+export class PostgresDriver {
+    #config;
+    #connections = new WeakMap();
+    #pool;
+    constructor(config) {
+        this.#config = freeze({ ...config });
+    }
+    async init(options) {
+        this.#pool = isFunction(this.#config.pool)
+            ? await this.#config.pool(options)
+            : this.#config.pool;
+    }
+    async acquireConnection(options) {
+        const client = await this.#pool.connect();
+        let connection = this.#connections.get(client);
+        if (!connection) {
+            connection = new PostgresConnection(client, {
+                controlClient: this.#config.controlClient || this.#pool.Client,
+                cursor: this.#config.cursor ?? null,
+                poolOptions: this.#pool.options,
+            });
+            this.#connections.set(client, connection);
+            // The driver must take care of calling `onCreateConnection` when a new
+            // connection is created. The `pg` module doesn't provide an async hook
+            // for the connection creation. We need to call the method explicitly.
+            if (this.#config.onCreateConnection) {
+                await this.#config.onCreateConnection(connection, options);
+            }
+        }
+        if (this.#config.onReserveConnection) {
+            await this.#config.onReserveConnection(connection, options);
+        }
+        return connection;
+    }
+    async beginTransaction(connection, settings) {
+        let sql = 'begin';
+        if (settings.isolationLevel || settings.accessMode) {
+            sql = 'start transaction';
+            if (settings.isolationLevel) {
+                sql += ` isolation level ${settings.isolationLevel}`;
+            }
+            if (settings.accessMode) {
+                sql += ` ${settings.accessMode}`;
+            }
+        }
+        await connection.executeQuery(CompiledQuery.raw(sql));
+    }
+    async commitTransaction(connection) {
+        await connection.executeQuery(CompiledQuery.raw('commit'));
+    }
+    async rollbackTransaction(connection) {
+        await connection.executeQuery(CompiledQuery.raw('rollback'));
+    }
+    async savepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('savepoint', savepointName), createQueryId()));
+    }
+    async rollbackToSavepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('rollback to', savepointName), createQueryId()));
+    }
+    async releaseSavepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('release', savepointName), createQueryId()));
+    }
+    async releaseConnection(connection) {
+        connection[PRIVATE_RELEASE_METHOD]();
+    }
+    async destroy() {
+        if (this.#pool) {
+            const pool = this.#pool;
+            this.#pool = undefined;
+            await pool.end();
+        }
+    }
+}
+class PostgresConnection {
+    #client;
+    #options;
+    #queryId;
+    #pid;
+    constructor(client, options) {
+        this.#client = client;
+        this.#options = options;
+    }
+    async cancelQuery(controlConnectionProvider) {
+        return await this.#executeControlQuery(`select pg_cancel_backend(${this.#pid})`, controlConnectionProvider);
+    }
+    async collectSessionInfo() {
+        if (this.#pid) {
+            return;
+        }
+        const { processID } = this.#client;
+        // `processID` is an undocumented member of the `Client` class.
+        // it might not exist in old or future versions of the `pg` driver.
+        // if it does, use it.
+        if (processID) {
+            this.#pid = processID;
+        }
+        else {
+            const { rows: [{ pid }], } = await this.#client.query('select pg_backend_pid() as pid', []);
+            this.#pid = Number(pid);
+        }
+    }
+    async executeQuery(compiledQuery) {
+        try {
+            // this helps ensure we don't cancel the wrong query when aborted.
+            this.#queryId = compiledQuery.queryId;
+            const result = await this.#client.query(compiledQuery.sql, compiledQuery.parameters);
+            const { command, rowCount, rows } = result;
+            return {
+                numAffectedRows: command === 'INSERT' ||
+                    command === 'UPDATE' ||
+                    command === 'DELETE' ||
+                    command === 'MERGE'
+                    ? BigInt(rowCount)
+                    : undefined,
+                rows: rows ?? [],
+            };
+        }
+        catch (err) {
+            throw extendStackTrace(err, new Error());
+        }
+        finally {
+            // this tells cancellation the query is no longer relevant.
+            this.#queryId = undefined;
+        }
+    }
+    async killSession(controlConnectionProvider) {
+        return await this.#executeControlQuery(`select pg_terminate_backend(${this.#pid})`, controlConnectionProvider);
+    }
+    async *streamQuery(compiledQuery, chunkSize) {
+        if (!this.#options.cursor) {
+            throw new Error("`cursor` is not present in your postgres dialect config. It's required to make streaming work in postgres.");
+        }
+        // this helps ensure we don't cancel the wrong query when aborted.
+        this.#queryId = compiledQuery.queryId;
+        const cursor = this.#client.query(new this.#options.cursor(compiledQuery.sql, compiledQuery.parameters.slice()));
+        try {
+            while (true) {
+                const rows = await cursor.read(chunkSize);
+                if (rows.length === 0) {
+                    break;
+                }
+                yield {
+                    rows,
+                };
+            }
+        }
+        finally {
+            await cursor.close();
+            // this tells cancellation the query is no longer relevant.
+            this.#queryId = undefined;
+        }
+    }
+    [PRIVATE_RELEASE_METHOD]() {
+        this.#client.release();
+    }
+    async #executeControlQuery(query, controlConnectionProvider) {
+        if (!this.#queryId) {
+            return;
+        }
+        const { controlClient: Client, poolOptions } = this.#options;
+        const queryIdToCancel = this.#queryId;
+        // we fallback to a pool connection, and execute a SQL query to cancel the
+        // query. this is not ideal, as we might have to wait for an idle connection.
+        if (!Client) {
+            return await controlConnectionProvider(async (controlConnection) => {
+                // by the time we get the connection, another query might have been executed.
+                // we need to ensure we're not canceling the wrong query.
+                if (queryIdToCancel.queryId === this.#queryId?.queryId) {
+                    await controlConnection.executeQuery(CompiledQuery.raw(query, []));
+                }
+            });
+        }
+        const controlClient = new Client({ ...poolOptions });
+        try {
+            await controlClient.connect();
+            // by the time we get the connection, another query might have been executed.
+            // we need to ensure we're not canceling the wrong query.
+            if (queryIdToCancel.queryId !== this.#queryId.queryId) {
+                return;
+            }
+            await controlClient.query(query, []);
+        }
+        finally {
+            controlClient.end();
+        }
+    }
+}