kysely 0.27.3 → 0.27.5

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

@@ -11,24 +11,22 @@ export class MssqlDriver {
     #pool;
     constructor(config) {
         this.#config = freeze({ ...config });
-        this.#pool = new this.#config.tarn.Pool({
-            ...this.#config.tarn.options,
+        const { tarn, tedious } = this.#config;
+        const { validateConnections, ...poolOptions } = tarn.options;
+        this.#pool = new tarn.Pool({
+            ...poolOptions,
             create: async () => {
-                const connection = await this.#config.tedious.connectionFactory();
-                await new Promise((resolve, reject) => connection.connect((error) => {
-                    if (error)
-                        reject(error);
-                    else
-                        resolve(undefined);
-                }));
-                return new MssqlConnection(connection, this.#config.tedious);
+                const connection = await tedious.connectionFactory();
+                return await new MssqlConnection(connection, tedious).connect();
             },
             destroy: async (connection) => {
                 await connection[PRIVATE_DESTROY_METHOD]();
             },
             // @ts-ignore `tarn` accepts a function that returns a promise here, but
             // the types are not aligned and it type errors.
-            validate: (connection) => connection.validate(),
+            validate: validateConnections === false
+                ? undefined
+                : (connection) => connection.validate(),
         });
     }
     async init() {
@@ -60,6 +58,10 @@ class MssqlConnection {
     constructor(connection, tedious) {
         this.#connection = connection;
         this.#tedious = tedious;
+        this.#connection.on('error', console.error);
+        this.#connection.once('end', () => {
+            this.#connection.off('error', console.error);
+        });
     }
     async beginTransaction(settings) {
         const { isolationLevel } = settings;
@@ -80,10 +82,28 @@ class MssqlConnection {
                 resolve(undefined);
         }));
     }
