kysely 0.28.1 → 0.28.3

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

@@ -6,6 +6,7 @@ import { randomString } from '../../util/random-string.js';
 import { Deferred } from '../../util/deferred.js';
 const PRIVATE_RESET_METHOD = Symbol();
 const PRIVATE_DESTROY_METHOD = Symbol();
+const PRIVATE_VALIDATE_METHOD = Symbol();
 export class MssqlDriver {
     #config;
     #pool;
@@ -27,7 +28,7 @@ export class MssqlDriver {
             validate: validateConnections === false ||
                 deprecatedValidateConnections === false
                 ? undefined
-                : (connection) => connection.validate(),
+                : (connection) => connection[PRIVATE_VALIDATE_METHOD](),
         });
     }
     async init() {
@@ -64,14 +65,12 @@ export class MssqlDriver {
 }
 class MssqlConnection {
     #connection;
+    #hasSocketError;
     #tedious;
     constructor(connection, tedious) {
         this.#connection = connection;
+        this.#hasSocketError = false;
         this.#tedious = tedious;
-        this.#connection.on('error', console.error);
-        this.#connection.once('end', () => {
-            this.#connection.off('error', console.error);
-        });
     }
     async beginTransaction(settings) {
         const { isolationLevel } = settings;
@@ -93,17 +92,28 @@ class MssqlConnection {
         }));
     }
     async connect() {
-        await new Promise((resolve, reject) => {
-            this.#connection.connect((error) => {
-                if (error) {
-                    console.error(error);
-                    reject(error);
-                }
-                else {
-                    resolve(undefined);
-                }
-            });
+        const { promise: waitForConnected, reject, resolve } = new Deferred();
+        this.#connection.connect((error) => {
+            if (error) {
+                return reject(error);
+            }
+            resolve();
         });
+        this.#connection.on('error', (error) => {
+            if (error instanceof Error &&
+                'code' in error &&
+                error.code === 'ESOCKET') {
+                this.#hasSocketError = true;
+            }
+            console.error(error);
+            reject(error);
+        });
+        function endListener() {
+            reject(new Error('The connection ended without ever completing the connection'));
+        }
+        this.#connection.once('end', endListener);
+        await waitForConnected;
+        this.#connection.off('end', endListener);
         return this;
     }
     async executeQuery(compiledQuery) {
@@ -167,22 +177,6 @@ class MssqlConnection {
             await this.#cancelRequest(request);
         }
     }
-    async validate() {
-        try {
-            const deferred = new Deferred();
-            const request = new MssqlRequest({
-                compiledQuery: CompiledQuery.raw('select 1'),
-                onDone: deferred,
-                tedious: this.#tedious,
-            });
-            this.#connection.execSql(request.request);
-            await deferred.promise;
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
     #getTediousIsolationLevel(isolationLevel) {
         const { ISOLATION_LEVEL } = this.#tedious;
         const mapper = {
@@ -204,27 +198,50 @@ class MssqlConnection {
             const wasCanceled = this.#connection.cancel();
             if (!wasCanceled) {
                 request.request.off('requestCompleted', resolve);
-                resolve(undefined);
+                resolve();
             }
         });
     }
+    [PRIVATE_DESTROY_METHOD]() {
+        if ('closed' in this.#connection && this.#connection.closed) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+            this.#connection.once('end', resolve);
+            this.#connection.close();
+        });
+    }
     async [PRIVATE_RESET_METHOD]() {
         await new Promise((resolve, reject) => {
             this.#connection.reset((error) => {
-                if (error)
-                    reject(error);
-                else
-                    resolve(undefined);
+                if (error) {
+                    return reject(error);
+                }
+                resolve();
             });
         });
     }
