kysely 0.27.4 → 0.27.6

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'), eb('c.relkind', '=', 'p')]))
+            .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/dialect/sqlite/sqlite-introspector.js

@@ -11,58 +11,80 @@ export class SqliteIntrospector {
         return [];
     }
     async getTables(options = { withInternalKyselyTables: false }) {
-        let query = this.#db
+        return await this.#getTableMetadata(options);
+    }
+    async getMetadata(options) {
+        return {
+            tables: await this.getTables(options),
+        };
+    }
+    #tablesQuery(qb, options) {
+        let tablesQuery = qb
             .selectFrom('sqlite_master')
             .where('type', 'in', ['table', 'view'])
             .where('name', 'not like', 'sqlite_%')
-            .select('name')
-            .orderBy('name')
-            .$castTo();
+            .select(['name', 'sql', 'type'])
+            .orderBy('name');
         if (!options.withInternalKyselyTables) {
-            query = query
+            tablesQuery = tablesQuery
                 .where('name', '!=', DEFAULT_MIGRATION_TABLE)
                 .where('name', '!=', DEFAULT_MIGRATION_LOCK_TABLE);
         }
-        const tables = await query.execute();
-        return Promise.all(tables.map(({ name }) => this.#getTableMetadata(name)));
+        return tablesQuery;
     }
-    async getMetadata(options) {
-        return {
-            tables: await this.getTables(options),
-        };
-    }
-    async #getTableMetadata(table) {
-        const db = this.#db;
-        // Get the SQL that was used to create the table.
-        const tableDefinition = await db
-            .selectFrom('sqlite_master')
-            .where('name', '=', table)
-            .select(['sql', 'type'])
-            .$castTo()
-            .executeTakeFirstOrThrow();
-        // Try to find the name of the column that has `autoincrement` 🤦
-        const autoIncrementCol = tableDefinition.sql
-            ?.split(/[\(\),]/)
-            ?.find((it) => it.toLowerCase().includes('autoincrement'))
-            ?.trimStart()
-            ?.split(/\s+/)?.[0]
-            ?.replace(/["`]/g, '');
-        const columns = await db
-            .selectFrom(sql `pragma_table_info(${table})`.as('table_info'))
-            .select(['name', 'type', 'notnull', 'dflt_value'])
-            .orderBy('cid')
+    async #getTableMetadata(options) {
+        const tablesResult = await this.#tablesQuery(this.#db, options).execute();
+        const tableMetadata = await this.#db
+            .with('table_list', (qb) => this.#tablesQuery(qb, options))
+            .selectFrom([
+            'table_list as tl',
+            sql `pragma_table_info(tl.name)`.as('p'),
+        ])
+            .select([
+            'tl.name as table',
+            'p.cid',
+            'p.name',
+            'p.type',
+            'p.notnull',
+            'p.dflt_value',
+            'p.pk',
+        ])
+            .orderBy(['tl.name', 'p.cid'])
             .execute();
-        return {
-            name: table,
-            isView: tableDefinition.type === 'view',
-            columns: columns.map((col) => ({
-                name: col.name,
-                dataType: col.type,
-                isNullable: !col.notnull,
-                isAutoIncrementing: col.name === autoIncrementCol,
-                hasDefaultValue: col.dflt_value != null,
-                comment: undefined,
-            })),
-        };
+        const columnsByTable = {};
+        for (const row of tableMetadata) {
+            columnsByTable[row.table] ??= [];
+            columnsByTable[row.table].push(row);
+        }
+        return tablesResult.map(({ name, sql, type }) => {
+            // // Try to find the name of the column that has `autoincrement` 🤦
+            let autoIncrementCol = sql
+                ?.split(/[\(\),]/)
+                ?.find((it) => it.toLowerCase().includes('autoincrement'))
+                ?.trimStart()
+                ?.split(/\s+/)?.[0]
+                ?.replace(/["`]/g, '');
+            const columns = columnsByTable[name] ?? [];
+            // Otherwise, check for an INTEGER PRIMARY KEY
+            // https://www.sqlite.org/autoinc.html
+            if (!autoIncrementCol) {
+                const pkCols = columns.filter((r) => r.pk > 0);
+                if (pkCols.length === 1 && pkCols[0].type.toLowerCase() === 'integer') {
+                    autoIncrementCol = pkCols[0].name;
+                }
+            }
+            return {
+                name: name,
+                isView: type === 'view',
+                columns: columns.map((col) => ({
+                    name: col.name,
+                    dataType: col.type,
+                    isNullable: !col.notnull,
+                    isAutoIncrementing: col.name === autoIncrementCol,
+                    hasDefaultValue: col.dflt_value != null,
+                    comment: undefined,
+                })),
+            };
+        });
     }
 }

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

@@ -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

@@ -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) {