kysely 0.30.0-beta.1 → 0.30.0-beta.2

package/README.md

@@ -1,7 +1,7 @@
 [![Stand With Ukraine](https://raw.githubusercontent.com/vshymanskyy/StandWithUkraine/main/banner2-direct.svg)](https://stand-with-ukraine.pp.ua)
 
 [![NPM Version](https://img.shields.io/npm/v/kysely?style=flat&label=latest)](https://github.com/kysely-org/kysely/releases/latest)
-[![Socket Badge](https://badge.socket.dev/npm/package/kysely/0.30.0-beta.1)](https://socket.dev/npm/package/kysely/overview/0.30.0-beta.1)
+[![Socket Badge](https://badge.socket.dev/npm/package/kysely/0.30.0-beta.2)](https://socket.dev/npm/package/kysely/overview/0.30.0-beta.2)
 [![Tests](https://github.com/kysely-org/kysely/actions/workflows/test.yml/badge.svg)](https://github.com/kysely-org/kysely)
 [![License](https://img.shields.io/github/license/kysely-org/kysely?style=flat)](https://github.com/kysely-org/kysely/blob/master/LICENSE)
 [![Issues](https://img.shields.io/github/issues-closed/kysely-org/kysely?logo=github)](https://github.com/kysely-org/kysely/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc)

package/dist/dialect/database-introspector.d.ts

@@ -1,3 +1,5 @@
+import type { Expression } from '../expression/expression.js';
+import type { SqlBool } from '../util/type-utils.js';
 /**
  * An interface for getting the database metadata (names of the tables and columns etc.)
  */
@@ -5,27 +7,59 @@ export interface DatabaseIntrospector {
     /**
      * Get schema metadata.
      */
-    getSchemas(): Promise<SchemaMetadata[]>;
+    getSchemas(options?: DatabaseSchemaMetadataOptions): Promise<SchemaMetadata[]>;
     /**
      * Get tables and views metadata.
      */
     getTables(options?: DatabaseMetadataOptions): Promise<TableMetadata[]>;
 }
+export interface DatabaseSchemaMetadataOptions {
+    /**
+     * An optional SQL `where` expression for filtering the schemas returned by
+     * the introspector.
+     *
+     * The refs argument contains an SQL reference to the schema name column
+     * within the catalog query this expression will be used in.
+     */
+    where?: (refs: Readonly<{
+        schema: Expression<string>;
+    }>) => Expression<SqlBool>;
+}
 export interface DatabaseMetadataOptions {
+    /**
+     * An optional SQL `where` expression for filtering the tables returned by
+     * the introspector.
+     *
+     * The refs argument contains SQL references to the table name and optional
+     * schema name columns within the catalog query this expression will be used
+     * in.
+     */
+    where?: (refs: Readonly<{
+        table: Expression<string>;
+        schema?: Expression<string>;
+    }>) => Expression<SqlBool>;
     /**
      * If this is true, the metadata contains the internal kysely tables
      * such as the migration tables.
      */
     withInternalKyselyTables: boolean;
+    /**
+     * If this is true, tables from non-default databases are also returned.
+     *
+     * This option only affects MySQL and defaults to false. System databases are
+     * excluded regardless of this option.
+     */
+    withNonDefaultDatabases?: boolean;
 }
 export interface SchemaMetadata {
     readonly name: string;
 }
 export interface TableMetadata {
-    readonly name: string;
-    readonly isView: boolean;
-    readonly isForeign: boolean;
     readonly columns: ColumnMetadata[];
+    readonly comment?: string;
+    readonly isForeign: boolean;
+    readonly isView: boolean;
+    readonly name: string;
     readonly schema?: string;
 }
 export interface ColumnMetadata {

package/dist/dialect/mssql/mssql-introspector.d.ts

@@ -1,12 +1,12 @@
 import type { Kysely } from '../../kysely.js';
-import type { DatabaseIntrospector, DatabaseMetadataOptions, SchemaMetadata, TableMetadata } from '../database-introspector.js';
+import type { DatabaseIntrospector, DatabaseMetadataOptions, DatabaseSchemaMetadataOptions, SchemaMetadata, TableMetadata } from '../database-introspector.js';
 export declare class MssqlIntrospector implements DatabaseIntrospector {
     #private;
     constructor(db: Kysely<any>);
     /**
      * Get schema metadata.
      */
-    getSchemas(): Promise<SchemaMetadata[]>;
+    getSchemas(options?: DatabaseSchemaMetadataOptions): Promise<SchemaMetadata[]>;
     /**
      * Get tables and views metadata.
      */

package/dist/dialect/mssql/mssql-introspector.js

@@ -1,15 +1,28 @@
 /// <reference types="./mssql-introspector.d.ts" />
 import { DEFAULT_MIGRATION_LOCK_TABLE, DEFAULT_MIGRATION_TABLE, } from '../../migration/migrator.js';
+import { sql } from '../../raw-builder/sql.js';
 import { freeze } from '../../util/object-utils.js';
 export class MssqlIntrospector {
     #db;
     constructor(db) {
         this.#db = db;
     }
-    async getSchemas() {
-        return await this.#db.selectFrom('sys.schemas').select('name').execute();
+    async getSchemas(options = {}) {
+        let query = this.#db.selectFrom('sys.schemas').select('name');
+        if (options.where) {
+            query = query.where(options.where({ schema: sql.ref('name') }));
+        }
+        return await query.execute();
     }
     async getTables(options = { withInternalKyselyTables: false }) {
+        const tablesWhere = options.where?.({
+            schema: sql.ref('table_schemas.name'),
+            table: sql.ref('tables.name'),
+        });
+        const viewsWhere = options.where?.({
+            schema: sql.ref('view_schemas.name'),
+            table: sql.ref('views.name'),
+        });
         const rawColumns = await this.#db
             .selectFrom('sys.tables as tables')
             .leftJoin('sys.schemas as table_schemas', 'table_schemas.schema_id', 'tables.schema_id')
@@ -17,12 +30,19 @@ export class MssqlIntrospector {
             .innerJoin('sys.types as types', 'types.user_type_id', 'columns.user_type_id')
             .leftJoin('sys.schemas as type_schemas', 'type_schemas.schema_id', 'types.schema_id')
             .leftJoin('sys.extended_properties as comments', (join) => join
+            .on('comments.class', '=', 1)
             .onRef('comments.major_id', '=', 'tables.object_id')
             .onRef('comments.minor_id', '=', 'columns.column_id')
             .on('comments.name', '=', 'MS_Description'))
+            .leftJoin('sys.extended_properties as table_comments', (join) => join
+            .on('table_comments.class', '=', 1)
+            .onRef('table_comments.major_id', '=', 'tables.object_id')
+            .on('table_comments.minor_id', '=', 0)
+            .on('table_comments.name', '=', 'MS_Description'))
             .$if(!options.withInternalKyselyTables, (qb) => qb
             .where('tables.name', '!=', DEFAULT_MIGRATION_TABLE)
             .where('tables.name', '!=', DEFAULT_MIGRATION_LOCK_TABLE))
+            .$if(!!tablesWhere, (qb) => qb.where(tablesWhere))
             .select([
             'tables.name as table_name',
             (eb) => eb
@@ -41,6 +61,7 @@ export class MssqlIntrospector {
             'types.name as type_name',
             'type_schemas.name as type_schema_name',
             'comments.value as column_comment',
+            'table_comments.value as table_comment',
         ])
             .unionAll(this.#db
             .selectFrom('sys.views as views')
@@ -49,9 +70,16 @@ export class MssqlIntrospector {
             .innerJoin('sys.types as types', 'types.user_type_id', 'columns.user_type_id')
             .leftJoin('sys.schemas as type_schemas', 'type_schemas.schema_id', 'types.schema_id')
             .leftJoin('sys.extended_properties as comments', (join) => join
+            .on('comments.class', '=', 1)
             .onRef('comments.major_id', '=', 'views.object_id')
             .onRef('comments.minor_id', '=', 'columns.column_id')
             .on('comments.name', '=', 'MS_Description'))
+            .leftJoin('sys.extended_properties as table_comments', (join) => join
+            .on('table_comments.class', '=', 1)
+            .onRef('table_comments.major_id', '=', 'views.object_id')
+            .on('table_comments.minor_id', '=', 0)
+            .on('table_comments.name', '=', 'MS_Description'))
+            .$if(!!viewsWhere, (qb) => qb.where(viewsWhere))
             .select([
             'views.name as table_name',
             'views.type as table_type',
@@ -67,6 +95,7 @@ export class MssqlIntrospector {
             'types.name as type_name',
             'type_schemas.name as type_schema_name',
             'comments.value as column_comment',
+            'table_comments.value as table_comment',
         ]))
             .orderBy('table_schema_name')
             .orderBy('table_name')
@@ -79,6 +108,7 @@ export class MssqlIntrospector {
                 tableDictionary[key] ||
                     freeze({
                         columns: [],
+                        comment: rawColumn.table_comment ?? undefined,
                         isForeign: false,
                         isView: rawColumn.table_type === 'V ',
                         name: rawColumn.table_name,

package/dist/dialect/mysql/mysql-introspector.d.ts

@@ -1,4 +1,4 @@
-import type { DatabaseIntrospector, DatabaseMetadataOptions, SchemaMetadata, TableMetadata } from '../database-introspector.js';
+import type { DatabaseIntrospector, DatabaseMetadataOptions, DatabaseSchemaMetadataOptions, SchemaMetadata, TableMetadata } from '../database-introspector.js';
 import type { Kysely } from '../../kysely.js';
 export declare class MysqlIntrospector implements DatabaseIntrospector {
     #private;
@@ -6,7 +6,7 @@ export declare class MysqlIntrospector implements DatabaseIntrospector {
     /**
      * Get schema metadata.
      */
-    getSchemas(): Promise<SchemaMetadata[]>;
+    getSchemas(options?: DatabaseSchemaMetadataOptions): Promise<SchemaMetadata[]>;
     /**
      * Get tables and views metadata.
      */

package/dist/dialect/mysql/mysql-introspector.js

@@ -2,18 +2,27 @@
 import { DEFAULT_MIGRATION_LOCK_TABLE, DEFAULT_MIGRATION_TABLE, } from '../../migration/migrator.js';
 import { freeze } from '../../util/object-utils.js';
 import { sql } from '../../raw-builder/sql.js';
+const SYSTEM_DATABASES = [
+    'information_schema',
+    'mysql',
+    'performance_schema',
+    'sys',
+    'ndbinfo',
+];
 export class MysqlIntrospector {
     #db;
     constructor(db) {
         this.#db = db;
     }
-    async getSchemas() {
-        let rawSchemas = await this.#db
+    async getSchemas(options = {}) {
+        let query = this.#db
             .selectFrom('information_schema.schemata')
-            .select('schema_name')
-            .$castTo()
-            .execute();
-        return rawSchemas.map((it) => ({ name: it.SCHEMA_NAME }));
+            .select('schema_name as name')
+            .$narrowType();
+        if (options.where) {
+            query = query.where(options.where({ schema: sql.ref('schema_name') }));
+        }
+        return await query.execute();
     }
     async getTables(options = { withInternalKyselyTables: false }) {
         let query = this.#db
@@ -28,34 +37,48 @@ export class MysqlIntrospector {
             'columns.TABLE_NAME',
             'columns.TABLE_SCHEMA',
             'tables.TABLE_TYPE',
+            'tables.TABLE_COMMENT',
             'tables.ENGINE',
             'columns.IS_NULLABLE',
             'columns.DATA_TYPE',
             'columns.EXTRA',
             'columns.COLUMN_COMMENT',
         ])
-            .where('columns.TABLE_SCHEMA', '=', sql `database()`)
+            .where('columns.TABLE_SCHEMA', 'not in', SYSTEM_DATABASES)
+            .orderBy('columns.TABLE_SCHEMA')
             .orderBy('columns.TABLE_NAME')
             .orderBy('columns.ORDINAL_POSITION')
             .$castTo();
+        if (!options.withNonDefaultDatabases) {
+            query = query.where('columns.TABLE_SCHEMA', '=', sql `database()`);
+        }
         if (!options.withInternalKyselyTables) {
             query = query
                 .where('columns.TABLE_NAME', '!=', DEFAULT_MIGRATION_TABLE)
                 .where('columns.TABLE_NAME', '!=', DEFAULT_MIGRATION_LOCK_TABLE);
         }
+        if (options.where) {
+            query = query.where(options.where({
+                schema: sql.ref('columns.TABLE_SCHEMA'),
+                table: sql.ref('columns.TABLE_NAME'),
+            }));
+        }
         const rawColumns = await query.execute();
         return this.#parseTableMetadata(rawColumns);
     }
     #parseTableMetadata(columns) {
         return columns.reduce((tables, it) => {
-            let table = tables.find((tbl) => tbl.name === it.TABLE_NAME);
+            let table = tables.find((tbl) => tbl.name === it.TABLE_NAME && tbl.schema === it.TABLE_SCHEMA);
             if (!table) {
                 table = freeze({
-                    name: it.TABLE_NAME,
-                    isView: it.TABLE_TYPE === 'VIEW',
+                    columns: [],
+                    comment: it.TABLE_TYPE === 'VIEW' || it.TABLE_COMMENT === ''
+                        ? undefined
+                        : it.TABLE_COMMENT,
                     isForeign: it.ENGINE === 'FEDERATED',
+                    isView: it.TABLE_TYPE === 'VIEW',
+                    name: it.TABLE_NAME,
                     schema: it.TABLE_SCHEMA,
-                    columns: [],
                 });
                 tables.push(table);
             }

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

@@ -1,4 +1,4 @@
-import type { DatabaseIntrospector, DatabaseMetadataOptions, SchemaMetadata, TableMetadata } from '../database-introspector.js';
+import type { DatabaseIntrospector, DatabaseMetadataOptions, DatabaseSchemaMetadataOptions, SchemaMetadata, TableMetadata } from '../database-introspector.js';
 import type { Kysely } from '../../kysely.js';
 export declare class PostgresIntrospector implements DatabaseIntrospector {
     #private;
@@ -6,7 +6,7 @@ export declare class PostgresIntrospector implements DatabaseIntrospector {
     /**
      * Get schema metadata.
      */
-    getSchemas(): Promise<SchemaMetadata[]>;
+    getSchemas(options?: DatabaseSchemaMetadataOptions): Promise<SchemaMetadata[]>;
     /**
      * Get tables and views metadata.
      */

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

@@ -7,13 +7,15 @@ export class PostgresIntrospector {
     constructor(db) {
         this.#db = db;
     }
-    async getSchemas() {
-        let rawSchemas = await this.#db
+    async getSchemas(options = {}) {
+        let query = this.#db
             .selectFrom('pg_catalog.pg_namespace')
-            .select('nspname')
-            .$castTo()
-            .execute();
-        return rawSchemas.map((it) => ({ name: it.nspname }));
+            .select('nspname as name')
+            .$narrowType();
+        if (options.where) {
+            query = query.where(options.where({ schema: sql.ref('nspname') }));
+        }
+        return await query.execute();
     }
     async getTables(options = { withInternalKyselyTables: false }) {
         let query = this.#db
@@ -36,12 +38,14 @@ export class PostgresIntrospector {
             'ns.nspname as schema',
             'typ.typname as type',
             'dtns.nspname as type_schema',
+            sql `obj_description(c.oid, 'pg_class')`.as('table_description'),
             sql `col_description(a.attrelid, a.attnum)`.as('column_description'),
             sql `pg_get_serial_sequence(quote_ident(ns.nspname) || '.' || quote_ident(c.relname), a.attname)`.as('auto_incrementing'),
         ])
             .where('c.relkind', 'in', [
             'r' /*regular table*/,
             'v' /*view*/,
+            'm' /*materialized view*/,
             'p' /*partitioned table*/,
             'f' /*foreign table*/,
         ])
@@ -63,6 +67,12 @@ export class PostgresIntrospector {
                 .where('c.relname', '!=', DEFAULT_MIGRATION_TABLE)
                 .where('c.relname', '!=', DEFAULT_MIGRATION_LOCK_TABLE);
         }
+        if (options.where) {
+            query = query.where(options.where({
+                schema: sql.ref('ns.nspname'),
+                table: sql.ref('c.relname'),
+            }));
+        }
         const rawColumns = await query.execute();
         return this.#parseTableMetadata(rawColumns);
     }
@@ -79,8 +89,9 @@ export class PostgresIntrospector {
             if (!table) {
                 table = freeze({
                     columns: [],
+                    comment: column.table_description ?? undefined,
                     isForeign: column.table_type === 'f',
-                    isView: column.table_type === 'v',
+                    isView: column.table_type === 'v' || column.table_type === 'm',
                     name: column.table,
                     schema: column.schema,
                 });

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

@@ -1,5 +1,4 @@
 /// <reference types="./sqlite-driver.d.ts" />
-import { SelectQueryNode } from '../../operation-node/select-query-node.js';
 import { parseSavepointCommand } from '../../parser/savepoint-parser.js';
 import { CompiledQuery } from '../../query-compiler/compiled-query.js';
 import { freeze, isFunction } from '../../util/object-utils.js';
@@ -68,14 +67,14 @@ class SqliteConnection {
             rows: [],
         };
     }
-    async *streamQuery(compiledQuery, _chunkSize) {
-        const { sql, parameters, query } = compiledQuery;
-        const stmt = this.#db.prepare(sql);
-        if (!SelectQueryNode.is(query)) {
-            throw new Error('Sqlite driver only supports streaming of select queries');
+    async *streamQuery(compiledQuery) {
+        const { sql, parameters } = compiledQuery;
+        const statement = this.#db.prepare(sql);
+        if (!statement.reader) {
+            throw new Error('Sqlite driver only supports streaming of queries that return rows');
         }
-        const iter = stmt.iterate(parameters);
-        for (const row of iter) {
+        const rows = statement.iterate(parameters);
+        for (const row of rows) {
             yield {
                 rows: [row],
             };

package/dist/dialect/sqlite/sqlite-introspector.js

@@ -25,6 +25,9 @@ export class SqliteIntrospector {
                 .where('name', '!=', DEFAULT_MIGRATION_TABLE)
                 .where('name', '!=', DEFAULT_MIGRATION_LOCK_TABLE);
         }
+        if (options.where) {
+            tablesQuery = tablesQuery.where(options.where({ table: sql.ref('name') }));
+        }
         return tablesQuery;
     }
     async #getTableMetadata(options) {
@@ -70,9 +73,6 @@ export class SqliteIntrospector {
                 }
             }
             return {
-                name: name,
-                isView: type === 'view',
-                isForeign: false,
                 columns: columns.map((col) => ({
                     name: col.name,
                     dataType: col.type,
@@ -81,6 +81,10 @@ export class SqliteIntrospector {
                     hasDefaultValue: col.dflt_value != null,
                     comment: undefined,
                 })),
+                comment: undefined,
+                isForeign: false,
+                isView: type === 'view',
+                name,
             };
         });
     }

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

@@ -29,8 +29,8 @@ import type { Driver } from './driver.js';
  * })
  * ```
  *
- * You can use it to build a query and compile it to SQL but trying to
- * execute the query will throw an error.
+ * You can use it to build a query and compile it to SQL. Executing queries
+ * returns empty results without communicating with a database.
  *
  * ```ts
  * const { sql } = db.selectFrom('person').selectAll().compile()

package/dist/driver/dummy-driver.js

@@ -28,8 +28,8 @@
  * })
  * ```
  *
- * You can use it to build a query and compile it to SQL but trying to
- * execute the query will throw an error.
+ * You can use it to build a query and compile it to SQL. Executing queries
+ * returns empty results without communicating with a database.
  *
  * ```ts
  * const { sql } = db.selectFrom('person').selectAll().compile()

package/dist/kysely.d.ts

@@ -14,7 +14,6 @@ import type { CompiledQuery } from './query-compiler/compiled-query.js';
 import { type Compilable } from './util/compilable.js';
 import { CaseBuilder } from './query-builder/case-builder.js';
 import type { Expression } from './expression/expression.js';
-import type { DrainOuterGeneric } from './util/type-utils.js';
 import type { ReleaseSavepoint, RollbackToSavepoint } from './parser/savepoint-parser.js';
 import { type ControlledConnection } from './util/provide-controlled-connection.js';
 import type { AbortableOperationOptions, AbortableQueryOptions } from './util/abort.js';
@@ -60,6 +59,7 @@ declare global {
  */
 export declare class Kysely<DB> extends QueryCreator<DB> implements QueryExecutorProvider, AsyncDisposable {
     #private;
+    protected readonly '~DB': QueryCreator<DB>['~DB'];
     constructor(args: KyselyConfig);
     constructor(args: KyselyProps);
     /**
@@ -380,7 +380,7 @@ export declare class Kysely<DB> extends QueryCreator<DB> implements QueryExecuto
      *   .execute()
      * ```
      */
-    $extendTables<T extends Record<string, Record<string, any>>>(): Kysely<DrainOuterGeneric<DB & T>>;
+    $extendTables<T extends Record<string, Record<string, any>>>(): Kysely<DB & T>;
     /**
      * Returns a copy of this Kysely instance without the given tables (provided as
      * a union type of table names).
@@ -446,7 +446,7 @@ export declare class Kysely<DB> extends QueryCreator<DB> implements QueryExecuto
     /**
      * @deprecated use {@link $extendTables} instead.
      */
-    withTables<T extends Record<string, Record<string, any>>>(): Kysely<DrainOuterGeneric<DB & T>>;
+    withTables<T extends Record<string, Record<string, any>>>(): Kysely<DB & T>;
     /**
      * Releases all resources and disconnects from the database.
      *
@@ -514,19 +514,30 @@ export declare class Transaction<DB> extends Kysely<DB> {
      *
      * @deprecated use {@link $extendTables} instead.
      */
-    withTables<T extends Record<string, Record<string, any>>>(): Transaction<DrainOuterGeneric<DB & T>>;
+    withTables<T extends Record<string, Record<string, any>>>(): Transaction<DB & T>;
+    /**
+     * @deprecated use {@link $extendTables} instead.
+     */
+    withTables<T extends Record<string, Record<string, any>>>(): Kysely<DB & T>;
+    withTables<T extends Record<string, Record<string, any>>>(): Transaction<DB & T>;
     /**
      * Similar to {@link Kysely.$extendTables} but returns the transaction.
      */
-    $extendTables<T extends Record<string, Record<string, any>>>(): Transaction<DrainOuterGeneric<DB & T>>;
+    $extendTables<T extends Record<string, Record<string, any>>>(): Transaction<DB & T>;
+    $extendTables<T extends Record<string, Record<string, any>>>(): Kysely<DB & T>;
+    $extendTables<T extends Record<string, Record<string, any>>>(): Transaction<DB & T>;
     /**
      * Similar to {@link Kysely.$omitTables} but returns the transaction.
      */
     $omitTables<T extends keyof DB>(): Transaction<DB extends object ? Omit<DB, T> : DB>;
+    $omitTables<T extends keyof DB>(): Kysely<DB extends object ? Omit<DB, T> : DB>;
+    $omitTables<T extends keyof DB>(): Transaction<DB extends object ? Omit<DB, T> : DB>;
     /**
      * Similar to {@link Kysely.$pickTables} but returns the transaction.
      */
     $pickTables<T extends keyof DB>(): Transaction<DB extends object ? Pick<DB, T> : DB>;
+    $pickTables<T extends keyof DB>(): Kysely<DB extends object ? Pick<DB, T> : DB>;
+    $pickTables<T extends keyof DB>(): Transaction<DB extends object ? Pick<DB, T> : DB>;
 }
 export interface KyselyProps {
     readonly config: KyselyConfig;
@@ -777,10 +788,19 @@ export declare class ControlledTransaction<DB, S extends string[] = []> extends
      *
      * @deprecated use {@link $extendTables} instead.
      */
-    withTables<T extends Record<string, Record<string, any>>>(): ControlledTransaction<DrainOuterGeneric<DB & T>, S>;
-    $extendTables<T extends Record<string, Record<string, any>>>(): ControlledTransaction<DrainOuterGeneric<DB & T>, S>;
+    withTables<T extends Record<string, Record<string, any>>>(): ControlledTransaction<DB & T, S>;
+    withTables<T extends Record<string, Record<string, any>>>(): Kysely<DB & T>;
+    withTables<T extends Record<string, Record<string, any>>>(): ControlledTransaction<DB & T, S>;
+    $extendTables<T extends Record<string, Record<string, any>>>(): ControlledTransaction<DB & T, S>;
+    $extendTables<T extends Record<string, Record<string, any>>>(): Kysely<DB & T>;
+    $extendTables<T extends Record<string, Record<string, any>>>(): ControlledTransaction<DB & T, S>;
+    $omitTables<T extends keyof DB>(): ControlledTransaction<DB extends object ? Omit<DB, T> : DB, S>;
+    $omitTables<T extends keyof DB>(): Kysely<DB extends object ? Omit<DB, T> : DB>;
+    $omitTables<T extends keyof DB>(): Transaction<DB extends object ? Omit<DB, T> : DB>;
     $omitTables<T extends keyof DB>(): ControlledTransaction<DB extends object ? Omit<DB, T> : DB, S>;
     $pickTables<T extends keyof DB>(): ControlledTransaction<DB extends object ? Pick<DB, T> : DB, S>;
+    $pickTables<T extends keyof DB>(): Kysely<DB extends object ? Pick<DB, T> : DB>;
+    $pickTables<T extends keyof DB>(): ControlledTransaction<DB extends object ? Pick<DB, T> : DB, S>;
 }
 interface ControlledTransactionProps extends KyselyProps {
     readonly connection: ControlledConnection;

package/dist/kysely.js

@@ -601,29 +601,15 @@ export class Transaction extends Kysely {
             executor: this.#props.executor.withPluginAtFront(new WithSchemaPlugin(schema)),
         });
     }
-    /**
-     * Similar to {@link Kysely.withTables} but returns the transaction.
-     *
-     * @deprecated use {@link $extendTables} instead.
-     */
     withTables() {
         return new Transaction({ ...this.#props });
     }
-    /**
-     * Similar to {@link Kysely.$extendTables} but returns the transaction.
-     */
     $extendTables() {
         return new Transaction({ ...this.#props });
     }
-    /**
-     * Similar to {@link Kysely.$omitTables} but returns the transaction.
-     */
     $omitTables() {
         return new Transaction({ ...this.#props });
     }
-    /**
-     * Similar to {@link Kysely.$pickTables} but returns the transaction.
-     */
     $pickTables() {
         return new Transaction({ ...this.#props });
     }

package/dist/migration/migrator.js

@@ -1,6 +1,7 @@
 /// <reference types="./migrator.d.ts" />
 import { NoopPlugin } from '../plugin/noop-plugin.js';
 import { WithSchemaPlugin } from '../plugin/with-schema/with-schema-plugin.js';
+import { sql } from '../raw-builder/sql.js';
 import { logOnce } from '../util/log-once.js';
 import { freeze, isObject } from '../util/object-utils.js';
 export const DEFAULT_MIGRATION_TABLE = 'kysely_migration';
@@ -53,7 +54,7 @@ export class Migrator {
      * The returned array is sorted by migration name.
      */
     async getMigrations() {
-        const tableExists = await this.#doesTableExist(this.#migrationTable);
+        const tableExists = await this.#doesTableExist(this.#migrationTableSchema, this.#migrationTable);
         const executedMigrations = tableExists
             ? await this.#props.db
                 .withPlugin(this.#schemaPlugin)
@@ -329,7 +330,7 @@ export class Migrator {
             // Use default schema. Nothing to do.
             return;
         }
-        const schemaExists = await this.#doesSchemaExist();
+        const schemaExists = await this.#doesSchemaExist(this.#migrationTableSchema);
         if (schemaExists) {
             return;
         }
@@ -337,7 +338,7 @@ export class Migrator {
             await this.#createIfNotExists(this.#props.db.schema.createSchema(this.#migrationTableSchema));
         }
         catch (error) {
-            const schemaExists = await this.#doesSchemaExist();
+            const schemaExists = await this.#doesSchemaExist(this.#migrationTableSchema);
             // At least on PostgreSQL, `if not exists` doesn't guarantee the `create schema`
             // query doesn't throw if the schema already exits. That's why we check if
             // the schema exist here and ignore the error if it does.
@@ -347,7 +348,7 @@ export class Migrator {
         }
     }
     async #ensureMigrationTableExists() {
-        const tableExists = await this.#doesTableExist(this.#migrationTable);
+        const tableExists = await this.#doesTableExist(this.#migrationTableSchema, this.#migrationTable);
         if (tableExists) {
             return;
         }
@@ -361,7 +362,7 @@ export class Migrator {
                 .addColumn('timestamp', 'varchar(255)', (col) => col.notNull()));
         }
         catch (error) {
-            const tableExists = await this.#doesTableExist(this.#migrationTable);
+            const tableExists = await this.#doesTableExist(this.#migrationTableSchema, this.#migrationTable);
             // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
             // query doesn't throw if the table already exits. That's why we check if
             // the table exist here and ignore the error if it does.
@@ -371,7 +372,7 @@ export class Migrator {
         }
     }
     async #ensureMigrationLockTableExists() {
-        const tableExists = await this.#doesTableExist(this.#migrationLockTable);
+        const tableExists = await this.#doesTableExist(this.#migrationTableSchema, this.#migrationLockTable);
         if (tableExists) {
             return;
         }
@@ -383,7 +384,7 @@ export class Migrator {
                 .addColumn('is_locked', 'integer', (col) => col.notNull().defaultTo(0)));
         }
         catch (error) {
-            const tableExists = await this.#doesTableExist(this.#migrationLockTable);
+            const tableExists = await this.#doesTableExist(this.#migrationTableSchema, this.#migrationLockTable);
             // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
             // query doesn't throw if the table already exits. That's why we check if
             // the table exist here and ignore the error if it does.
@@ -411,16 +412,24 @@ export class Migrator {
             }
         }
     }
-    async #doesSchemaExist() {
-        const schemas = await this.#props.db.introspection.getSchemas();
-        return schemas.some((it) => it.name === this.#migrationTableSchema);
+    async #doesSchemaExist(schemaName) {
+        const schemas = await this.#props.db.introspection.getSchemas({
+            where: ({ schema }) => sql `${schema} = ${schemaName}`,
+        });
+        // we still keep this in case the introspector doesn't implement support for
+        // `where`.
+        return schemas.some((it) => it.name === schemaName);
     }
-    async #doesTableExist(tableName) {
-        const schema = this.#migrationTableSchema;
+    async #doesTableExist(schemaName, tableName) {
         const tables = await this.#props.db.introspection.getTables({
+            where: ({ schema, table }) => schemaName != null && schema
+                ? sql `${schema} = ${schemaName} and ${table} = ${tableName}`
+                : sql `${table} = ${tableName}`,
             withInternalKyselyTables: true,
         });
-        return tables.some((it) => it.name === tableName && (!schema || it.schema === schema));
+        // we still keep this in case the introspector doesn't implement support for
+        // `where`.
+        return tables.some((it) => it.name === tableName && (!schemaName || it.schema === schemaName));
     }
     async #doesLockRowExists() {
         const lockRow = await this.#props.db

package/dist/query-builder/delete-query-builder.d.ts

@@ -1039,7 +1039,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * delete from `pet` order by `created_at` limit ?
      * ```
      */
-    limit(limit: ValueExpression<DB, TB, number>): DeleteQueryBuilder<DB, TB, O>;
+    limit<VE extends ValueExpression<DB, TB, number>>(limit: VE): DeleteQueryBuilder<DB, TB, O>;
     /**
      * This can be used to add any additional SQL to the end of the query.
      *
@@ -1122,7 +1122,7 @@ export declare class DeleteQueryBuilder<DB, TB extends keyof DB, O> implements W
      * }>
      * ```
      */
-    $if<O2>(condition: boolean, func: (qb: this) => DeleteQueryBuilder<any, any, O2>): O2 extends DeleteResult ? DeleteQueryBuilder<DB, TB, DeleteResult> : O2 extends O & infer E ? DeleteQueryBuilder<DB, TB, O & Partial<E>> : DeleteQueryBuilder<DB, TB, Partial<O2>>;
+    $if<O2>(condition: boolean, func: (qb: this) => DeleteQueryBuilder<any, any, O2>): unknown extends O2 ? DeleteQueryBuilder<any, any, O2> : O2 extends DeleteResult ? DeleteQueryBuilder<DB, TB, DeleteResult> : O2 extends O & infer E ? DeleteQueryBuilder<DB, TB, O & Partial<E>> : DeleteQueryBuilder<DB, TB, Partial<O2>>;
     /**
      * Change the output type of the query.
      *

package/dist/query-builder/function-module.d.ts

@@ -3,10 +3,16 @@ import type { Expression } from '../expression/expression.js';
 import type { ExtractTypeFromCoalesce1, ExtractTypeFromCoalesce3, ExtractTypeFromCoalesce2, ExtractTypeFromCoalesce4, ExtractTypeFromCoalesce5 } from '../parser/coalesce-parser.js';
 import { type ExtractTypeFromReferenceExpression, type ReferenceExpression, type StringReference, type ExtractTypeFromStringReference } from '../parser/reference-parser.js';
 import type { KyselyTypeError } from '../util/type-error.js';
-import type { IsNever, ShallowDehydrateObject, ShallowDehydrateValue, Simplify } from '../util/type-utils.js';
+import type { IsAny, IsNever, ShallowDehydrateObject, ShallowDehydrateValue, Simplify } from '../util/type-utils.js';
 import { AggregateFunctionBuilder } from './aggregate-function-builder.js';
 import type { SelectQueryBuilderExpression } from '../query-builder/select-query-builder-expression.js';
 import type { Selectable, SelectType } from '../util/column-type.js';
+declare class FunctionModule<DB, TB extends keyof DB> {
+    protected readonly '~DB'?: IsAny<DB> extends true ? any : {
+        [T in TB]: Selectable<DB[T]>;
+    };
+}
+export type { FunctionModule };
 /**
  * Helpers for type safe SQL function calls.
  *
@@ -79,7 +85,7 @@ import type { Selectable, SelectType } from '../util/column-type.js';
  * having count("pet"."id") > $3
  * ```
  */
-export interface FunctionModule<DB, TB extends keyof DB> {
+interface FunctionModule<DB, TB extends keyof DB> {
     /**
      * Creates a function call.
      *

package/dist/query-builder/join-builder.d.ts

@@ -14,14 +14,14 @@ export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNo
      * See {@link WhereInterface.where} for documentation and examples.
      */
     on<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): JoinBuilder<DB, TB>;
-    on(expression: ExpressionOrFactory<DB, TB, SqlBool>): JoinBuilder<DB, TB>;
+    on<E extends ExpressionOrFactory<DB, TB, SqlBool>>(expression: E): JoinBuilder<DB, TB>;
     /**
      * Just like {@link WhereInterface.whereRef} but adds an item to the join's
      * `on` clause instead.
      *
      * See {@link WhereInterface.whereRef} for documentation and examples.
      */
-    onRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): JoinBuilder<DB, TB>;
+    onRef<LRE extends ReferenceExpression<DB, TB>, RRE extends ReferenceExpression<DB, TB>>(lhs: LRE, op: ComparisonOperatorExpression, rhs: RRE): JoinBuilder<DB, TB>;
     /**
      * Adds `on true`.
      */

package/dist/query-builder/merge-query-builder.d.ts

@@ -14,16 +14,24 @@ import type { ValueExpression } from '../parser/value-parser.js';
 import type { CompiledQuery } from '../query-compiler/compiled-query.js';
 import type { QueryExecutor } from '../query-executor/query-executor.js';
 import type { AbortableQueryOptions } from '../util/abort.js';
+import type { Insertable, Selectable, Updateable } from '../util/column-type.js';
 import type { Compilable } from '../util/compilable.js';
 import type { Executable, ExecuteTakeFirstOrThrowOptions } from '../util/executable.js';
 import type { QueryId } from '../util/query-id.js';
-import type { ShallowRecord, SimplifyResult, SimplifySingleResult, SqlBool } from '../util/type-utils.js';
+import type { IsAny, ShallowRecord, SimplifyResult, SimplifySingleResult, SqlBool } from '../util/type-utils.js';
 import { MergeResult } from './merge-result.js';
 import type { OutputCallback, OutputExpression, OutputInterface, OutputPrefix, SelectExpressionFromOutputCallback, SelectExpressionFromOutputExpression } from './output-interface.js';
 import type { MultiTableReturningInterface } from './returning-interface.js';
 import { UpdateQueryBuilder } from './update-query-builder.js';
 export declare class MergeQueryBuilder<DB, TT extends keyof DB, O> implements MultiTableReturningInterface<DB, TT, O>, OutputInterface<DB, TT, O> {
     #private;
+    protected readonly '~DB': IsAny<DB> extends true ? any : {
+        [T in keyof DB]: {
+            select: () => Selectable<DB[T]>;
+            insert: (row: Insertable<DB[T]>) => void;
+            update: (row: Updateable<DB[T]>) => void;
+        };
+    };
     constructor(props: MergeQueryBuilderProps);
     /**
      * This can be used to add any additional SQL to the end of the query.

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

@@ -1377,7 +1377,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      * select "first_name" from "person" limit $1 offset $2
      * ```
      */
-    limit(limit: ValueExpression<DB, TB, number | bigint | null>): SelectQueryBuilder<DB, TB, O>;
+    limit<VE extends ValueExpression<DB, TB, number | bigint | null>>(limit: VE): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds an `offset` clause to the query.
      *
@@ -1400,7 +1400,7 @@ export interface SelectQueryBuilder<DB, TB extends keyof DB, O> extends WhereInt
      * select "first_name" from "person" limit $1 offset $2
      * ```
      */
-    offset(offset: ValueExpression<DB, TB, number | bigint>): SelectQueryBuilder<DB, TB, O>;
+    offset<VE extends ValueExpression<DB, TB, number | bigint>>(offset: VE): SelectQueryBuilder<DB, TB, O>;
     /**
      * Adds a `fetch` clause to the query.
      *
@@ -2367,22 +2367,44 @@ export interface SelectQueryBuilderProps {
 export interface AliasedSelectQueryBuilder<out O = undefined, out A extends string = never> extends AliasedExpression<O, A> {
     get isAliasedSelectQueryBuilder(): true;
 }
-export type SelectQueryBuilderWithInnerJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? InnerJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? SelectQueryBuilder<DB, TB | TE, O> : TE extends AliasedExpression<infer QO, infer QA> ? InnerJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? InnerJoinedBuilder<DB, TB, O, QA, QO> : never;
+/**
+ * Guards a join's result type against being computed for an unknown table
+ * expression.
+ *
+ * `TableExpression<DB, TB> extends TE` only holds when `TE` is as wide as its
+ * own constraint, which never happens at a call site - there `TE` is a specific
+ * table name, alias or subquery. It does happen when the compiler asks what a
+ * join returns for an arbitrary table expression, which is what it has to do
+ * whenever it compares two `SelectQueryBuilder` types structurally.
+ *
+ * Without this guard that comparison never terminates on its own: computing the
+ * join result yields a `SelectQueryBuilder` over a wider `DB`, whose own join
+ * methods yield a wider one still, so the compiler only stops when it hits its
+ * internal recursion limit. That limit differs between TypeScript versions - 7.0
+ * searches a level deeper than 5.9 and 6.0 - which made comparing two select
+ * query builders over 6x more expensive there.
+ *
+ * Collapsing to a fixed type makes the recursion converge instead: joining an
+ * unknown table expression again produces the same type, so the compiler
+ * recognises the pair it is already comparing and stops immediately.
+ */
+type JoinResultForUnknownTable<O> = SelectQueryBuilder<any, any, O>;
+export type SelectQueryBuilderWithInnerJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TableExpression<DB, TB> extends TE ? JoinResultForUnknownTable<O> : TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? InnerJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? SelectQueryBuilder<DB, TB | TE, O> : TE extends AliasedExpression<infer QO, infer QA> ? InnerJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? InnerJoinedBuilder<DB, TB, O, QA, QO> : never;
 type InnerJoinedBuilder<DB, TB extends keyof DB, O, A extends string, R> = A extends keyof DB ? SelectQueryBuilder<InnerJoinedDB<DB, A, R>, TB | A, O> : SelectQueryBuilder<DB & ShallowRecord<A, R>, TB | A, O>;
 type InnerJoinedDB<DB, A extends string, R> = DrainOuterGeneric<{
     [C in keyof DB | A]: C extends A ? R : C extends keyof DB ? DB[C] : never;
 }>;
-export type SelectQueryBuilderWithLeftJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? LeftJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? LeftJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? LeftJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? LeftJoinedBuilder<DB, TB, O, QA, QO> : never;
+export type SelectQueryBuilderWithLeftJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TableExpression<DB, TB> extends TE ? JoinResultForUnknownTable<O> : TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? LeftJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? LeftJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? LeftJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? LeftJoinedBuilder<DB, TB, O, QA, QO> : never;
 type LeftJoinedBuilder<DB, TB extends keyof DB, O, A extends keyof any, R> = A extends keyof DB ? SelectQueryBuilder<LeftJoinedDB<DB, A, R>, TB | A, O> : SelectQueryBuilder<DB & ShallowRecord<A, Nullable<R>>, TB | A, O>;
 type LeftJoinedDB<DB, A extends keyof any, R> = DrainOuterGeneric<{
     [C in keyof DB | A]: C extends A ? Nullable<R> : C extends keyof DB ? DB[C] : never;
 }>;
-export type SelectQueryBuilderWithRightJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? RightJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? RightJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? RightJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? RightJoinedBuilder<DB, TB, O, QA, QO> : never;
+export type SelectQueryBuilderWithRightJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TableExpression<DB, TB> extends TE ? JoinResultForUnknownTable<O> : TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? RightJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? RightJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? RightJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? RightJoinedBuilder<DB, TB, O, QA, QO> : never;
 type RightJoinedBuilder<DB, TB extends keyof DB, O, A extends keyof any, R> = SelectQueryBuilder<RightJoinedDB<DB, TB, A, R>, TB | A, O>;
 type RightJoinedDB<DB, TB extends keyof DB, A extends keyof any, R> = DrainOuterGeneric<{
     [C in keyof DB | A]: C extends A ? R : C extends TB ? Nullable<DB[C]> : C extends keyof DB ? DB[C] : never;
 }>;
-export type SelectQueryBuilderWithFullJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? OuterJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? OuterJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? OuterJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? OuterJoinedBuilder<DB, TB, O, QA, QO> : never;
+export type SelectQueryBuilderWithFullJoin<DB, TB extends keyof DB, O, TE extends TableExpression<DB, TB>> = TableExpression<DB, TB> extends TE ? JoinResultForUnknownTable<O> : TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? OuterJoinedBuilder<DB, TB, O, A, DB[T]> : never : TE extends keyof DB ? OuterJoinedBuilder<DB, TB, O, TE, DB[TE]> : TE extends AliasedExpression<infer QO, infer QA> ? OuterJoinedBuilder<DB, TB, O, QA, QO> : TE extends (qb: any) => AliasedExpression<infer QO, infer QA> ? OuterJoinedBuilder<DB, TB, O, QA, QO> : never;
 type OuterJoinedBuilder<DB, TB extends keyof DB, O, A extends keyof any, R> = SelectQueryBuilder<OuterJoinedBuilderDB<DB, TB, A, R>, TB | A, O>;
 type OuterJoinedBuilderDB<DB, TB extends keyof DB, A extends keyof any, R> = DrainOuterGeneric<{
     [C in keyof DB | A]: C extends A ? Nullable<R> : C extends TB ? Nullable<DB[C]> : C extends keyof DB ? DB[C] : never;

package/dist/query-builder/update-query-builder.d.ts

@@ -1148,7 +1148,7 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * }>
      * ```
      */
-    $if<O2>(condition: boolean, func: (qb: this) => UpdateQueryBuilder<any, any, any, O2>): O2 extends UpdateResult ? UpdateQueryBuilder<DB, UT, TB, UpdateResult> : O2 extends O & infer E ? UpdateQueryBuilder<DB, UT, TB, O & Partial<E>> : UpdateQueryBuilder<DB, UT, TB, Partial<O2>>;
+    $if<O2>(condition: boolean, func: (qb: this) => UpdateQueryBuilder<any, any, any, O2>): unknown extends O2 ? UpdateQueryBuilder<any, any, any, O2> : O2 extends UpdateResult ? UpdateQueryBuilder<DB, UT, TB, UpdateResult> : O2 extends O & infer E ? UpdateQueryBuilder<DB, UT, TB, O & Partial<E>> : UpdateQueryBuilder<DB, UT, TB, Partial<O2>>;
     /**
      * Change the output type of the query.
      *

package/dist/query-creator.d.ts

@@ -12,8 +12,17 @@ import type { SelectFrom } from './parser/select-from-parser.js';
 import type { DeleteFrom } from './parser/delete-from-parser.js';
 import type { UpdateTable } from './parser/update-parser.js';
 import type { MergeInto } from './parser/merge-into-parser.js';
+import type { IsAny } from './util/type-utils.js';
+import type { Insertable, Selectable, Updateable } from './util/column-type.js';
 export declare class QueryCreator<DB> {
     #private;
+    protected readonly '~DB': IsAny<DB> extends true ? any : {
+        [T in keyof DB]: {
+            select: () => Selectable<DB[T]>;
+            insert: (row: Insertable<DB[T]>) => void;
+            update: (row: Updateable<DB[T]>) => void;
+        };
+    };
     constructor(props: QueryCreatorProps);
     /**
      * Creates a `select` query builder for the given table or tables.

package/dist/raw-builder/raw-builder.d.ts

@@ -6,6 +6,7 @@ import type { QueryExecutorProvider } from '../query-executor/query-executor-pro
 import type { QueryId } from '../util/query-id.js';
 import type { AliasableExpression, AliasedExpression, Expression } from '../expression/expression.js';
 import type { AbortableQueryOptions } from '../util/abort.js';
+import type { StreamOptions } from '../util/streamable.js';
 /**
  * An instance of this class can be used to create raw SQL snippets or queries.
  *
@@ -181,6 +182,10 @@ export interface RawBuilder<O> extends AliasableExpression<O> {
      * ```
      */
     execute(executorProvider: QueryExecutorProvider, options?: AbortableQueryOptions): Promise<QueryResult<O>>;
+    /**
+     * Executes the raw query and streams the rows.
+     */
+    stream(executorOrProvider: QueryExecutorProvider, options?: StreamOptions | StreamOptions['chunkSize']): AsyncIterableIterator<O>;
     /**
      * Creates the OperationNode that describes how to compile this expression into SQL.
      *

package/dist/raw-builder/raw-builder.js

@@ -42,6 +42,18 @@ class RawBuilderImpl {
         const executor = this.#getExecutor(executorProvider);
         return executor.executeQuery(this.#compile(executor), options);
     }
+    async *stream(executorProvider, chunkSizeOrOptions) {
+        const executor = this.#getExecutor(executorProvider);
+        if (typeof chunkSizeOrOptions !== 'object') {
+            chunkSizeOrOptions = {
+                chunkSize: chunkSizeOrOptions,
+            };
+        }
+        const stream = executor.stream(this.#compile(executor), chunkSizeOrOptions.chunkSize ?? 100, chunkSizeOrOptions);
+        for await (const item of stream) {
+            yield* item.rows;
+        }
+    }
     #getExecutor(executorProvider) {
         const executor = executorProvider !== undefined
             ? executorProvider.getExecutor()

package/dist/readonly/readonly-kysely.d.ts

@@ -5,11 +5,11 @@ import type { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import type { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import type { AbortableOperationOptions, AbortableQueryOptions } from '../util/abort.js';
 import type { KyselyTypeError } from '../util/type-error.js';
-import type { DrainOuterGeneric } from '../util/type-utils.js';
 import type { ReadonlyCompiledQuery } from './readonly-compiled-query.js';
 import type { ReadonlyQueryResult } from './readonly-database-connection.js';
 import type { ReadonlyAccessMode } from './readonly-driver.js';
 import type { ReadonlyQueryCreator } from './readonly-query-creator.js';
+export type { ReadonlyKysely, ReadonlyTransaction, ReadonlyControlledTransaction, };
 /**
  * A helper type that allows you to expose a type-level read-only {@link Kysely} version
  * to your service's consumers.
@@ -43,7 +43,13 @@ import type { ReadonlyQueryCreator } from './readonly-query-creator.js';
  * db.deleteFrom('person') // typescript compiler error!
  * ```
  */
-export interface ReadonlyKysely<DB> extends ReadonlyQueryCreator<DB>, Pick<Kysely<DB>, 'case' | 'destroy' | 'dynamic' | 'fn' | 'introspection' | 'isTransaction'> {
+declare class ReadonlyKysely<DB> extends ReadonlyQueryCreator<DB> {
+    case: Kysely<DB>['case'];
+    destroy: Kysely<DB>['destroy'];
+    get dynamic(): Kysely<DB>['dynamic'];
+    readonly fn: Kysely<DB>['fn'];
+    get introspection(): Kysely<DB>['introspection'];
+    get isTransaction(): Kysely<DB>['isTransaction'];
     /**
      * Similar to {@link Kysely.connection} but read-only.
      */
@@ -89,11 +95,11 @@ export interface ReadonlyKysely<DB> extends ReadonlyQueryCreator<DB>, Pick<Kysel
      *
      * @deprecated use {@link $extendTables} instead.
      */
-    withTables<T extends Record<string, Record<string, any>>>(): ReadonlyKysely<DrainOuterGeneric<DB & T>>;
+    withTables<T extends Record<string, Record<string, any>>>(): ReadonlyKysely<DB & T>;
     /**
      * Similar to {@link Kysely.$extendTables} but read-only.
      */
-    $extendTables<T extends Record<string, Record<string, any>>>(): ReadonlyKysely<DrainOuterGeneric<DB & T>>;
+    $extendTables<T extends Record<string, Record<string, any>>>(): ReadonlyKysely<DB & T>;
     /**
      * Similar to {@link Kysely.$omitTables} but read-only.
      */
@@ -132,7 +138,24 @@ export interface ReadonlyTransactionBuilder<DB> {
 /**
  * Similar to {@link Transaction} but read-only.
  */
-export interface ReadonlyTransaction<DB> extends Pick<ReadonlyKysely<DB>, 'case' | 'deleteFrom' | 'dynamic' | 'executeQuery' | 'fn' | 'getExecutor' | 'insertInto' | 'introspection' | 'mergeInto' | 'replaceInto' | 'schema' | 'selectFrom' | 'selectNoFrom' | 'updateTable' | 'with' | 'withRecursive'>, Pick<Transaction<DB>, 'connection' | 'destroy' | 'isTransaction' | 'startTransaction' | 'transaction'> {
+declare class ReadonlyTransaction<DB> extends ReadonlyKysely<DB> {
+    /**
+     * @deprecated calling the connection method for a Transaction is not supported
+     */
+    connection(): never;
+    /**
+     * @deprecated calling the destroy method for a Transaction is not supported
+     */
+    destroy: Transaction<DB>['destroy'];
+    get isTransaction(): true;
+    /**
+     * @deprecated calling the controlled transaction method for a Transaction is not supported
+     */
+    startTransaction(): never;
+    /**
+     * @deprecated calling the transaction method for a Transaction is not supported
+     */
+    transaction(): never;
     /**
      * Similar to {@link Transaction.withoutPlugins} but read-only.
      */
@@ -150,19 +173,32 @@ export interface ReadonlyTransaction<DB> extends Pick<ReadonlyKysely<DB>, 'case'
      *
      * @deprecated use {@link $extendTables} instead.
      */
-    withTables<T extends Record<string, Record<string, any>>>(): ReadonlyTransaction<DrainOuterGeneric<DB & T>>;
+    withTables<T extends Record<string, Record<string, any>>>(): ReadonlyTransaction<DB & T>;
+    /**
+     * Similar to {@link Kysely.withTables} but read-only.
+     *
+     * @deprecated use {@link $extendTables} instead.
+     */
+    withTables<T extends Record<string, Record<string, any>>>(): ReadonlyKysely<DB & T>;
+    withTables<T extends Record<string, Record<string, any>>>(): ReadonlyTransaction<DB & T>;
     /**
      * Similar to {@link Transaction.$extendTables} but read-only.
      */
-    $extendTables<T extends Record<string, Record<string, any>>>(): ReadonlyTransaction<DrainOuterGeneric<DB & T>>;
+    $extendTables<T extends Record<string, Record<string, any>>>(): ReadonlyTransaction<DB & T>;
+    $extendTables<T extends Record<string, Record<string, any>>>(): ReadonlyKysely<DB & T>;
+    $extendTables<T extends Record<string, Record<string, any>>>(): ReadonlyTransaction<DB & T>;
     /**
      * Similar to {@link Transaction.$omitTables} but read-only.
      */
     $omitTables<T extends keyof DB>(): ReadonlyTransaction<DB extends object ? Omit<DB, T> : DB>;
+    $omitTables<T extends keyof DB>(): ReadonlyKysely<DB extends object ? Omit<DB, T> : DB>;
+    $omitTables<T extends keyof DB>(): ReadonlyTransaction<DB extends object ? Omit<DB, T> : DB>;
     /**
      * Similar to {@link Transaction.$pickTables} but read-only.
      */
     $pickTables<T extends keyof DB>(): ReadonlyTransaction<DB extends object ? Pick<DB, T> : DB>;
+    $pickTables<T extends keyof DB>(): ReadonlyKysely<DB extends object ? Pick<DB, T> : DB>;
+    $pickTables<T extends keyof DB>(): ReadonlyTransaction<DB extends object ? Pick<DB, T> : DB>;
 }
 /**
  * Similar to {@link ControlledTransactionBuilder} but read-only.
@@ -184,7 +220,11 @@ export interface ReadonlyControlledTransactionBuilder<DB> {
 /**
  * Similar to {@link ControlledTransaction} but read-only.
  */
-export interface ReadonlyControlledTransaction<DB, S extends string[] = []> extends ReadonlyTransaction<DB>, Pick<ControlledTransaction<DB, S>, 'commit' | 'isCommitted' | 'isRolledBack' | 'rollback'> {
+declare class ReadonlyControlledTransaction<DB, S extends string[] = []> extends ReadonlyTransaction<DB> {
+    commit: ControlledTransaction<DB, S>['commit'];
+    get isCommitted(): ControlledTransaction<DB, S>['isCommitted'];
+    get isRolledBack(): ControlledTransaction<DB, S>['isRolledBack'];
+    rollback: ControlledTransaction<DB, S>['rollback'];
     /**
      * Similar to {@link ControlledTransaction.releaseSavepoint} but read-only.
      */
@@ -214,17 +254,31 @@ export interface ReadonlyControlledTransaction<DB, S extends string[] = []> exte
      *
      * @deprecated use {@link $extendTables} instead.
      */
-    withTables<T extends Record<string, Record<string, any>>>(): ReadonlyControlledTransaction<DrainOuterGeneric<DB & T>, S>;
+    withTables<T extends Record<string, Record<string, any>>>(): ReadonlyControlledTransaction<DB & T, S>;
+    /**
+     * Similar to {@link Transaction.withTables} but read-only.
+     *
+     * @deprecated use {@link $extendTables} instead.
+     */
+    withTables<T extends Record<string, Record<string, any>>>(): ReadonlyKysely<DB & T>;
+    withTables<T extends Record<string, Record<string, any>>>(): ReadonlyControlledTransaction<DB & T, S>;
     /**
      * Similar to {@link ControlledTransaction.$extendTables} but read-only.
      */
-    $extendTables<T extends Record<string, Record<string, any>>>(): ReadonlyControlledTransaction<DrainOuterGeneric<DB & T>, S>;
+    $extendTables<T extends Record<string, Record<string, any>>>(): ReadonlyControlledTransaction<DB & T, S>;
+    $extendTables<T extends Record<string, Record<string, any>>>(): ReadonlyKysely<DB & T>;
+    $extendTables<T extends Record<string, Record<string, any>>>(): ReadonlyControlledTransaction<DB & T, S>;
     /**
      * Similar to {@link ControlledTransaction.$omitTables} but read-only.
      */
     $omitTables<T extends keyof DB>(): ReadonlyControlledTransaction<DB extends object ? Omit<DB, T> : DB, S>;
+    $omitTables<T extends keyof DB>(): ReadonlyKysely<DB extends object ? Omit<DB, T> : DB>;
+    $omitTables<T extends keyof DB>(): ReadonlyTransaction<DB extends object ? Omit<DB, T> : DB>;
+    $omitTables<T extends keyof DB>(): ReadonlyControlledTransaction<DB extends object ? Omit<DB, T> : DB, S>;
     /**
      * Similar to {@link ControlledTransaction.$pickTables} but read-only.
      */
     $pickTables<T extends keyof DB>(): ReadonlyControlledTransaction<DB extends object ? Pick<DB, T> : DB, S>;
+    $pickTables<T extends keyof DB>(): ReadonlyKysely<DB extends object ? Pick<DB, T> : DB>;
+    $pickTables<T extends keyof DB>(): ReadonlyControlledTransaction<DB extends object ? Pick<DB, T> : DB, S>;
 }

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

@@ -1,11 +1,19 @@
 import type { CTEBuilderCallback } from '../query-builder/cte-builder.js';
 import type { QueryCreator } from '../query-creator.js';
+import type { Selectable } from '../util/column-type.js';
+import type { IsAny } from '../util/type-utils.js';
 import type { KyselyTypeError } from '../util/type-error.js';
 import type { ReadonlyCommonTableExpression, ReadonlyQueryCreatorWithCommonTableExpression, ReadonlyRecursiveCommonTableExpression } from './readonly-with-parser.js';
+export type { ReadonlyQueryCreator };
 /**
  * Similar to {@link QueryCreator} but read-only.
  */
-export interface ReadonlyQueryCreator<DB> extends Pick<QueryCreator<DB>, 'selectFrom' | 'selectNoFrom'> {
+declare class ReadonlyQueryCreator<DB> {
+    protected readonly '~DB': IsAny<DB> extends true ? any : {
+        [T in keyof DB]: Selectable<DB[T]>;
+    };
+    selectFrom: QueryCreator<DB>['selectFrom'];
+    selectNoFrom: QueryCreator<DB>['selectNoFrom'];
     /**
      * @deprecated not allowed with a read-only Kysely instance.
      */

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

@@ -10,7 +10,7 @@ export declare class CreateTypeBuilder implements OperationNodeSource, Compilabl
     constructor(props: CreateTypeBuilderProps);
     toOperationNode(): CreateTypeNode;
     /**
-     * Creates an anum type.
+     * Creates an enum type.
      *
      * ### Examples
      *

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

@@ -10,7 +10,7 @@ export class CreateTypeBuilder {
         return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
     }
     /**
-     * Creates an anum type.
+     * Creates an enum type.
      *
      * ### Examples
      *

package/dist/util/abort.js

@@ -8,6 +8,7 @@ export function getInflightQueryAbortHandler(abortStrategy = 'ignore query', con
     if (abortStrategy === 'cancel query') {
         const handler = connection.cancelQuery;
         if (!handler) {
+            beforeThrow();
             throwUnsupportedInflightQueryAbortStrategyError(abortStrategy, connection.killSession ? 'kill session' : undefined);
         }
         return handler.bind(connection);
@@ -15,6 +16,7 @@ export function getInflightQueryAbortHandler(abortStrategy = 'ignore query', con
     if (abortStrategy === 'kill session') {
         const handler = connection.killSession;
         if (!handler) {
+            beforeThrow();
             throwUnsupportedInflightQueryAbortStrategyError(abortStrategy, connection.cancelQuery ? 'cancel query' : undefined);
         }
         return handler.bind(connection);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely",
-  "version": "0.30.0-beta.1",
+  "version": "0.30.0-beta.2",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",
@@ -63,39 +63,40 @@
   "devDependencies": {
     "@arethetypeswrong/cli": "0.18.5",
     "@electric-sql/pglite": "0.5.4",
-    "@types/better-sqlite3": "7.6.13",
+    "@types/better-sqlite3": "9.6.0",
     "@types/chai": "5.2.3",
     "@types/chai-as-promised": "8.0.2",
     "@types/mocha": "10.0.10",
-    "@types/node": "26.1.1",
-    "@types/pg": "8.20.0",
+    "@types/node": "26.2.0",
+    "@types/pg": "8.21.0",
     "@types/pg-cursor": "2.7.2",
     "@types/prototype-pollution-vulnerable-lodash.merge-dont-upgrade": "npm:@types/lodash.merge@4.6.1",
-    "@types/semver": "7.7.1",
+    "@types/semver": "7.8.0",
     "@types/sinon": "22.0.0",
-    "better-sqlite3": "12.11.1",
+    "better-sqlite3": "13.0.3",
     "chai": "6.2.2",
     "chai-as-promised": "8.0.2",
-    "esbuild": "0.28.1",
+    "esbuild": "0.28.2",
     "jsr": "0.14.3",
-    "mocha": "11.7.6",
-    "mysql2": "3.23.0",
+    "mocha": "11.8.0",
+    "mysql2": "3.23.3",
     "pathe": "2.0.3",
-    "pg": "8.22.0",
-    "pg-cursor": "2.21.0",
-    "playwright": "1.61.1",
-    "prettier": "3.9.5",
+    "pg": "8.23.0",
+    "pg-cursor": "2.22.0",
+    "playwright": "1.62.1",
+    "prettier": "3.9.6",
     "prototype-pollution-vulnerable-lodash.merge-dont-upgrade": "npm:lodash.merge@4.6.1",
     "remeda": "2.39.0",
     "semver": "7.8.5",
-    "sinon": "22.0.0",
+    "sinon": "22.1.0",
     "std-env": "4.2.0",
     "tarn": "3.1.2",
     "tedious": "20.0.0",
     "tsd": "0.33.0",
-    "tsx": "4.23.1",
+    "tsx": "4.23.12",
     "typescript": "7.0.2",
-    "typescript-6": "npm:typescript@6.0.3"
+    "typescript-6": "npm:typescript@6.0.3",
+    "vitest": "5.0.0"
   },
   "scripts": {
     "clean": "rm -rf dist & rm -rf test/node/dist & rm -rf test/browser/bundle.js",
@@ -110,6 +111,7 @@
     "test:cloudflare-workers": "pnpm build && pnpm -r test --filter kysely-cloudflare-workers-test",
     "test:deno": "deno run --allow-env --allow-read --allow-net --no-lock test/deno/test.ts",
     "test:typings": "tsd test/typings",
+    "test:typings:vitest": "vitest run --config test/typings/vitest.config.ts",
     "test:esmimports": "node scripts/check-esm-imports.cjs",
     "test:esbuild": "esbuild --bundle --platform=node --external:pg-native dist/index.js --outfile=/dev/null",
     "test:exports": "attw --profile esm-only --pack . && node scripts/check-exports.cjs",