-    [PRIVATE_DESTROY_METHOD]() {
-        return new Promise((resolve) => {
-            this.#connection.once('end', () => {
-                resolve(undefined);
+    async [PRIVATE_VALIDATE_METHOD]() {
+        if (this.#hasSocketError || this.#isConnectionClosed()) {
+            return false;
+        }
+        try {
+            const deferred = new Deferred();
+            const request = new MssqlRequest({
+                compiledQuery: CompiledQuery.raw('select 1'),
+                onDone: deferred,
+                tedious: this.#tedious,
             });
-            this.#connection.close();
-        });
+            this.#connection.execSql(request.request);
+            await deferred.promise;
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    #isConnectionClosed() {
+        return 'closed' in this.#connection && Boolean(this.#connection.closed);
     }
 }
 class MssqlRequest {
@@ -248,23 +265,19 @@ class MssqlRequest {
                 }
                 delete this.#subscribers[subscriptionKey];
                 if (event === 'error') {
-                    onDone.reject(error);
-                }
-                else {
-                    onDone.resolve({
-                        rowCount: this.#rowCount,
-                        rows: this.#rows,
-                    });
+                    return onDone.reject(error);
                 }
+                onDone.resolve({
+                    rowCount: this.#rowCount,
+                    rows: this.#rows,
+                });
             };
         }
         this.#request = new this.#tedious.Request(compiledQuery.sql, (err, rowCount) => {
             if (err) {
-                Object.values(this.#subscribers).forEach((subscriber) => subscriber('error', err instanceof AggregateError ? err.errors : err));
-            }
-            else {
-                this.#rowCount = rowCount;
+                return Object.values(this.#subscribers).forEach((subscriber) => subscriber('error', err instanceof AggregateError ? err.errors : err));
             }
+            this.#rowCount = rowCount;
         });
         this.#addParametersToRequest(compiledQuery.parameters);
         this.#attachListeners();
@@ -278,11 +291,9 @@ class MssqlRequest {
             this.#subscribers[subscriptionKey] = (event, error) => {
                 delete this.#subscribers[subscriptionKey];
                 if (event === 'error') {
-                    reject(error);
-                }
-                else {
-                    resolve(this.#rows.splice(0, this.#streamChunkSize));
+                    return reject(error);
                 }
+                resolve(this.#rows.splice(0, this.#streamChunkSize));
             };
             this.#request.resume();
         });

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

@@ -46,6 +46,8 @@ export class PostgresIntrospector {
         ])
             .where('ns.nspname', '!~', '^pg_')
             .where('ns.nspname', '!=', 'information_schema')
+            // Filter out internal cockroachdb schema
+            .where('ns.nspname', '!=', 'crdb_internal')
             // No system columns
             .where('a.attnum', '>=', 0)
             .where('a.attisdropped', '!=', true)

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

@@ -49,7 +49,8 @@ export class SqliteIntrospector {
             'p.dflt_value',
             'p.pk',
         ])