+    async connect() {
+        await new Promise((resolve, reject) => {
+            this.#connection.connect((error) => {
+                if (error) {
+                    console.error(error);
+                    reject(error);
+                }
+                else {
+                    resolve(undefined);
+                }
+            });
+        });
+        return this;
+    }
     async executeQuery(compiledQuery) {
         try {
             const deferred = new Deferred();
-            const request = new MssqlRequest(this.#tedious, compiledQuery, deferred);
+            const request = new MssqlRequest({
+                compiledQuery,
+                tedious: this.#tedious,
+                onDone: deferred,
+            });
             this.#connection.execSql(request.request);
             const { rowCount, rows } = await deferred.promise;
             return {
@@ -107,11 +127,15 @@ class MssqlConnection {
         if (!Number.isInteger(chunkSize) || chunkSize <= 0) {
             throw new Error('chunkSize must be a positive integer');
         }
-        const request = new MssqlRequest(this.#tedious, compiledQuery);
+        const request = new MssqlRequest({
+            compiledQuery,
+            streamChunkSize: chunkSize,
+            tedious: this.#tedious,
+        });
         this.#connection.execSql(request.request);
         try {
             while (true) {
-                const rows = await request.readChunk(chunkSize);
+                const rows = await request.readChunk();
                 if (rows.length === 0) {
                     break;
                 }
@@ -122,13 +146,17 @@ class MssqlConnection {
             }
         }
         finally {
-            this.#connection.cancel();
+            await this.#cancelRequest(request);
         }
     }
     async validate() {
         try {
             const deferred = new Deferred();
-            const request = new MssqlRequest(this.#tedious, CompiledQuery.raw('select 1'), deferred);
+            const request = new MssqlRequest({
+                compiledQuery: CompiledQuery.raw('select 1'),
+                onDone: deferred,
+                tedious: this.#tedious,
+            });
             this.#connection.execSql(request.request);
             await deferred.promise;
             return true;
@@ -152,16 +180,29 @@ class MssqlConnection {
         }
         return tediousIsolationLevel;
     }
-    [PRIVATE_RELEASE_METHOD]() {
-        return new Promise((resolve, reject) => {
-            this.#connection.reset((error) => {
-                if (error)
-                    reject(error);
-                else
-                    resolve(undefined);
-            });
+    #cancelRequest(request) {
+        return new Promise((resolve) => {
+            request.request.once('requestCompleted', resolve);
+            const wasCanceled = this.#connection.cancel();
+            if (!wasCanceled) {
+                request.request.off('requestCompleted', resolve);
+                resolve(undefined);
+            }
         });
     }
+    async [PRIVATE_RELEASE_METHOD]() {
+        // TODO: flip this to `if (!this.#tedious.resetConnectionOnRelease) {}` in a future PR.
+        if (this.#tedious.resetConnectionOnRelease !== false) {
+            await new Promise((resolve, reject) => {
+                this.#connection.reset((error) => {
+                    if (error)
+                        reject(error);
+                    else
+                        resolve(undefined);
+                });
+            });
+        }
+    }
     [PRIVATE_DESTROY_METHOD]() {
         return new Promise((resolve) => {
             this.#connection.once('end', () => {
@@ -174,42 +215,62 @@ class MssqlConnection {
 class MssqlRequest {
     #request;
     #rows;
+    #streamChunkSize;
+    #subscribers;
     #tedious;
-    #completed;
     #error;
     #rowCount;
-    constructor(tedious, compiledQuery, onDone) {
-        this.#completed = false;
+    constructor(props) {
+        const { compiledQuery, onDone, streamChunkSize, tedious } = props;
         this.#rows = [];
+        this.#streamChunkSize = streamChunkSize;
+        this.#subscribers = {};
         this.#tedious = tedious;
-        const { parameters, sql } = compiledQuery;
-        this.#request = new this.#tedious.Request(sql, (err, rowCount) => {
+        if (onDone) {
+            const subscriptionKey = 'onDone';
+            this.#subscribers[subscriptionKey] = (event, error) => {
+                if (event === 'chunkReady') {
+                    return;
+                }
+                delete this.#subscribers[subscriptionKey];
+                if (event === 'error') {
+                    onDone.reject(error);
+                }
+                else {
+                    onDone.resolve({
+                        rowCount: this.#rowCount,
+                        rows: this.#rows,
+                    });
+                }
+            };
+        }
+        this.#request = new this.#tedious.Request(compiledQuery.sql, (err, rowCount) => {
             if (err) {
-                this.#error = err instanceof AggregateError ? err.errors : err;
-                onDone?.reject(this.#error);
+                Object.values(this.#subscribers).forEach((subscriber) => subscriber('error', err instanceof AggregateError ? err.errors : err));
             }
             else {
                 this.#rowCount = rowCount;
             }
         });
-        this.#addParametersToRequest(parameters);
-        this.#attachListeners(onDone);
+        this.#addParametersToRequest(compiledQuery.parameters);
+        this.#attachListeners();
     }
     get request() {
         return this.#request;
     }
-    readChunk(chunkSize) {
+    readChunk() {
+        const subscriptionKey = this.readChunk.name;
         return new Promise((resolve, reject) => {
-            const interval = setInterval(() => {
-                if (this.#error) {
-                    clearInterval(interval);
-                    reject(this.#error);
+            this.#subscribers[subscriptionKey] = (event, error) => {
+                delete this.#subscribers[subscriptionKey];
+                if (event === 'error') {
+                    reject(error);
                 }
-                else if (this.#completed || this.#rows.length >= chunkSize) {
-                    clearInterval(interval);
-                    resolve(this.#rows.splice(0, chunkSize));
+                else {
+                    resolve(this.#rows.splice(0, this.#streamChunkSize));
                 }
-            }, 0);
+            };
+            this.#request.resume();
         });
     }
     #addParametersToRequest(parameters) {
@@ -218,22 +279,27 @@ class MssqlRequest {
             this.#request.addParameter(String(i + 1), this.#getTediousDataType(parameter), parameter);
         }
     }
-    #attachListeners(onDone) {
+    #attachListeners() {
+        const pauseAndEmitChunkReady = this.#streamChunkSize
+            ? () => {
+                if (this.#streamChunkSize <= this.#rows.length) {
+                    this.#request.pause();
+                    Object.values(this.#subscribers).forEach((subscriber) => subscriber('chunkReady'));
+                }
+            }
+            : () => { };
         const rowListener = (columns) => {
             const row = {};
             for (const column of columns) {
                 row[column.metadata.colName] = column.value;
             }
             this.#rows.push(row);
+            pauseAndEmitChunkReady();
         };
         this.#request.on('row', rowListener);
         this.#request.once('requestCompleted', () => {
-            this.#completed = true;
+            Object.values(this.#subscribers).forEach((subscriber) => subscriber('completed'));
             this.#request.off('row', rowListener);
-            onDone?.resolve({
-                rowCount: this.#rowCount,
-                rows: this.#rows,
-            });
         });
     }
     #getTediousDataType(value) {

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

@@ -33,8 +33,13 @@ export declare class MysqlAdapter extends DialectAdapterBase {
      * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
      *
      * ```ts
-     * {
-     *   async acquireMigrationLock(db, options): Promise<void> {
+     * 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
@@ -50,6 +55,10 @@ export declare class MysqlAdapter extends DialectAdapterBase {
      *       .forUpdate()
      *       .execute()
      *   }
+     *
+     *   override async releaseMigrationLock() {
+     *     // noop
+     *   }
      * }
      * ```
      *

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

@@ -17,6 +17,10 @@ export interface MysqlDialectConfig {
      * Called once for each created connection.
      */
     onCreateConnection?: (connection: DatabaseConnection) => Promise<void>;
+    /**
+     * Called every time a connection is acquired from the connection pool.
+     */
+    onReserveConnection?: (connection: DatabaseConnection) => Promise<void>;
 }
 /**
  * This interface is the subset of mysql2 driver's `Pool` class that

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

@@ -28,6 +28,9 @@ export class MysqlDriver {
                 await this.#config.onCreateConnection(connection);
             }
         }
+        if (this.#config?.onReserveConnection) {
+            await this.#config.onReserveConnection(connection);
+        }
         return connection;
     }
     async #acquireConnection() {

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

@@ -33,8 +33,13 @@ export declare class PostgresAdapter extends DialectAdapterBase {
      * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
      *
      * ```ts
-     * {
-     *   async acquireMigrationLock(db, options): Promise<void> {
+     * 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
@@ -50,6 +55,10 @@ export declare class PostgresAdapter extends DialectAdapterBase {
      *       .forUpdate()
      *       .execute()
      *   }
+     *
+     *   override async releaseMigrationLock() {
+     *     // noop
+     *   }
      * }
      * ```
      *

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

@@ -13,13 +13,16 @@ export interface PostgresDialectConfig {
     pool: PostgresPool | (() => Promise<PostgresPool>);
     /**
      * 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'
+     * // or import * as Cursor from 'pg-cursor'
      *
      * new PostgresDialect({
-     *  cursor: Cursor
+     *  cursor: Cursor,
+     *  pool: new Pool('postgres://localhost:5432/mydb')
      * })
      * ```
      */
@@ -28,6 +31,10 @@ export interface PostgresDialectConfig {
      * Called once for each created connection.
      */
     onCreateConnection?: (connection: DatabaseConnection) => Promise<void>;
+    /**
+     * Called every time a connection is acquired from the pool.
+     */
+    onReserveConnection?: (connection: DatabaseConnection) => Promise<void>;
 }
 /**
  * This interface is the subset of pg driver's `Pool` class that

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

@@ -30,6 +30,9 @@ export class PostgresDriver {
                 await this.#config.onCreateConnection(connection);
             }
         }
+        if (this.#config.onReserveConnection) {
+            await this.#config.onReserveConnection(connection);
+        }
         return connection;
     }
     async beginTransaction(connection, settings) {

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

@@ -49,7 +49,11 @@ export class PostgresIntrospector {
                 .as('auto_incrementing'),
         ])
             // r == normal table
-            .where((eb) => eb.or([eb('c.relkind', '=', 'r'), eb('c.relkind', '=', 'v')]))
+            .where((eb) => eb.or([
+            eb('c.relkind', '=', 'r'),
+            eb('c.relkind', '=', 'v'),
+            eb('c.relkind', '=', 'p'),
+        ]))
             .where('ns.nspname', '!~', '^pg_')
             .where('ns.nspname', '!=', 'information_schema')
             // No system columns

package/dist/esm/dialect/sqlite/sqlite-adapter.d.ts

@@ -33,8 +33,13 @@ export declare class SqliteAdapter extends DialectAdapterBase {
      * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
      *
      * ```ts
-     * {
-     *   async acquireMigrationLock(db, options): Promise<void> {
+     * 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
@@ -50,6 +55,10 @@ export declare class SqliteAdapter extends DialectAdapterBase {
      *       .forUpdate()
      *       .execute()
      *   }
+     *
+     *   override async releaseMigrationLock() {
+     *     // noop
+     *   }
      * }
      * ```
      *

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

@@ -21,7 +21,9 @@ export interface QueryResult<O> {
     /**
      * This is defined for update queries and contains the number of rows
      * the query changed.
-     * This is optional and only provided by some drivers like node-mysql2.
+     *
+     * This is **optional** and only provided in dialects such as MySQL.
+     * You would probably use {@link numAffectedRows} in most cases.
      */
     readonly numChangedRows?: bigint;
     /**

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

@@ -10,20 +10,21 @@ import { Driver } from './driver.js';
  * This example creates a Kysely instance for building postgres queries:
  *
  * ```ts
+ * import {
+ *   DummyDriver,
+ *   Kysely,
+ *   PostgresAdapter,
+ *   PostgresIntrospector,
+ *   PostgresQueryCompiler
+ * } from 'kysely'
+ * import type { Database } from 'type-editor' // imaginary module
+ *
  * 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()
- *     },
+ *     createAdapter: () => new PostgresAdapter(),
+ *     createDriver: () => new DummyDriver(),
+ *     createIntrospector: (db: Kysely<any>) => new PostgresIntrospector(db),
+ *     createQueryCompiler: () => new PostgresQueryCompiler(),
  *   },
  * })
  * ```

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

@@ -9,20 +9,21 @@
  * This example creates a Kysely instance for building postgres queries:
  *
  * ```ts
+ * import {
+ *   DummyDriver,
+ *   Kysely,
+ *   PostgresAdapter,
+ *   PostgresIntrospector,
+ *   PostgresQueryCompiler
+ * } from 'kysely'
+ * import type { Database } from 'type-editor' // imaginary module
+ *
  * 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()
- *     },
+ *     createAdapter: () => new PostgresAdapter(),
+ *     createDriver: () => new DummyDriver(),
+ *     createIntrospector: (db: Kysely<any>) => new PostgresIntrospector(db),
+ *     createQueryCompiler: () => new PostgresQueryCompiler(),
  *   },
  * })
  * ```

package/dist/esm/dynamic/dynamic.d.ts

@@ -5,7 +5,7 @@ export declare class DynamicModule {
      *
      * Kysely is built in a way that by default you can't refer to tables or columns
      * that are not actually visible in the current query and context. This is all
-     * done by typescript at compile time, which means that you need to know the
+     * done by TypeScript at compile time, which means that you need to know the
      * columns and tables at compile time. This is not always the case of course.
      *
      * This method is meant to be used in those cases where the column names
@@ -61,11 +61,11 @@ export declare class DynamicModule {
      * const { ref } = db.dynamic
      *
      * // Some column name provided by the user. Value not known at compile time.
-     * const columnFromUserInput = req.query.select;
+     * const columnFromUserInput: PossibleColumns = 'birthdate';
      *
      * // A type that lists all possible values `columnFromUserInput` can have.
      * // You can use `keyof Person` if any column of an interface is allowed.
-     * type PossibleColumns = 'last_name' | 'first_name' | 'birth_date'
+     * type PossibleColumns = 'last_name' | 'first_name' | 'birthdate'
      *
      * const [person] = await db.selectFrom('person')
      *   .select([
@@ -77,12 +77,12 @@ export declare class DynamicModule {
      * // The resulting type contains all `PossibleColumns` as optional fields
      * // because we cannot know which field was actually selected before
      * // running the code.
-     * const lastName: string | undefined = person.last_name
-     * const firstName: string | undefined = person.first_name
-     * const birthDate: string | undefined = person.birth_date
+     * const lastName: string | null | undefined = person?.last_name
+     * const firstName: string | undefined = person?.first_name
+     * const birthDate: Date | null | undefined = person?.birthdate
      *
      * // The result type also contains the compile time selection `id`.
-     * person.id
+     * person?.id
      * ```
      */
     ref<R extends string = never>(reference: string): DynamicReferenceBuilder<R>;

package/dist/esm/dynamic/dynamic.js

@@ -6,7 +6,7 @@ export class DynamicModule {
      *
      * Kysely is built in a way that by default you can't refer to tables or columns
      * that are not actually visible in the current query and context. This is all
-     * done by typescript at compile time, which means that you need to know the
+     * done by TypeScript at compile time, which means that you need to know the
      * columns and tables at compile time. This is not always the case of course.
      *
      * This method is meant to be used in those cases where the column names
@@ -62,11 +62,11 @@ export class DynamicModule {
      * const { ref } = db.dynamic
      *
      * // Some column name provided by the user. Value not known at compile time.
-     * const columnFromUserInput = req.query.select;
+     * const columnFromUserInput: PossibleColumns = 'birthdate';
      *
      * // A type that lists all possible values `columnFromUserInput` can have.
      * // You can use `keyof Person` if any column of an interface is allowed.
-     * type PossibleColumns = 'last_name' | 'first_name' | 'birth_date'
+     * type PossibleColumns = 'last_name' | 'first_name' | 'birthdate'
      *
      * const [person] = await db.selectFrom('person')
      *   .select([
@@ -78,12 +78,12 @@ export class DynamicModule {
      * // The resulting type contains all `PossibleColumns` as optional fields
      * // because we cannot know which field was actually selected before
      * // running the code.
-     * const lastName: string | undefined = person.last_name
-     * const firstName: string | undefined = person.first_name
-     * const birthDate: string | undefined = person.birth_date
+     * const lastName: string | null | undefined = person?.last_name
+     * const firstName: string | undefined = person?.first_name
+     * const birthDate: Date | null | undefined = person?.birthdate
      *
      * // The result type also contains the compile time selection `id`.
-     * person.id
+     * person?.id
      * ```
      */
     ref(reference) {