kysely 0.19.10 → 0.19.11

package/README.md

@@ -32,15 +32,21 @@ You can find a more thorough introduction [here](https://www.jakso.me/blog/kysel
 # Table of contents
 
 - [Installation](#installation)
+    - [3rd party dialects](#3rd-party-dialects)
 - [Minimal example](#minimal-example)
 - [Generating types](#generating-types)
 - [Query examples](#query-examples)
-- [Recipes](https://github.com/koskimas/kysely/tree/master/recipes)
+  - [Select queries](#select-queries)
+    - [Stream select query results](#stream-select-query-results)
+  - [Update queries](#update-queries)
+  - [Insert queries](#insert-queries)
+  - [Delete queries](#delete-queries)
 - [Migrations](#migrations)
+    - [PostgreSQL migration example](#postgresql-migration-example)
+    - [MySQL migration example](#mysql-migration-example)
 - [Deno](#deno)
 - [Browser](#browser)
-- [API reference](https://koskimas.github.io/kysely/index.html)
-- [Changelog](https://github.com/koskimas/kysely/releases)
+- [Why not just contribute to knex](#why-not-just-contribute-to-knex)
 
 # Installation
 
@@ -180,6 +186,48 @@ You can find examples of select queries in the documentation of the
 the [where method](https://koskimas.github.io/kysely/classes/SelectQueryBuilder.html#where)
 among other places.
 
+### Stream select query results
+
+*Currently only supported by `postgres` and `mysql` dialects.*
+
+```ts
+import { Pool } from 'pg'
+// or `import * as Cursor from 'pg-cursor'` depending on your tsconfig
+import Cursor from 'pg-cursor'
+import {
+    Kysely,
+    PostgresDialect,
+} from 'kysely'
+
+const db = new Kysely<Database>({
+    // PostgresDialect requires the Cursor dependency
+    dialect: new PostgresDialect({
+        pool: new Pool({
+            host: 'localhost',
+            database: 'kysely_test'
+        }),
+        cursor: Cursor
+    }),
+
+    // MysqlDialect doesn't require any special configuration
+})
+
+async function demo() {
+    for await (const male of db.selectFrom("person")
+        .selectAll()
+        .where("person.gender", "=", "male")
+        .stream()) {
+        console.log(`Hello mr. ${male.first_name}!`)
+
+        if (male.first_name === "John") {
+          // After this line the db connection is released and no more 
+          // rows are streamed from the database to the client
+          break;
+        }
+    }
+}
+```
+
 ## Update queries
 
 See the [set method](https://koskimas.github.io/kysely/classes/UpdateQueryBuilder.html#set) and the

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

@@ -31,9 +31,19 @@ export interface MysqlPool {
     end(callback: (error: unknown) => void): void;
 }
 export interface MysqlPoolConnection {
+    query(sql: string, parameters: ReadonlyArray<unknown>): {
+        stream: <T>(options: MysqlStreamOptions) => MysqlStream<T>;
+    };
     query(sql: string, parameters: ReadonlyArray<unknown>, callback: (error: unknown, result: MysqlQueryResult) => void): void;
     release(): void;
 }
+export interface MysqlStreamOptions {
+    highWaterMark?: number;
+    objectMode?: boolean;
+}
+export interface MysqlStream<T> {
+    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+}
 export interface MysqlOkPacket {
     affectedRows: number;
     insertId: number;

package/dist/cjs/dialect/mysql/mysql-driver.d.ts

@@ -42,6 +42,7 @@ declare class MysqlConnection implements DatabaseConnection {
     #private;
     constructor(rawConnection: MysqlPoolConnection);
     executeQuery<O>(compiledQuery: CompiledQuery): Promise<QueryResult<O>>;
+    streamQuery<O>(compiledQuery: CompiledQuery, chunkSize: number): AsyncIterableIterator<QueryResult<O>>;
     [PRIVATE_RELEASE_METHOD](): void;
 }
 export {};

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

@@ -124,6 +124,31 @@ class MysqlConnection {
             });
         });
     }
+    async *streamQuery(compiledQuery, chunkSize) {
+        const stream = this.#rawConnection
+            .query(compiledQuery.sql, compiledQuery.parameters)
+            .stream({
+            objectMode: true,
+        });
+        try {
+            for await (const row of stream) {
+                yield {
+                    rows: [row],
+                };
+            }
+        }
+        catch (ex) {
+            if (ex &&
+                typeof ex === 'object' &&
+                'code' in ex &&
+                // @ts-ignore
+                ex.code === 'ERR_STREAM_PREMATURE_CLOSE') {
+                // Most likely because of https://github.com/mysqljs/mysql/blob/master/lib/protocol/sequences/Query.js#L220
+                return;
+            }
+            throw ex;
+        }
+    }
     [PRIVATE_RELEASE_METHOD]() {
         this.#rawConnection.release();
     }

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

@@ -1,4 +1,14 @@
 import { DatabaseConnection } from '../../driver/database-connection.js';
+export declare type PostgresCursorConstructor = new <T>(sql: string, parameters: readonly unknown[]) => PostgresCursor<T>;
+export declare type PostgresCursor<T> = {
+    state: 'initialized' | 'idle' | 'submitted' | 'busy';
+    read: (rowsCount: number) => Promise<T[]>;
+} | {
+    state: 'done';
+} | {
+    state: 'error';
+    _error: Error;
+};
 /**
  * Config for the PostgreSQL dialect.
  */
@@ -11,6 +21,19 @@ export interface PostgresDialectConfig {
      * https://node-postgres.com/api/pool
      */
     pool: PostgresPool | (() => Promise<PostgresPool>);
+    /**
+     * https://github.com/brianc/node-postgres/tree/master/packages/pg-cursor
+     * ```ts
+     * import Cursor from 'pg-cursor'
+     * // or
+     * import * as Cursor from 'pg-cursor'
+     *
+     * new PostgresDialect({
+     *  cursor: Cursor
+     * })
+     * ```
+     */
+    cursor?: PostgresCursorConstructor;
     /**
      * Called once for each created connection.
      */
@@ -30,6 +53,7 @@ export interface PostgresPool {
 }
 export interface PostgresPoolClient {
     query<R>(sql: string, parameters: ReadonlyArray<unknown>): Promise<PostgresQueryResult<R>>;
+    query<R>(cursor: PostgresCursor<R>): PostgresCursor<R>;
     release(): void;
 }
 export interface PostgresQueryResult<R> {
@@ -37,3 +61,8 @@ export interface PostgresQueryResult<R> {
     rowCount: number;
     rows: R[];
 }
+export interface PostgresStreamOptions {
+}
+export interface PostgresStream<T> {
+    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+}

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

@@ -1,7 +1,7 @@
 import { DatabaseConnection, QueryResult } from '../../driver/database-connection.js';
 import { Driver, TransactionSettings } from '../../driver/driver.js';
 import { CompiledQuery } from '../../query-compiler/compiled-query.js';
-import { PostgresDialectConfig, PostgresPoolClient } from './postgres-dialect-config.js';
+import { PostgresCursorConstructor, PostgresDialectConfig, PostgresPoolClient } from './postgres-dialect-config.js';
 declare const PRIVATE_RELEASE_METHOD: unique symbol;
 export declare class PostgresDriver implements Driver {
     #private;
@@ -38,10 +38,14 @@ export declare class PostgresDriver implements Driver {
      */
     destroy(): Promise<void>;
 }
+interface PostgresConnectionOptions {
+    cursor: PostgresCursorConstructor | null;
+}
 declare class PostgresConnection implements DatabaseConnection {
     #private;
-    constructor(client: PostgresPoolClient);
+    constructor(client: PostgresPoolClient, options: PostgresConnectionOptions);
     executeQuery<O>(compiledQuery: CompiledQuery): Promise<QueryResult<O>>;
+    streamQuery<O>(compiledQuery: CompiledQuery, chunkSize: number): AsyncIterableIterator<QueryResult<O>>;
     [PRIVATE_RELEASE_METHOD](): void;
 }
 export {};

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

@@ -21,7 +21,9 @@ class PostgresDriver {
         const client = await this.#pool.connect();
         let connection = this.#connections.get(client);
         if (!connection) {
-            connection = new PostgresConnection(client);
+            connection = new PostgresConnection(client, {
+                cursor: this.#config.cursor ?? null,
+            });
             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
@@ -60,8 +62,10 @@ class PostgresDriver {
 exports.PostgresDriver = PostgresDriver;
 class PostgresConnection {
     #client;
-    constructor(client) {
+    #options;
+    constructor(client, options) {
         this.#client = client;
+        this.#options = options;
     }
     async executeQuery(compiledQuery) {
         try {
@@ -82,6 +86,24 @@ class PostgresConnection {
             throw (0, stack_trace_utils_js_1.extendStackTrace)(err, new Error());
         }
     }
+    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.");
+        }
+        const cursor = this.#client.query(new this.#options.cursor(compiledQuery.sql, compiledQuery.parameters));
+        while (true) {
+            if (cursor.state === 'done') {
+                break;
+            }
+            if (cursor.state === 'error') {
+                throw cursor._error;
+            }
+            const rows = await cursor.read(chunkSize);
+            yield {
+                rows,
+            };
+        }
+    }
     [PRIVATE_RELEASE_METHOD]() {
         this.#client.release();
     }

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

@@ -69,6 +69,9 @@ class SqliteConnection {
             });
         }
     }
+    async *streamQuery() {
+        throw new Error("Sqlite driver doesn't support streaming");
+    }
 }
 class ConnectionMutex {
     #promise;

package/dist/cjs/driver/database-connection.d.ts

@@ -6,6 +6,7 @@ import { CompiledQuery } from '../query-compiler/compiled-query.js';
  */
 export interface DatabaseConnection {
     executeQuery<R>(compiledQuery: CompiledQuery): Promise<QueryResult<R>>;
+    streamQuery<R>(compiledQuery: CompiledQuery, chunkSize?: number): AsyncIterableIterator<QueryResult<R>>;
 }
 export interface QueryResult<O> {
     /**

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

@@ -67,4 +67,7 @@ class DummyConnection {
             rows: [],
         };
     }
+    async *streamQuery() {
+        // Nothing to do here.
+    }
 }

package/dist/cjs/index.d.ts

@@ -25,7 +25,9 @@ export * from './query-compiler/default-query-compiler.js';
 export * from './query-compiler/compiled-query.js';
 export * from './schema/schema.js';
 export * from './schema/create-table-builder.js';
+export * from './schema/create-type-builder.js';
 export * from './schema/drop-table-builder.js';
+export * from './schema/drop-type-builder.js';
 export * from './schema/create-index-builder.js';
 export * from './schema/drop-index-builder.js';
 export * from './schema/create-schema-builder.js';
@@ -87,6 +89,7 @@ export * from './operation-node/constraint-node.js';
 export * from './operation-node/create-index-node.js';
 export * from './operation-node/create-schema-node.js';
 export * from './operation-node/create-table-node.js';
+export * from './operation-node/create-type-node.js';
 export * from './operation-node/create-view-node.js';
 export * from './operation-node/data-type-node.js';
 export * from './operation-node/default-value-node.js';
@@ -96,6 +99,7 @@ export * from './operation-node/drop-constraint-node.js';
 export * from './operation-node/drop-index-node.js';
 export * from './operation-node/drop-schema-node.js';
 export * from './operation-node/drop-table-node.js';
+export * from './operation-node/drop-type-node.js';
 export * from './operation-node/drop-view-node.js';
 export * from './operation-node/filter-node.js';
 export * from './operation-node/foreign-key-constraint-node.js';

package/dist/cjs/index.js

@@ -41,7 +41,9 @@ __exportStar(require("./query-compiler/default-query-compiler.js"), exports);
 __exportStar(require("./query-compiler/compiled-query.js"), exports);
 __exportStar(require("./schema/schema.js"), exports);
 __exportStar(require("./schema/create-table-builder.js"), exports);
+__exportStar(require("./schema/create-type-builder.js"), exports);
 __exportStar(require("./schema/drop-table-builder.js"), exports);
+__exportStar(require("./schema/drop-type-builder.js"), exports);
 __exportStar(require("./schema/create-index-builder.js"), exports);
 __exportStar(require("./schema/drop-index-builder.js"), exports);
 __exportStar(require("./schema/create-schema-builder.js"), exports);
@@ -103,6 +105,7 @@ __exportStar(require("./operation-node/constraint-node.js"), exports);
 __exportStar(require("./operation-node/create-index-node.js"), exports);
 __exportStar(require("./operation-node/create-schema-node.js"), exports);
 __exportStar(require("./operation-node/create-table-node.js"), exports);
+__exportStar(require("./operation-node/create-type-node.js"), exports);
 __exportStar(require("./operation-node/create-view-node.js"), exports);
 __exportStar(require("./operation-node/data-type-node.js"), exports);
 __exportStar(require("./operation-node/default-value-node.js"), exports);
@@ -112,6 +115,7 @@ __exportStar(require("./operation-node/drop-constraint-node.js"), exports);
 __exportStar(require("./operation-node/drop-index-node.js"), exports);
 __exportStar(require("./operation-node/drop-schema-node.js"), exports);
 __exportStar(require("./operation-node/drop-table-node.js"), exports);
+__exportStar(require("./operation-node/drop-type-node.js"), exports);
 __exportStar(require("./operation-node/drop-view-node.js"), exports);
 __exportStar(require("./operation-node/filter-node.js"), exports);
 __exportStar(require("./operation-node/foreign-key-constraint-node.js"), exports);

package/dist/cjs/operation-node/data-type-node.d.ts

@@ -1,5 +1,5 @@
 import { OperationNode } from './operation-node.js';
-export declare type ColumnDataType = 'varchar' | `varchar(${number})` | 'text' | 'integer' | 'int2' | 'int4' | 'int8' | 'bigint' | 'boolean' | 'real' | 'double precision' | 'float4' | 'float8' | 'decimal' | `decimal(${number}, ${number})` | 'numeric' | `numeric(${number}, ${number})` | 'binary' | 'date' | 'datetime' | 'time' | 'timetz' | 'timestamp' | 'timestamptz' | 'serial' | 'bigserial' | 'uuid' | 'json' | 'jsonb' | 'blob';
+export declare type ColumnDataType = 'varchar' | `varchar(${number})` | 'text' | 'integer' | 'int2' | 'int4' | 'int8' | 'bigint' | 'boolean' | 'real' | 'double precision' | 'float4' | 'float8' | 'decimal' | `decimal(${number}, ${number})` | 'numeric' | `numeric(${number}, ${number})` | 'binary' | 'date' | 'datetime' | `datetime(${number})` | 'time' | `time(${number})` | 'timetz' | `timetz(${number})` | 'timestamp' | `timestamp(${number})` | 'timestamptz' | `timestamptz(${number})` | 'serial' | 'bigserial' | 'uuid' | 'json' | 'jsonb' | 'blob';
 export declare type DataTypeParams = Omit<DataTypeNode, 'kind' | 'dataType'>;
 export interface DataTypeNode extends OperationNode {
     readonly kind: 'DataTypeNode';

package/dist/cjs/operation-node/insert-query-node.d.ts

@@ -19,12 +19,13 @@ export interface InsertQueryNode extends OperationNode {
     readonly onDuplicateKey?: OnDuplicateKeyNode;
     readonly with?: WithNode;
     readonly ignore?: boolean;
+    readonly replace?: boolean;
 }
 /**
  * @internal
  */
 export declare const InsertQueryNode: Readonly<{
     is(node: OperationNode): node is InsertQueryNode;
-    create(into: TableNode, withNode?: WithNode): InsertQueryNode;
+    create(into: TableNode, withNode?: WithNode, replace?: boolean): InsertQueryNode;
     cloneWith(insertQuery: InsertQueryNode, props: InsertQueryNodeProps): InsertQueryNode;
 }>;

package/dist/cjs/operation-node/insert-query-node.js

@@ -9,11 +9,12 @@ exports.InsertQueryNode = (0, object_utils_js_1.freeze)({
     is(node) {
         return node.kind === 'InsertQueryNode';
     },
-    create(into, withNode) {
+    create(into, withNode, replace) {
         return (0, object_utils_js_1.freeze)({
             kind: 'InsertQueryNode',
             into,
             ...(withNode && { with: withNode }),
+            replace,
         });
     },
     cloneWith(insertQuery, props) {

package/dist/cjs/operation-node/operation-node-transformer.js

@@ -244,6 +244,7 @@ class OperationNodeTransformer {
             onDuplicateKey: this.transformNode(node.onDuplicateKey),
             with: this.transformNode(node.with),
             ignore: node.ignore,
+            replace: node.replace,
         });
     }
     transformValues(node) {

package/dist/cjs/query-builder/insert-query-builder.d.ts

@@ -43,7 +43,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *
      * Insert a row into `person`:
      * ```ts
-     * const id = await db
+     * const result = await db
      *   .insertInto('person')
      *   .values({
      *     first_name: 'Jennifer',

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

@@ -1343,6 +1343,33 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * error.
      */
     executeTakeFirstOrThrow(errorConstructor?: NoResultErrorConstructor): Promise<O>;
+    /**
+     * Executes the query and streams the rows.
+     *
+     * The optional argument `chunkSize` defines how many rows to fetch from the database
+     * at a time. It only affects some dialects like PostgreSQL that support it.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const stream = db.
+     *   .selectFrom('person')
+     *   .select(['first_name', 'last_name'])
+     *   .where('gender', '=', 'other')
+     *   .stream()
+     *
+     * for await (const person of stream) {
+     *   console.log(person.first_name)
+     *
+     *   if (person.last_name === 'Something') {
+     *     // Breaking or returning before the stream has ended will release
+     *     // the database connection and invalidate the stream.
+     *     break
+     *   }
+     * }
+     * ```
+     */
+    stream(chunkSize?: number): AsyncIterableIterator<O>;
 }
 export interface SelectQueryBuilderProps {
     readonly queryId: QueryId;

package/dist/cjs/query-builder/select-query-builder.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AliasedQueryBuilder = exports.SelectQueryBuilder = void 0;
 const alias_node_js_1 = require("../operation-node/alias-node.js");
+const select_modifier_node_js_1 = require("../operation-node/select-modifier-node.js");
 const join_parser_js_1 = require("../parser/join-parser.js");
 const select_parser_js_1 = require("../parser/select-parser.js");
 const filter_parser_js_1 = require("../parser/filter-parser.js");
@@ -16,7 +17,6 @@ const group_by_parser_js_1 = require("../parser/group-by-parser.js");
 const union_parser_js_1 = require("../parser/union-parser.js");
 const no_result_error_js_1 = require("./no-result-error.js");
 const identifier_node_js_1 = require("../operation-node/identifier-node.js");
-const select_modifier_node_js_1 = require("../operation-node/select-modifier-node.js");
 class SelectQueryBuilder {
     #props;
     constructor(props) {
@@ -630,7 +630,6 @@ class SelectQueryBuilder {
      */
     async execute() {
         const compildQuery = this.compile();
-        const query = compildQuery.query;
         const result = await this.#props.executor.executeQuery(compildQuery, this.#props.queryId);
         return result.rows;
     }
@@ -657,6 +656,39 @@ class SelectQueryBuilder {
         }
         return result;
     }
+    /**
+     * Executes the query and streams the rows.
+     *
+     * The optional argument `chunkSize` defines how many rows to fetch from the database
+     * at a time. It only affects some dialects like PostgreSQL that support it.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const stream = db.
+     *   .selectFrom('person')
+     *   .select(['first_name', 'last_name'])
+     *   .where('gender', '=', 'other')
+     *   .stream()
+     *
+     * for await (const person of stream) {
+     *   console.log(person.first_name)
+     *
+     *   if (person.last_name === 'Something') {
+     *     // Breaking or returning before the stream has ended will release
+     *     // the database connection and invalidate the stream.
+     *     break
+     *   }
+     * }
+     * ```
+     */
+    async *stream(chunkSize = 100) {
+        const compildQuery = this.compile();
+        const stream = this.#props.executor.stream(compildQuery, chunkSize, this.#props.queryId);
+        for await (const item of stream) {
+            yield* item.rows;
+        }
+    }
 }
 exports.SelectQueryBuilder = SelectQueryBuilder;
 (0, prevent_await_js_1.preventAwait)(SelectQueryBuilder, "don't await SelectQueryBuilder instances directly. To execute the query you need to call `execute` or `executeTakeFirst`.");

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

@@ -134,7 +134,7 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             this.visitNode(node.with);
             this.append(' ');
         }
-        this.append('insert');
+        this.append(node.replace ? 'replace' : 'insert');
         if (node.ignore) {
             this.append(' ignore');
         }

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

@@ -161,6 +161,33 @@ export declare class QueryCreator<DB> {
      * ```
      */
     insertInto<T extends keyof DB & string>(table: T): InsertQueryBuilder<DB, T, InsertResult>;
+    /**
+     * Creates a replace query.
+     *
+     * A MySQL-only statement similar to {@link InsertQueryBuilder.onDuplicateKeyUpdate}
+     * that deletes and inserts values on collision instead of updating existing rows.
+     *
+     * The return value of this query is an instance of {@link InsertResult}. {@link InsertResult}
+     * has the {@link InsertResult.insertId | insertId} field that holds the auto incremented id of
+     * the inserted row if the db returned one.
+     *
+     * See the {@link InsertQueryBuilder.values | values} method for more info and examples.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db
+     *   .replaceInto('person')
+     *   .values({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   })
+     *   .executeTakeFirst()
+     *
+     * console.log(result.insertId)
+     * ```
+     */
+    replaceInto<T extends keyof DB & string>(table: T): InsertQueryBuilder<DB, T, InsertResult>;
     /**
      * Creates a delete query.
      *

package/dist/cjs/query-creator.js

@@ -72,6 +72,39 @@ class QueryCreator {
             queryNode: insert_query_node_js_1.InsertQueryNode.create((0, table_parser_js_1.parseTable)(table), this.#props.withNode),
         });
     }
+    /**
+     * Creates a replace query.
+     *
+     * A MySQL-only statement similar to {@link InsertQueryBuilder.onDuplicateKeyUpdate}
+     * that deletes and inserts values on collision instead of updating existing rows.
+     *
+     * The return value of this query is an instance of {@link InsertResult}. {@link InsertResult}
+     * has the {@link InsertResult.insertId | insertId} field that holds the auto incremented id of
+     * the inserted row if the db returned one.
+     *
+     * See the {@link InsertQueryBuilder.values | values} method for more info and examples.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db
+     *   .replaceInto('person')
+     *   .values({
+     *     first_name: 'Jennifer',
+     *     last_name: 'Aniston'
+     *   })
+     *   .executeTakeFirst()
+     *
+     * console.log(result.insertId)
+     * ```
+     */
+    replaceInto(table) {
+        return new insert_query_builder_js_1.InsertQueryBuilder({
+            queryId: (0, query_id_js_1.createQueryId)(),
+            executor: this.#props.executor,
+            queryNode: insert_query_node_js_1.InsertQueryNode.create((0, table_parser_js_1.parseTable)(table), this.#props.withNode, true),
+        });
+    }
     /**
      * Creates a delete query.
      *

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

@@ -36,6 +36,12 @@ export declare abstract class QueryExecutorBase implements QueryExecutor {
      * `transformResult` method.
      */
     executeQuery<R>(compiledQuery: CompiledQuery, queryId: QueryId): Promise<QueryResult<R>>;
+    /**
+     * Executes a compiled query and runs the result through all plugins'
+     * `transformResult` method. Results are streamead instead of loaded
+     * at once.
+     */
+    stream<R>(compiledQuery: CompiledQuery, chunkSize: number, queryId: QueryId): AsyncIterableIterator<QueryResult<R>>;
     /**
      * Returns a copy of this executor with a new connection provider.
      */

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryExecutorBase = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
+const deferred_js_1 = require("../util/deferred.js");
 const NO_PLUGINS = (0, object_utils_js_1.freeze)([]);
 class QueryExecutorBase {
     #plugins;
@@ -36,6 +37,24 @@ class QueryExecutorBase {
             return this.#transformResult(result, queryId);
         });
     }
+    async *stream(compiledQuery, chunkSize, queryId) {
+        const connectionDefer = new deferred_js_1.Deferred();
+        const connectionReleaseDefer = new deferred_js_1.Deferred();
+        this.provideConnection(async (connection) => {
+            connectionDefer.resolve(connection);
+            // Lets wait until we don't need connection before returning here (returning releases connection)
+            return await connectionReleaseDefer.promise;
+        }).catch((ex) => connectionDefer.reject(ex));
+        const connection = await connectionDefer.promise;
+        try {
+            for await (const result of connection.streamQuery(compiledQuery, chunkSize)) {
+                yield await this.#transformResult(result, queryId);
+            }
+        }
+        finally {
+            connectionReleaseDefer.resolve();
+        }
+    }
     async #transformResult(result, queryId) {
         for (const plugin of this.#plugins) {
             result = await plugin.transformResult({ result, queryId });

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

@@ -37,6 +37,17 @@ export interface QueryExecutor extends ConnectionProvider {
      * `transformResult` method.
      */
     executeQuery<R>(compiledQuery: CompiledQuery, queryId: QueryId): Promise<QueryResult<R>>;
+    /**
+     * Executes a compiled query and runs the result through all plugins'
+     * `transformResult` method. Results are streamead instead of loaded
+     * at once.
+     */
+    stream<R>(compiledQuery: CompiledQuery, 
+    /**
+     * How many rows should be pulled from the database at once. Supported
+     * only by the postgres driver.
+     */
+    chunkSize: number, queryId: QueryId): AsyncIterableIterator<QueryResult<R>>;
     /**
      * Returns a copy of this executor with a new connection provider.
      */