kysely 0.30.0-beta.0 → 0.30.0-beta.2

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/file-migration-provider.d.ts

@@ -6,7 +6,7 @@ import type { MigrationProvider } from './migrator.js';
  * ### Examples
  *
  * ```ts
- * import { promises as fs } from 'node:fs'
+ * import fs from 'node:fs/promises'
  * import path from 'node:path'
  *
  * new FileMigrationProvider({

package/dist/migration/file-migration-provider.js

@@ -6,7 +6,7 @@ import { isFunction, isObject } from '../util/object-utils.js';
  * ### Examples
  *
  * ```ts
- * import { promises as fs } from 'node:fs'
+ * import fs from 'node:fs/promises'
  * import path from 'node:path'
  *
  * new FileMigrationProvider({

package/dist/migration/migrator.d.ts

@@ -16,7 +16,7 @@ export declare const NO_MIGRATIONS: NoMigrations;
  * other way.
  *
  * ```ts
- * import { promises as fs } from 'node:fs'
+ * import fs from 'node:fs/promises'
  * import path from 'node:path'
  * import * as Sqlite from 'better-sqlite3'
  * import { Kysely, SqliteDialect } from 'kysely'
@@ -64,7 +64,7 @@ export declare class Migrator {
      * ### Examples
      *
      * ```ts
-     * import { promises as fs } from 'node:fs'
+     * import fs from 'node:fs/promises'
      * import path from 'node:path'
      * import * as Sqlite from 'better-sqlite3'
      * import { FileMigrationProvider, Migrator } from 'kysely/migration'
@@ -106,7 +106,7 @@ export declare class Migrator {
      * ### Examples
      *
      * ```ts
-     * import { promises as fs } from 'node:fs'
+     * import fs from 'node:fs/promises'
      * import path from 'node:path'
      * import { FileMigrationProvider, Migrator } from 'kysely/migration'
      *
@@ -129,7 +129,7 @@ export declare class Migrator {
      * you can use a special constant `NO_MIGRATIONS`:
      *
      * ```ts
-     * import { promises as fs } from 'node:fs'
+     * import fs from 'node:fs/promises'
      * import path from 'node:path'
      * import { FileMigrationProvider, Migrator, NO_MIGRATIONS } from 'kysely/migration'
      *
@@ -145,8 +145,33 @@ export declare class Migrator {
      *
      * await migrator.migrateTo(NO_MIGRATIONS)
      * ```
+     *
+     * By default, this method migrates up or down depending on which side of the
+     * current migration state the target migration is on. Pass
+     * {@link MigrateToOptions.direction} to enforce a direction — if reaching the
+     * target would require migrating the other way, nothing is executed and
+     * {@link MigrationResultSet.error} holds an error:
+     *
+     * ```ts
+     * import fs from 'node:fs/promises'
+     * import path from 'node:path'
+     * import { FileMigrationProvider, Migrator } from 'kysely/migration'
+     *
+     * const migrator = new Migrator({
+     *   db,
+     *   provider: new FileMigrationProvider({
+     *     fs,
+     *     // Path to the folder that contains all your migrations.
+     *     migrationFolder: 'some/path/to/migrations',
+     *     path,
+     *   })
+     * })
+     *
+     * // Errors if `some_migration` is already executed.
+     * await migrator.migrateTo('some_migration', { direction: 'Up' })
+     * ```
      */
-    migrateTo(targetMigrationName: string | NoMigrations, options?: MigrateOptions): Promise<MigrationResultSet>;
+    migrateTo(targetMigrationName: string | NoMigrations, options?: MigrateToOptions): Promise<MigrationResultSet>;
     /**
      * Migrate one step up.
      *
@@ -158,7 +183,7 @@ export declare class Migrator {
      * ### Examples
      *
      * ```ts
-     * import { promises as fs } from 'node:fs'
+     * import fs from 'node:fs/promises'
      * import path from 'node:path'
      * import { FileMigrationProvider, Migrator } from 'kysely/migration'
      *
@@ -187,7 +212,7 @@ export declare class Migrator {
      * ### Examples
      *
      * ```ts
-     * import { promises as fs } from 'node:fs'
+     * import fs from 'node:fs/promises'
      * import path from 'node:path'
      * import { FileMigrationProvider, Migrator } from 'kysely/migration'
      *
@@ -257,6 +282,21 @@ export interface MigrateOptions {
     readonly transactionMode?: MigratorTransactionMode;
 }
 export type MigratorTransactionMode = 'per-run' | 'per-migration' | 'none';
+export interface MigrateToOptions extends MigrateOptions {
+    /**
+     * Enforces a migration direction.
+     *
+     * When provided and reaching the target migration would require migrating
+     * the other way, nothing is executed and {@link MigrationResultSet.error}
+     * holds an error. For example, `direction: 'Up'` errors when the target
+     * migration is already executed.
+     *
+     * By default, {@link Migrator.migrateTo | migrateTo} migrates up or down
+     * depending on which side of the current migration state the target
+     * migration is on.
+     */
+    readonly direction?: MigrationDirection;
+}
 export interface MigratorProps extends MigrateOptions {
     readonly db: Kysely<any>;
     readonly provider: MigrationProvider;
@@ -359,7 +399,7 @@ export interface MigrationResultSet {
      */
     readonly results?: MigrationResult[];
 }
-type MigrationDirection = 'Up' | 'Down';
+export type MigrationDirection = 'Up' | 'Down';
 export interface MigrationResult {
     readonly migrationName: string;
     /**
@@ -422,4 +462,3 @@ export interface MigrationInfo {
      */
     executedAt?: Date;
 }
-export {};

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';
@@ -19,7 +20,7 @@ export const NO_MIGRATIONS = freeze({ __noMigrations__: true });
  * other way.
  *
  * ```ts
- * import { promises as fs } from 'node:fs'
+ * import fs from 'node:fs/promises'
  * import path from 'node:path'
  * import * as Sqlite from 'better-sqlite3'
  * import { Kysely, SqliteDialect } from 'kysely'
@@ -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)
@@ -88,7 +89,7 @@ export class Migrator {
      * ### Examples
      *
      * ```ts
-     * import { promises as fs } from 'node:fs'
+     * import fs from 'node:fs/promises'
      * import path from 'node:path'
      * import * as Sqlite from 'better-sqlite3'
      * import { FileMigrationProvider, Migrator } from 'kysely/migration'
@@ -132,7 +133,7 @@ export class Migrator {
      * ### Examples
      *
      * ```ts
-     * import { promises as fs } from 'node:fs'
+     * import fs from 'node:fs/promises'
      * import path from 'node:path'
      * import { FileMigrationProvider, Migrator } from 'kysely/migration'
      *
@@ -155,7 +156,7 @@ export class Migrator {
      * you can use a special constant `NO_MIGRATIONS`:
      *
      * ```ts
-     * import { promises as fs } from 'node:fs'
+     * import fs from 'node:fs/promises'
      * import path from 'node:path'
      * import { FileMigrationProvider, Migrator, NO_MIGRATIONS } from 'kysely/migration'
      *
@@ -171,11 +172,39 @@ export class Migrator {
      *
      * await migrator.migrateTo(NO_MIGRATIONS)
      * ```
+     *
+     * By default, this method migrates up or down depending on which side of the
+     * current migration state the target migration is on. Pass
+     * {@link MigrateToOptions.direction} to enforce a direction — if reaching the
+     * target would require migrating the other way, nothing is executed and
+     * {@link MigrationResultSet.error} holds an error:
+     *
+     * ```ts
+     * import fs from 'node:fs/promises'
+     * import path from 'node:path'
+     * import { FileMigrationProvider, Migrator } from 'kysely/migration'
+     *
+     * const migrator = new Migrator({
+     *   db,
+     *   provider: new FileMigrationProvider({
+     *     fs,
+     *     // Path to the folder that contains all your migrations.
+     *     migrationFolder: 'some/path/to/migrations',
+     *     path,
+     *   })
+     * })
+     *
+     * // Errors if `some_migration` is already executed.
+     * await migrator.migrateTo('some_migration', { direction: 'Up' })
+     * ```
      */
     async migrateTo(targetMigrationName, options) {
         return this.#migrate(({ migrations, executedMigrations, pendingMigrations, }) => {
             if (isObject(targetMigrationName) &&
                 targetMigrationName.__noMigrations__ === true) {
+                if (options?.direction === 'Up') {
+                    throw new Error(`can't migrate up to NO_MIGRATIONS`);
+                }
                 return { direction: 'Down', step: Infinity };
             }
             if (!migrations.find((m) => m.name === targetMigrationName)) {
@@ -184,12 +213,18 @@ export class Migrator {
             const executedIndex = executedMigrations.indexOf(targetMigrationName);
             const pendingIndex = pendingMigrations.findIndex((m) => m.name === targetMigrationName);
             if (executedIndex !== -1) {
+                if (options?.direction === 'Up') {
+                    throw new Error(`migration "${targetMigrationName}" is already executed; can't migrate up to it`);
+                }
                 return {
                     direction: 'Down',
                     step: executedMigrations.length - executedIndex - 1,
                 };
             }
             if (pendingIndex !== -1) {
+                if (options?.direction === 'Down') {
+                    throw new Error(`migration "${targetMigrationName}" isn't executed; can't migrate down to it`);
+                }
                 return { direction: 'Up', step: pendingIndex + 1 };
             }
             throw new Error(`migration "${targetMigrationName}" isn't executed or pending`);
@@ -206,7 +241,7 @@ export class Migrator {
      * ### Examples
      *
      * ```ts
-     * import { promises as fs } from 'node:fs'
+     * import fs from 'node:fs/promises'
      * import path from 'node:path'
      * import { FileMigrationProvider, Migrator } from 'kysely/migration'
      *
@@ -237,7 +272,7 @@ export class Migrator {
      * ### Examples
      *
      * ```ts
-     * import { promises as fs } from 'node:fs'
+     * import fs from 'node:fs/promises'
      * import path from 'node:path'
      * import { FileMigrationProvider, Migrator } from 'kysely/migration'
      *
@@ -295,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;
         }
@@ -303,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.
@@ -313,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;
         }
@@ -327,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.
@@ -337,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;
         }
@@ -349,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.
@@ -377,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.
      *