-            .orderBy(['tl.name', 'p.cid'])
+            .orderBy('tl.name')
+            .orderBy('p.cid')
             .execute();
         const columnsByTable = {};
         for (const row of tableMetadata) {

package/dist/esm/dynamic/dynamic-table-builder.d.ts

@@ -0,0 +1,16 @@
+import { AliasNode } from '../operation-node/alias-node.js';
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+export declare class DynamicTableBuilder<T extends string> {
+    #private;
+    get table(): T;
+    constructor(table: T);
+    as<A extends string>(alias: A): AliasedDynamicTableBuilder<T, A>;
+}
+export declare class AliasedDynamicTableBuilder<T extends string, A extends string> implements OperationNodeSource {
+    #private;
+    get table(): T;
+    get alias(): A;
+    constructor(table: T, alias: A);
+    toOperationNode(): AliasNode;
+}
+export declare function isAliasedDynamicTableBuilder(obj: unknown): obj is AliasedDynamicTableBuilder<any, any>;

package/dist/esm/dynamic/dynamic-table-builder.js

@@ -0,0 +1,41 @@
+/// <reference types="./dynamic-table-builder.d.ts" />
+import { AliasNode } from '../operation-node/alias-node.js';
+import { IdentifierNode } from '../operation-node/identifier-node.js';
+import { isOperationNodeSource, } from '../operation-node/operation-node-source.js';
+import { parseTable } from '../parser/table-parser.js';
+import { isObject, isString } from '../util/object-utils.js';
+export class DynamicTableBuilder {
+    #table;
+    get table() {
+        return this.#table;
+    }
+    constructor(table) {
+        this.#table = table;
+    }
+    as(alias) {
+        return new AliasedDynamicTableBuilder(this.#table, alias);
+    }
+}
+export class AliasedDynamicTableBuilder {
+    #table;
+    #alias;
+    get table() {
+        return this.#table;
+    }
+    get alias() {
+        return this.#alias;
+    }
+    constructor(table, alias) {
+        this.#table = table;
+        this.#alias = alias;
+    }
+    toOperationNode() {
+        return AliasNode.create(parseTable(this.#table), IdentifierNode.create(this.#alias));
+    }
+}
+export function isAliasedDynamicTableBuilder(obj) {
+    return (isObject(obj) &&
+        isOperationNodeSource(obj) &&
+        isString(obj.table) &&
+        isString(obj.alias));
+}

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

@@ -1,5 +1,6 @@
 import { DynamicReferenceBuilder } from './dynamic-reference-builder.js';
-export declare class DynamicModule {
+import { DynamicTableBuilder } from './dynamic-table-builder.js';
+export declare class DynamicModule<DB> {
     /**
      * Creates a dynamic reference to a column that is not know at compile time.
      *
@@ -86,4 +87,38 @@ export declare class DynamicModule {
      * ```
      */
     ref<R extends string = never>(reference: string): DynamicReferenceBuilder<R>;
+    /**
+     * Creates a table reference to a table that's not fully known at compile time.
+     *
+     * The type `T` is allowed to be a union of multiple tables.
+     *
+     * <!-- siteExample("select", "Generic find query", 130) -->
+     *
+     * A generic type-safe helper function for finding a row by a column value:
+     *
+     * ```ts
+     * import { SelectType } from 'kysely'
+     * import { Database } from 'type-editor'
+     *
+     * async function getRowByColumn<
+     *   T extends keyof Database,
+     *   C extends keyof Database[T] & string,
+     *   V extends SelectType<Database[T][C]>,
+     * >(t: T, c: C, v: V) {
+     *   // We need to use the dynamic module since the table name
+     *   // is not known at compile time.
+     *   const { table, ref } = db.dynamic
+     *
+     *   return await db
+     *     .selectFrom(table(t).as('t'))
+     *     .selectAll()
+     *     .where(ref(c), '=', v)
+     *     .orderBy('t.id')
+     *     .executeTakeFirstOrThrow()
+     * }
+     *
+     * const person = await getRowByColumn('person', 'first_name', 'Arnold')
+     * ```
+     */
+    table<T extends keyof DB & string>(table: T): DynamicTableBuilder<T>;
 }

package/dist/esm/dynamic/dynamic.js

@@ -1,5 +1,6 @@
 /// <reference types="./dynamic.d.ts" />
 import { DynamicReferenceBuilder } from './dynamic-reference-builder.js';
+import { DynamicTableBuilder } from './dynamic-table-builder.js';
 export class DynamicModule {
     /**
      * Creates a dynamic reference to a column that is not know at compile time.
@@ -89,4 +90,40 @@ export class DynamicModule {
     ref(reference) {
         return new DynamicReferenceBuilder(reference);
     }
+    /**
+     * Creates a table reference to a table that's not fully known at compile time.
+     *
+     * The type `T` is allowed to be a union of multiple tables.
+     *
+     * <!-- siteExample("select", "Generic find query", 130) -->
+     *
+     * A generic type-safe helper function for finding a row by a column value:
+     *
+     * ```ts
+     * import { SelectType } from 'kysely'
+     * import { Database } from 'type-editor'
+     *
+     * async function getRowByColumn<
+     *   T extends keyof Database,
+     *   C extends keyof Database[T] & string,
+     *   V extends SelectType<Database[T][C]>,
+     * >(t: T, c: C, v: V) {
+     *   // We need to use the dynamic module since the table name
+     *   // is not known at compile time.
+     *   const { table, ref } = db.dynamic
+     *
+     *   return await db
+     *     .selectFrom(table(t).as('t'))
+     *     .selectAll()
+     *     .where(ref(c), '=', v)
+     *     .orderBy('t.id')
+     *     .executeTakeFirstOrThrow()
+     * }
+     *
+     * const person = await getRowByColumn('person', 'first_name', 'Arnold')
+     * ```
+     */
+    table(table) {
+        return new DynamicTableBuilder(table);
+    }
 }

package/dist/esm/helpers/mssql.d.ts

@@ -1,6 +1,6 @@
 import { Expression } from '../expression/expression.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
-import { Simplify } from '../util/type-utils.js';
+import { ShallowDehydrateObject, ShallowDehydrateValue, Simplify } from '../util/type-utils.js';
 /**
  * An MS SQL Server helper for aggregating a subquery into a JSON array.
  *
@@ -73,7 +73,7 @@ import { Simplify } from '../util/type-utils.js';
  * from "person"
  * ```
  */
-export declare function jsonArrayFrom<O>(expr: Expression<O>): RawBuilder<Simplify<O>[]>;
+export declare function jsonArrayFrom<O>(expr: Expression<O>): RawBuilder<Simplify<ShallowDehydrateObject<O>>[]>;
 /**
  * An MS SQL Server helper for turning a subquery into a JSON object.
  *
@@ -146,7 +146,7 @@ export declare function jsonArrayFrom<O>(expr: Expression<O>): RawBuilder<Simpli
  * from "person"
  * ```
  */
-export declare function jsonObjectFrom<O>(expr: Expression<O>): RawBuilder<Simplify<O> | null>;
+export declare function jsonObjectFrom<O>(expr: Expression<O>): RawBuilder<Simplify<ShallowDehydrateObject<O>> | null>;
 /**
  * The MS SQL Server `json_query` function, single argument variant.
  *
@@ -208,5 +208,5 @@ export declare function jsonObjectFrom<O>(expr: Expression<O>): RawBuilder<Simpl
  * ```
  */
 export declare function jsonBuildObject<O extends Record<string, Expression<unknown>>>(obj: O): RawBuilder<Simplify<{
-    [K in keyof O]: O[K] extends Expression<infer V> ? V : never;
+    [K in keyof O]: O[K] extends Expression<infer V> ? ShallowDehydrateValue<V> : never;
 }>>;

package/dist/esm/helpers/mysql.d.ts

@@ -1,7 +1,7 @@
 import { Expression } from '../expression/expression.js';
 import { SelectQueryBuilderExpression } from '../query-builder/select-query-builder-expression.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
-import { Simplify } from '../util/type-utils.js';
+import { ShallowDehydrateObject, ShallowDehydrateValue, Simplify } from '../util/type-utils.js';
 /**
  * A MySQL helper for aggregating a subquery into a JSON array.
  *
@@ -50,7 +50,7 @@ import { Simplify } from '../util/type-utils.js';
  * from `person`
  * ```
  */
-export declare function jsonArrayFrom<O>(expr: SelectQueryBuilderExpression<O>): RawBuilder<Simplify<O>[]>;
+export declare function jsonArrayFrom<O>(expr: SelectQueryBuilderExpression<O>): RawBuilder<Simplify<ShallowDehydrateObject<O>>[]>;
 /**
  * A MySQL helper for turning a subquery into a JSON object.
  *
@@ -101,7 +101,7 @@ export declare function jsonArrayFrom<O>(expr: SelectQueryBuilderExpression<O>):
  * from `person`
  * ```
  */
-export declare function jsonObjectFrom<O>(expr: SelectQueryBuilderExpression<O>): RawBuilder<Simplify<O> | null>;
+export declare function jsonObjectFrom<O>(expr: SelectQueryBuilderExpression<O>): RawBuilder<Simplify<ShallowDehydrateObject<O>> | null>;
 /**
  * The MySQL `json_object` function.
  *
@@ -143,5 +143,5 @@ export declare function jsonObjectFrom<O>(expr: SelectQueryBuilderExpression<O>)
  * ```
  */
 export declare function jsonBuildObject<O extends Record<string, Expression<unknown>>>(obj: O): RawBuilder<Simplify<{
-    [K in keyof O]: O[K] extends Expression<infer V> ? V : never;
+    [K in keyof O]: O[K] extends Expression<infer V> ? ShallowDehydrateValue<V> : never;
 }>>;

package/dist/esm/helpers/postgres.d.ts

@@ -1,6 +1,6 @@
 import { Expression } from '../expression/expression.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
-import { Simplify } from '../util/type-utils.js';
+import { ShallowDehydrateValue, ShallowDehydrateObject, Simplify } from '../util/type-utils.js';
 /**
  * A postgres helper for aggregating a subquery (or other expression) into a JSONB array.
  *
@@ -50,7 +50,7 @@ import { Simplify } from '../util/type-utils.js';
  * from "person"
  * ```
  */
-export declare function jsonArrayFrom<O>(expr: Expression<O>): RawBuilder<Simplify<O>[]>;
+export declare function jsonArrayFrom<O>(expr: Expression<O>): RawBuilder<Simplify<ShallowDehydrateObject<O>>[]>;
 /**
  * A postgres helper for turning a subquery (or other expression) into a JSON object.
  *
@@ -102,7 +102,7 @@ export declare function jsonArrayFrom<O>(expr: Expression<O>): RawBuilder<Simpli
  * from "person"
  * ```
  */
-export declare function jsonObjectFrom<O>(expr: Expression<O>): RawBuilder<Simplify<O> | null>;
+export declare function jsonObjectFrom<O>(expr: Expression<O>): RawBuilder<Simplify<ShallowDehydrateObject<O>> | null>;
 /**
  * The PostgreSQL `json_build_object` function.
  *
@@ -147,7 +147,7 @@ export declare function jsonObjectFrom<O>(expr: Expression<O>): RawBuilder<Simpl
  * ```
  */
 export declare function jsonBuildObject<O extends Record<string, Expression<unknown>>>(obj: O): RawBuilder<Simplify<{
-    [K in keyof O]: O[K] extends Expression<infer V> ? V : never;
+    [K in keyof O]: O[K] extends Expression<infer V> ? ShallowDehydrateValue<V> : never;
 }>>;
 export type MergeAction = 'INSERT' | 'UPDATE' | 'DELETE';
 /**

package/dist/esm/helpers/sqlite.d.ts

@@ -1,7 +1,7 @@
 import { Expression } from '../expression/expression.js';
 import { SelectQueryBuilderExpression } from '../query-builder/select-query-builder-expression.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
-import { Simplify } from '../util/type-utils.js';
+import { ShallowDehydrateObject, ShallowDehydrateValue, Simplify } from '../util/type-utils.js';
 /**
  * A SQLite helper for aggregating a subquery into a JSON array.
  *
@@ -63,7 +63,7 @@ import { Simplify } from '../util/type-utils.js';
  * from "person"
  * ```
  */
-export declare function jsonArrayFrom<O>(expr: SelectQueryBuilderExpression<O>): RawBuilder<Simplify<O>[]>;
+export declare function jsonArrayFrom<O>(expr: SelectQueryBuilderExpression<O>): RawBuilder<Simplify<ShallowDehydrateObject<O>>[]>;
 /**
  * A SQLite helper for turning a subquery into a JSON object.
  *
@@ -127,7 +127,7 @@ export declare function jsonArrayFrom<O>(expr: SelectQueryBuilderExpression<O>):
  * from "person";
  * ```
  */
-export declare function jsonObjectFrom<O>(expr: SelectQueryBuilderExpression<O>): RawBuilder<Simplify<O> | null>;
+export declare function jsonObjectFrom<O>(expr: SelectQueryBuilderExpression<O>): RawBuilder<Simplify<ShallowDehydrateObject<O>> | null>;
 /**
  * The SQLite `json_object` function.
  *
@@ -185,5 +185,5 @@ export declare function jsonObjectFrom<O>(expr: SelectQueryBuilderExpression<O>)
  * ```
  */
 export declare function jsonBuildObject<O extends Record<string, Expression<unknown>>>(obj: O): RawBuilder<Simplify<{
-    [K in keyof O]: O[K] extends Expression<infer V> ? V : never;
+    [K in keyof O]: O[K] extends Expression<infer V> ? ShallowDehydrateValue<V> : never;
 }>>;

package/dist/esm/index.d.ts

@@ -204,7 +204,7 @@ export * from './util/compilable.js';
 export * from './util/explainable.js';
 export * from './util/streamable.js';
 export * from './util/log.js';
-export { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, Equals, UnknownRow, Simplify, SqlBool, Nullable, NotNull, } from './util/type-utils.js';
+export { AnyAliasedColumn, AnyAliasedColumnWithTable, AnyColumn, AnyColumnWithTable, Equals, UnknownRow, Simplify, SqlBool, Nullable, NotNull, ShallowDehydrateObject, ShallowDehydrateValue, StringsWhenDataTypeNotAvailable, } from './util/type-utils.js';
 export * from './util/infer-result.js';
 export { logOnce } from './util/log-once.js';
 export { createQueryId, QueryId } from './util/query-id.js';

package/dist/esm/kysely.d.ts

@@ -18,6 +18,10 @@ import { Expression } from './expression/expression.js';
 import { DrainOuterGeneric } from './util/type-utils.js';
 import { ReleaseSavepoint, RollbackToSavepoint } from './parser/savepoint-parser.js';
 import { ControlledConnection } from './util/provide-controlled-connection.js';
+declare global {
+    interface AsyncDisposable {
+    }
+}
 /**
  * The main Kysely class.
  *
@@ -65,7 +69,7 @@ export declare class Kysely<DB> extends QueryCreator<DB> implements QueryExecuto
      * The {@link DynamicModule} module can be used to bypass strict typing and
      * passing in dynamic values for the queries.
      */
-    get dynamic(): DynamicModule;
+    get dynamic(): DynamicModule<DB>;
     /**
      * Returns a {@link DatabaseIntrospector | database introspector}.
      */

package/dist/esm/kysely.js

@@ -17,6 +17,7 @@ import { CaseNode } from './operation-node/case-node.js';
 import { parseExpression } from './parser/expression-parser.js';
 import { WithSchemaPlugin } from './plugin/with-schema/with-schema-plugin.js';
 import { provideControlledConnection, } from './util/provide-controlled-connection.js';
+import { logOnce } from './util/log-once.js';
 // @ts-ignore
 Symbol.asyncDispose ??= Symbol('Symbol.asyncDispose');
 /**
@@ -457,9 +458,14 @@ export class Kysely extends QueryCreator {
      *
      * See {@link https://github.com/kysely-org/kysely/blob/master/site/docs/recipes/0004-splitting-query-building-and-execution.md#execute-compiled-queries splitting build, compile and execute code recipe} for more information.
      */
-    executeQuery(query, queryId = createQueryId()) {
+    executeQuery(query, 
+    // TODO: remove this in the future. deprecated in  0.28.x
+    queryId) {
+        if (queryId !== undefined) {
+            logOnce('Passing `queryId` in `db.executeQuery` is deprecated and will result in a compile-time error in the future.');
+        }
         const compiledQuery = isCompilable(query) ? query.compile() : query;
-        return this.getExecutor().executeQuery(compiledQuery, queryId);
+        return this.getExecutor().executeQuery(compiledQuery);
     }
     async [Symbol.asyncDispose]() {
         await this.destroy();
@@ -878,13 +884,13 @@ class NotCommittedOrRolledBackAssertingExecutor {
     provideConnection(consumer) {
         return this.#executor.provideConnection(consumer);
     }
-    executeQuery(compiledQuery, queryId) {
+    executeQuery(compiledQuery) {
         assertNotCommittedOrRolledBack(this.#state);
-        return this.#executor.executeQuery(compiledQuery, queryId);
+        return this.#executor.executeQuery(compiledQuery);
     }
-    stream(compiledQuery, chunkSize, queryId) {
+    stream(compiledQuery, chunkSize) {
         assertNotCommittedOrRolledBack(this.#state);
-        return this.#executor.stream(compiledQuery, chunkSize, queryId);
+        return this.#executor.stream(compiledQuery, chunkSize);
     }
     withConnectionProvider(connectionProvider) {
         return new NotCommittedOrRolledBackAssertingExecutor(this.#executor.withConnectionProvider(connectionProvider), this.#state);

package/dist/esm/migration/migrator.js

@@ -1,7 +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 { freeze, getLast } from '../util/object-utils.js';
+import { freeze, getLast, isObject } from '../util/object-utils.js';
 export const DEFAULT_MIGRATION_TABLE = 'kysely_migration';
 export const DEFAULT_MIGRATION_LOCK_TABLE = 'kysely_migration_lock';
 export const DEFAULT_ALLOW_UNORDERED_MIGRATIONS = false;
@@ -176,7 +176,8 @@ export class Migrator {
      */
     async migrateTo(targetMigrationName) {
         return this.#migrate(({ migrations, executedMigrations, pendingMigrations, }) => {
-            if (targetMigrationName === NO_MIGRATIONS) {
+            if (isObject(targetMigrationName) &&
+                targetMigrationName.__noMigrations__ === true) {
                 return { direction: 'Down', step: Infinity };
             }
             if (!migrations.find((m) => m.name === targetMigrationName)) {

package/dist/esm/parser/delete-from-parser.d.ts

@@ -2,4 +2,8 @@ import type { DeleteQueryBuilder } from '../query-builder/delete-query-builder.j
 import type { DeleteResult } from '../query-builder/delete-result.js';
 import type { ShallowRecord } from '../util/type-utils.js';
 import type { ExtractTableAlias, From, FromTables, TableExpressionOrList } from './table-parser.js';
-export type DeleteFrom<DB, TE extends TableExpressionOrList<DB, never>> = TE extends ReadonlyArray<infer T> ? DeleteQueryBuilder<From<DB, T>, FromTables<DB, never, T>, DeleteResult> : TE extends keyof DB & string ? DeleteQueryBuilder<DB, ExtractTableAlias<DB, TE>, DeleteResult> : TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? DeleteQueryBuilder<DB & ShallowRecord<A, DB[T]>, A, DeleteResult> : never : DeleteQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, DeleteResult>;
+export type DeleteFrom<DB, TE extends TableExpressionOrList<DB, never>> = [
+    TE
+] extends [keyof DB] ? DeleteQueryBuilder<DB, ExtractTableAlias<DB, TE>, DeleteResult> : [
+    TE
+] extends [`${infer T} as ${infer A}`] ? T extends keyof DB ? DeleteQueryBuilder<DB & ShallowRecord<A, DB[T]>, A, DeleteResult> : never : TE extends ReadonlyArray<infer T> ? DeleteQueryBuilder<From<DB, T>, FromTables<DB, never, T>, DeleteResult> : DeleteQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, DeleteResult>;

package/dist/esm/parser/merge-into-parser.d.ts

@@ -2,4 +2,6 @@ import type { MergeQueryBuilder } from '../query-builder/merge-query-builder.js'
 import type { MergeResult } from '../query-builder/merge-result.js';
 import type { ShallowRecord } from '../util/type-utils.js';
 import type { ExtractTableAlias, SimpleTableReference } from './table-parser.js';
-export type MergeInto<DB, TE extends SimpleTableReference<DB>> = TE extends keyof DB & string ? MergeQueryBuilder<DB, ExtractTableAlias<DB, TE>, MergeResult> : TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? MergeQueryBuilder<DB & ShallowRecord<A, DB[T]>, A, MergeResult> : never : never;
+export type MergeInto<DB, TE extends SimpleTableReference<DB>> = [TE] extends [
+    keyof DB
+] ? MergeQueryBuilder<DB, ExtractTableAlias<DB, TE>, MergeResult> : [TE] extends [`${infer T} as ${infer A}`] ? T extends keyof DB ? MergeQueryBuilder<DB & ShallowRecord<A, DB[T]>, A, MergeResult> : never : never;

package/dist/esm/parser/select-from-parser.d.ts

@@ -1,4 +1,6 @@
 import type { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
 import type { ShallowRecord } from '../util/type-utils.js';
 import type { ExtractTableAlias, From, FromTables, TableExpressionOrList } from './table-parser.js';
-export type SelectFrom<DB, TB extends keyof DB, TE extends TableExpressionOrList<DB, TB>> = TE extends keyof DB & string ? SelectQueryBuilder<DB, TB | ExtractTableAlias<DB, TE>, {}> : TE extends `${infer T} as ${infer A}` ? T extends keyof DB ? SelectQueryBuilder<DB & ShallowRecord<A, DB[T]>, TB | A, {}> : never : TE extends ReadonlyArray<infer T> ? SelectQueryBuilder<From<DB, T>, FromTables<DB, TB, T>, {}> : SelectQueryBuilder<From<DB, TE>, FromTables<DB, TB, TE>, {}>;
+export type SelectFrom<DB, TB extends keyof DB, TE extends TableExpressionOrList<DB, TB>> = [TE] extends [keyof DB] ? SelectQueryBuilder<DB, TB | ExtractTableAlias<DB, TE>, {}> : [
+    TE
+] extends [`${infer T} as ${infer A}`] ? T extends keyof DB ? SelectQueryBuilder<DB & ShallowRecord<A, DB[T]>, TB | A, {}> : never : TE extends ReadonlyArray<infer T> ? SelectQueryBuilder<From<DB, T>, FromTables<DB, TB, T>, {}> : SelectQueryBuilder<From<DB, TE>, FromTables<DB, TB, TE>, {}>;