kysely 0.19.10 → 0.19.11

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

@@ -1,5 +1,6 @@
 /// <reference types="./query-executor-base.d.ts" />
 import { freeze } from '../util/object-utils.js';
+import { Deferred } from '../util/deferred.js';
 const NO_PLUGINS = freeze([]);
 export class QueryExecutorBase {
     #plugins;
@@ -34,6 +35,24 @@ export class QueryExecutorBase {
             return this.#transformResult(result, queryId);
         });
     }
+    async *stream(compiledQuery, chunkSize, queryId) {
+        const connectionDefer = new Deferred();
+        const connectionReleaseDefer = new 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/esm/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.
      */

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

@@ -47,17 +47,17 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      *   .addColumn('first_name', 'varchar(50)', (col) => col.notNull())
      *   .addColumn('last_name', 'varchar(255)')
      *   .addColumn('bank_balance', 'numeric(8, 2)')
-     *   .addColumn('data', sql`customtype`)
+     *   .addColumn('data', sql`some_type`)
      *   .addColumn('parent_id', 'integer', (col) =>
      *     col.references('person.id').onDelete('cascade'))
      *   )
      * ```
      *
-     * With this method, it's once again good to remember that Kysely just builds the query
-     * and doesn't provide the same API for all databses. For example, some databases like
-     * older MySQL don't support `references` statement in the column definition. Instead
-     * foreign key constraints need to be defined in at the level of the `create table`
-     * query. See the next example:
+     * With this method, it's once again good to remember that Kysely just builds the
+     * query and doesn't provide the same API for all databses. For example, some
+     * databases like older MySQL don't support the `references` statement in the
+     * column definition. Instead foreign key constraints need to be defined in the
+     * `create table` query. See the next example:
      *
      * ```ts
      *   .addColumn('parent_id', 'integer')

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

@@ -74,17 +74,17 @@ export class CreateTableBuilder {
      *   .addColumn('first_name', 'varchar(50)', (col) => col.notNull())
      *   .addColumn('last_name', 'varchar(255)')
      *   .addColumn('bank_balance', 'numeric(8, 2)')
-     *   .addColumn('data', sql`customtype`)
+     *   .addColumn('data', sql`some_type`)
      *   .addColumn('parent_id', 'integer', (col) =>
      *     col.references('person.id').onDelete('cascade'))
      *   )
      * ```
      *
-     * With this method, it's once again good to remember that Kysely just builds the query
-     * and doesn't provide the same API for all databses. For example, some databases like
-     * older MySQL don't support `references` statement in the column definition. Instead
-     * foreign key constraints need to be defined in at the level of the `create table`
-     * query. See the next example:
+     * With this method, it's once again good to remember that Kysely just builds the
+     * query and doesn't provide the same API for all databses. For example, some
+     * databases like older MySQL don't support the `references` statement in the
+     * column definition. Instead foreign key constraints need to be defined in the
+     * `create table` query. See the next example:
      *
      * ```ts
      *   .addColumn('parent_id', 'integer')

package/dist/esm/schema/create-type-builder.d.ts

@@ -8,6 +8,15 @@ export declare class CreateTypeBuilder implements OperationNodeSource, Compilabl
     #private;
     constructor(props: CreateTypeBuilderProps);
     toOperationNode(): CreateTypeNode;
+    /**
+     * Creates an anum type.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema.createType('species').asEnum(['cat', 'dog', 'frog'])
+     * ```
+     */
     asEnum(values: string[]): CreateTypeBuilder;
     compile(): CompiledQuery;
     execute(): Promise<void>;

package/dist/esm/schema/create-type-builder.js

@@ -10,6 +10,15 @@ export class CreateTypeBuilder {
     toOperationNode() {
         return this.#props.executor.transformQuery(this.#props.createTypeNode, this.#props.queryId);
     }
+    /**
+     * Creates an anum type.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema.createType('species').asEnum(['cat', 'dog', 'frog'])
+     * ```
+     */
     asEnum(values) {
         return new CreateTypeBuilder({
             ...this.#props,

package/dist/esm/util/deferred.d.ts

@@ -0,0 +1,7 @@
+export declare class Deferred<T> {
+    #private;
+    constructor();
+    get promise(): Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+}

package/dist/esm/util/deferred.js

@@ -0,0 +1,25 @@
+/// <reference types="./deferred.d.ts" />
+export class Deferred {
+    #promise;
+    #resolve;
+    #reject;
+    constructor() {
+        this.#promise = new Promise((resolve, reject) => {
+            this.#reject = reject;
+            this.#resolve = resolve;
+        });
+    }
+    get promise() {
+        return this.#promise;
+    }
+    resolve = (value) => {
+        if (this.#resolve) {
+            this.#resolve(value);
+        }
+    };
+    reject = (reason) => {
+        if (this.#reject) {
+            this.#reject(reason);
+        }
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely",
-  "version": "0.19.10",
+  "version": "0.19.11",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",
@@ -44,20 +44,23 @@
   "devDependencies": {
     "@types/better-sqlite3": "^7.5.0",
     "@types/chai": "^4.3.1",
+    "@types/chai-as-promised": "^7.1.5",
     "@types/chai-subset": "^1.3.3",
     "@types/mocha": "^9.1.1",
     "@types/pg": "^8.6.5",
     "better-sqlite3": "^7.5.3",
     "chai": "^4.3.6",
+    "chai-as-promised": "^7.1.1",
     "chai-subset": "^1.6.0",
     "esbuild": "^0.14.47",
     "mocha": "^10.0.0",
     "mysql2": "^2.3.3",
     "pg": "^8.7.3",
+    "pg-cursor": "^2.7.3",
     "playwright": "^1.22.2",
     "prettier": "^2.7.1",
     "tsd": "^0.21.0",
-    "typedoc": "^0.22.18",
+    "typedoc": "^0.23.6",
     "typescript": "4.7.4"
   }
 }