uql-orm 0.20.2 → 0.22.0

package/dist/migrate/introspection/abstractSqlSchemaIntrospector.js

@@ -30,16 +30,17 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
     // ============================================================================
     async getTableSchema(tableName) {
         const querier = await this.getQuerier();
+        const read = createTableRowReader(querier);
         try {
-            const exists = await this.tableExistsInternal(querier, tableName);
+            const exists = await this.tableExistsInternal(read, tableName);
             if (!exists) {
                 return undefined;
             }
             const [columns, indexes, foreignKeys, primaryKey] = await Promise.all([
-                this.getColumns(querier, tableName),
-                this.getIndexes(querier, tableName),
-                this.getForeignKeys(querier, tableName),
-                this.getPrimaryKey(querier, tableName),
+                this.getColumns(read, tableName),
+                this.getIndexes(read, tableName),
+                this.getForeignKeys(read, tableName),
+                this.getPrimaryKey(read, tableName),
             ]);
             return {
                 name: tableName,
@@ -66,7 +67,7 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
     async tableExists(tableName) {
         const querier = await this.getQuerier();
         try {
-            return this.tableExistsInternal(querier, tableName);
+            return this.tableExistsInternal(createTableRowReader(querier), tableName);
         }
         finally {
             await querier.release();
@@ -80,34 +81,24 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
         }
         return querier;
     }
-    async tableExistsInternal(querier, tableName) {
-        const sql = this.tableExistsQuery();
-        const params = this.tableExistsParams(tableName);
-        const results = await querier.all(sql, params);
+    async tableExistsInternal(read, tableName) {
+        const results = await read(this.tableExistsQuery(), this.tableExistsParams(tableName));
         return this.parseTableExistsResult(results);
     }
-    async getColumns(querier, tableName) {
-        const sql = this.getColumnsQuery(tableName);
-        const params = this.getColumnsParams(tableName);
-        const results = await querier.all(sql, params);
-        return this.mapColumnsResult(querier, tableName, results);
-    }
-    async getIndexes(querier, tableName) {
-        const sql = this.getIndexesQuery(tableName);
-        const params = this.getIndexesParams(tableName);
-        const results = await querier.all(sql, params);
-        return this.mapIndexesResult(querier, tableName, results);
-    }
-    async getForeignKeys(querier, tableName) {
-        const sql = this.getForeignKeysQuery(tableName);
-        const params = this.getForeignKeysParams(tableName);
-        const results = await querier.all(sql, params);
-        return this.mapForeignKeysResult(querier, tableName, results);
-    }
-    async getPrimaryKey(querier, tableName) {
-        const sql = this.getPrimaryKeyQuery(tableName);
-        const params = this.getPrimaryKeyParams(tableName);
-        const results = await querier.all(sql, params);
+    async getColumns(read, tableName) {
+        const results = await read(this.getColumnsQuery(tableName), this.getColumnsParams(tableName));
+        return this.mapColumnsResult(read, tableName, results);
+    }
+    async getIndexes(read, tableName) {
+        const results = await read(this.getIndexesQuery(tableName), this.getIndexesParams(tableName));
+        return this.mapIndexesResult(read, tableName, results);
+    }
+    async getForeignKeys(read, tableName) {
+        const results = await read(this.getForeignKeysQuery(tableName), this.getForeignKeysParams(tableName));
+        return this.mapForeignKeysResult(read, tableName, results);
+    }
+    async getPrimaryKey(read, tableName) {
+        const results = await read(this.getPrimaryKeyQuery(tableName), this.getPrimaryKeyParams(tableName));
         return this.mapPrimaryKeyResult(results);
     }
     // ============================================================================
@@ -157,5 +148,27 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
         }
         return Number(value);
     }
+    /**
+     * Map primary key query results to column names, in key order. `information_schema` gives every SQL
+     * engine here a `column_name` per row; SQLite reads its key off `PRAGMA table_info` instead and
+     * overrides this.
+     */
+    mapPrimaryKeyResult(results) {
+        const columns = results.map((row) => String(row['column_name']));
+        return columns.length ? columns : undefined;
+    }
+}
+/** A {@link TableRowReader} over one querier: the same statement is only ever sent once. */
+function createTableRowReader(querier) {
+    const sent = new Map();
+    return (sql, params) => {
+        const key = params?.length ? `${sql}\u0000${JSON.stringify(params)}` : sql;
+        let rows = sent.get(key);
+        if (!rows) {
+            // PRAGMA statements take no parameters at all, so they are sent as a bare statement.
+            rows = params?.length ? querier.all(sql, params) : querier.all(sql);
+            sent.set(key, rows);
+        }
+        return rows;
+    };
 }
-//# sourceMappingURL=abstractSqlSchemaIntrospector.js.map

package/dist/migrate/introspection/baseSqlIntrospector.d.ts

@@ -21,6 +21,4 @@ export declare abstract class BaseSqlIntrospector {
     private buildTables;
     private buildRelationships;
     private buildIndexes;
-    private columnSchemaToCanonical;
 }
-//# sourceMappingURL=baseSqlIntrospector.d.ts.map

package/dist/migrate/introspection/baseSqlIntrospector.js

@@ -1,4 +1,4 @@
-import { sqlToCanonical } from '../../schema/canonicalType.js';
+import { canonicalColumnType } from '../../schema/canonicalType.js';
 import { SchemaAST } from '../../schema/schemaAST.js';
 import { escapeSqlId } from '../../util/index.js';
 /**
@@ -52,7 +52,7 @@ export class BaseSqlIntrospector {
             for (const col of schema.columns) {
                 const column = {
                     name: col.name,
-                    type: this.columnSchemaToCanonical(col),
+                    type: canonicalColumnType(col.type, col),
                     nullable: col.nullable,
                     defaultValue: col.defaultValue,
                     isPrimaryKey: col.isPrimaryKey,
@@ -106,7 +106,7 @@ export class BaseSqlIntrospector {
             if (!table)
                 continue;
             for (const idx of schema.indexes) {
-                const columns = idx.columns.map((c) => table.columns.get(c)).filter((c) => !!c);
+                const columns = idx.columns.map((e) => table.columns.get(e.column)).filter((c) => !!c);
                 if (columns.length > 0) {
                     const index = {
                         name: idx.name,
@@ -119,14 +119,4 @@ export class BaseSqlIntrospector {
             }
         }
     }
-    columnSchemaToCanonical(col) {
-        const base = sqlToCanonical(col.type);
-        return {
-            ...base,
-            length: col.length ?? base.length,
-            precision: col.precision ?? base.precision,
-            scale: col.scale ?? base.scale,
-        };
-    }
 }
-//# sourceMappingURL=baseSqlIntrospector.js.map

package/dist/migrate/introspection/index.d.ts

@@ -3,4 +3,3 @@ export * from './mongoIntrospector.js';
 export { MariadbSchemaIntrospector, MysqlSchemaIntrospector } from './mysqlIntrospector.js';
 export * from './postgresIntrospector.js';
 export * from './sqliteIntrospector.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/migrate/introspection/index.js

@@ -3,4 +3,3 @@ export * from './mongoIntrospector.js';
 export { MariadbSchemaIntrospector, MysqlSchemaIntrospector } from './mysqlIntrospector.js';
 export * from './postgresIntrospector.js';
 export * from './sqliteIntrospector.js';
-//# sourceMappingURL=index.js.map

package/dist/migrate/introspection/mongoIntrospector.d.ts

@@ -12,4 +12,3 @@ export declare class MongoSchemaIntrospector implements SchemaIntrospector {
     getTableNames(): Promise<string[]>;
     tableExists(tableName: string): Promise<boolean>;
 }
-//# sourceMappingURL=mongoIntrospector.d.ts.map

package/dist/migrate/introspection/mongoIntrospector.js

@@ -27,7 +27,7 @@ export class MongoSchemaIntrospector {
                 if (schema.indexes) {
                     for (const idx of schema.indexes) {
                         const indexColumns = [];
-                        for (const colName of idx.columns) {
+                        for (const { column: colName } of idx.columns) {
                             let column = columns.get(colName);
                             if (!column) {
                                 column = {
@@ -72,7 +72,7 @@ export class MongoSchemaIntrospector {
                 columns: [], // We don't have columns in Mongo
                 indexes: indexes.map((idx) => ({
                     name: idx.name ?? Object.keys(idx.key).join('_'),
-                    columns: Object.keys(idx.key),
+                    columns: Object.keys(idx.key).map((column) => ({ column })),
                     unique: !!idx.unique,
                 })),
             };
@@ -97,4 +97,3 @@ export class MongoSchemaIntrospector {
         return names.includes(tableName);
     }
 }
-//# sourceMappingURL=mongoIntrospector.js.map

package/dist/migrate/introspection/mysqlIntrospector.d.ts

@@ -1,5 +1,5 @@
-import type { ColumnSchema, ForeignKeySchema, IndexSchema, SqlQuerier } from '../../type/index.js';
-import { AbstractSqlSchemaIntrospector } from './abstractSqlSchemaIntrospector.js';
+import type { ColumnSchema, ForeignKeySchema, IndexSchema } from '../../type/index.js';
+import { AbstractSqlSchemaIntrospector, type TableRowReader } from './abstractSqlSchemaIntrospector.js';
 /**
  * MySQL/MariaDB schema introspector.
  * Works with both MySQL and MariaDB as they share the same information_schema structure.
@@ -17,13 +17,13 @@ export declare class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospect
     protected mapTableNameRow(row: {
         table_name: string;
     }): string;
-    protected mapColumnsResult(_querier: SqlQuerier, _tableName: string, results: MysqlColumnRow[]): Promise<ColumnSchema[]>;
-    protected mapIndexesResult(_querier: SqlQuerier, _tableName: string, results: {
+    protected mapColumnsResult(_read: TableRowReader, _tableName: string, results: MysqlColumnRow[]): Promise<ColumnSchema[]>;
+    protected mapIndexesResult(_read: TableRowReader, _tableName: string, results: {
         index_name: string;
         columns: string;
         is_unique: number;
     }[]): Promise<IndexSchema[]>;
-    protected mapForeignKeysResult(_querier: SqlQuerier, _tableName: string, results: {
+    protected mapForeignKeysResult(_read: TableRowReader, _tableName: string, results: {
         constraint_name: string;
         columns: string;
         referenced_table: string;
@@ -31,9 +31,6 @@ export declare class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospect
         delete_rule: string;
         update_rule: string;
     }[]): Promise<ForeignKeySchema[]>;
-    protected mapPrimaryKeyResult(results: {
-        column_name: string;
-    }[]): string[] | undefined;
     protected parseDefaultValue(defaultValue: string | null): unknown;
 }
 type MysqlColumnRow = {
@@ -54,4 +51,3 @@ type MysqlColumnRow = {
  */
 export declare const MariadbSchemaIntrospector: typeof MysqlSchemaIntrospector;
 export {};
-//# sourceMappingURL=mysqlIntrospector.d.ts.map

package/dist/migrate/introspection/mysqlIntrospector.js

@@ -101,7 +101,7 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     mapTableNameRow(row) {
         return row.table_name;
     }
-    async mapColumnsResult(_querier, _tableName, results) {
+    async mapColumnsResult(_read, _tableName, results) {
         return results.map((row) => ({
             name: row.column_name,
             type: (row.column_type || '').toUpperCase(),
@@ -116,14 +116,14 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
             comment: row.column_comment || undefined,
         }));
     }
-    async mapIndexesResult(_querier, _tableName, results) {
+    async mapIndexesResult(_read, _tableName, results) {
         return results.map((row) => ({
             name: row.index_name,
-            columns: (row.columns || '').split(','),
+            columns: (row.columns || '').split(',').map((column) => ({ column })),
             unique: Boolean(row.is_unique),
         }));
     }
-    async mapForeignKeysResult(_querier, _tableName, results) {
+    async mapForeignKeysResult(_read, _tableName, results) {
         return results.map((row) => ({
             name: row.constraint_name,
             columns: (row.columns || '').split(','),
@@ -133,12 +133,6 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
             onUpdate: this.normalizeReferentialAction(row.update_rule),
         }));
     }
-    mapPrimaryKeyResult(results) {
-        if (results.length === 0) {
-            return undefined;
-        }
-        return results.map((r) => r.column_name);
-    }
     parseDefaultValue(defaultValue) {
         if (defaultValue === null) {
             return undefined;
@@ -167,4 +161,3 @@ export class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
  * MariaDB uses the same information_schema structure as MySQL.
  */
 export const MariadbSchemaIntrospector = MysqlSchemaIntrospector;
-//# sourceMappingURL=mysqlIntrospector.js.map

package/dist/migrate/introspection/postgresIntrospector.d.ts

@@ -1,5 +1,5 @@
-import type { ColumnSchema, ForeignKeySchema, IndexSchema, RawRow, SqlQuerier } from '../../type/index.js';
-import { AbstractSqlSchemaIntrospector } from './abstractSqlSchemaIntrospector.js';
+import type { ColumnSchema, ForeignKeySchema, IndexSchema, RawRow } from '../../type/index.js';
+import { AbstractSqlSchemaIntrospector, type TableRowReader } from './abstractSqlSchemaIntrospector.js';
 /**
  * PostgreSQL schema introspector
  */
@@ -14,13 +14,13 @@ export declare class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrosp
     protected mapTableNameRow(row: {
         table_name: string;
     }): string;
-    protected mapColumnsResult(_querier: SqlQuerier, _tableName: string, results: PostgresColumnRow[]): Promise<ColumnSchema[]>;
-    protected mapIndexesResult(_querier: SqlQuerier, _tableName: string, results: {
+    protected mapColumnsResult(_read: TableRowReader, _tableName: string, results: PostgresColumnRow[]): Promise<ColumnSchema[]>;
+    protected mapIndexesResult(_read: TableRowReader, _tableName: string, results: {
         index_name: string;
         columns: string[];
         is_unique: boolean;
     }[]): Promise<IndexSchema[]>;
-    protected mapForeignKeysResult(_querier: SqlQuerier, _tableName: string, results: {
+    protected mapForeignKeysResult(_read: TableRowReader, _tableName: string, results: {
         constraint_name: string;
         columns: string[];
         referenced_table: string;
@@ -28,9 +28,6 @@ export declare class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrosp
         delete_rule: string;
         update_rule: string;
     }[]): Promise<ForeignKeySchema[]>;
-    protected mapPrimaryKeyResult(results: {
-        column_name: string;
-    }[]): string[] | undefined;
     protected normalizeType(dataType: string, udtName: string): string;
     protected parseDefaultValue(defaultValue: string | null): unknown;
     protected isAutoIncrement(columnDefault: string | null, isIdentity: string): boolean;
@@ -50,4 +47,3 @@ type PostgresColumnRow = {
     column_comment: string | null;
 };
 export {};
-//# sourceMappingURL=postgresIntrospector.d.ts.map

package/dist/migrate/introspection/postgresIntrospector.js

@@ -134,7 +134,7 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     mapTableNameRow(row) {
         return row.table_name;
     }
-    async mapColumnsResult(_querier, _tableName, results) {
+    async mapColumnsResult(_read, _tableName, results) {
         return results.map((row) => ({
             name: row.column_name,
             type: this.normalizeType(row.data_type, row.udt_name),
@@ -149,14 +149,14 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
             comment: row.column_comment ?? undefined,
         }));
     }
-    async mapIndexesResult(_querier, _tableName, results) {
+    async mapIndexesResult(_read, _tableName, results) {
         return results.map((row) => ({
             name: row.index_name,
-            columns: row.columns,
+            columns: row.columns.map((column) => ({ column })),
             unique: row.is_unique,
         }));
     }
-    async mapForeignKeysResult(_querier, _tableName, results) {
+    async mapForeignKeysResult(_read, _tableName, results) {
         return results.map((row) => ({
             name: row.constraint_name,
             columns: row.columns,
@@ -166,12 +166,6 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
             onUpdate: this.normalizeReferentialAction(row.update_rule),
         }));
     }
-    mapPrimaryKeyResult(results) {
-        if (results.length === 0) {
-            return undefined;
-        }
-        return results.map((r) => r.column_name);
-    }
     // ============================================================================
     // PostgreSQL-specific helpers
     // ============================================================================
@@ -218,4 +212,3 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         return columnDefault?.includes('nextval(') ?? false;
     }
 }
-//# sourceMappingURL=postgresIntrospector.js.map

package/dist/migrate/introspection/sqliteIntrospector.d.ts

@@ -1,5 +1,5 @@
-import type { ColumnSchema, ForeignKeySchema, IndexSchema, SqlQuerier } from '../../type/index.js';
-import { AbstractSqlSchemaIntrospector } from './abstractSqlSchemaIntrospector.js';
+import type { ColumnSchema, ForeignKeySchema, IndexSchema } from '../../type/index.js';
+import { AbstractSqlSchemaIntrospector, type TableRowReader } from './abstractSqlSchemaIntrospector.js';
 /**
  * SQLite schema introspector
  */
@@ -18,11 +18,12 @@ export declare class SqliteSchemaIntrospector extends AbstractSqlSchemaIntrospec
     protected mapTableNameRow(row: {
         name: string;
     }): string;
-    protected mapColumnsResult(querier: SqlQuerier, tableName: string, results: SqliteColumnRow[]): Promise<ColumnSchema[]>;
-    protected mapIndexesResult(querier: SqlQuerier, _tableName: string, results: SqliteIndexRow[]): Promise<IndexSchema[]>;
-    protected mapForeignKeysResult(_querier: SqlQuerier, tableName: string, results: SqliteForeignKeyRow[]): Promise<ForeignKeySchema[]>;
+    protected mapColumnsResult(read: TableRowReader, tableName: string, results: SqliteColumnRow[]): Promise<ColumnSchema[]>;
+    protected mapIndexesResult(read: TableRowReader, _tableName: string, results: SqliteIndexRow[]): Promise<IndexSchema[]>;
+    protected mapForeignKeysResult(_read: TableRowReader, tableName: string, results: SqliteForeignKeyRow[]): Promise<ForeignKeySchema[]>;
     protected mapPrimaryKeyResult(results: SqliteColumnRow[]): string[] | undefined;
     private getUniqueColumns;
+    private getIndexColumns;
     protected normalizeType(type: string): string;
     protected extractLength(type: string): number | undefined;
     protected parseDefaultValue(defaultValue: string | null): unknown;
@@ -55,4 +56,3 @@ type SqliteForeignKeyRow = {
     match: string;
 };
 export {};
-//# sourceMappingURL=sqliteIntrospector.d.ts.map

package/dist/migrate/introspection/sqliteIntrospector.js

@@ -32,16 +32,16 @@ export class SqliteSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     }
     // SQLite uses PRAGMA which doesn't use parameterized queries in the same way
     getColumnsQuery(tableName) {
-        return `PRAGMA table_info(${this.escapeId(tableName)})`;
+        return /*sql*/ `PRAGMA table_info(${this.escapeId(tableName)})`;
     }
     getIndexesQuery(tableName) {
-        return `PRAGMA index_list(${this.escapeId(tableName)})`;
+        return /*sql*/ `PRAGMA index_list(${this.escapeId(tableName)})`;
     }
     getForeignKeysQuery(tableName) {
-        return `PRAGMA foreign_key_list(${this.escapeId(tableName)})`;
+        return /*sql*/ `PRAGMA foreign_key_list(${this.escapeId(tableName)})`;
     }
     getPrimaryKeyQuery(tableName) {
-        return `PRAGMA table_info(${this.escapeId(tableName)})`;
+        return /*sql*/ `PRAGMA table_info(${this.escapeId(tableName)})`;
     }
     getColumnsParams(_tableName) {
         return [];
@@ -61,9 +61,9 @@ export class SqliteSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     mapTableNameRow(row) {
         return row.name;
     }
-    async mapColumnsResult(querier, tableName, results) {
+    async mapColumnsResult(read, tableName, results) {
         // Get unique columns from indexes
-        const uniqueColumns = await this.getUniqueColumns(querier, tableName);
+        const uniqueColumns = await this.getUniqueColumns(read, tableName);
         return results.map((row) => ({
             name: row.name,
             type: this.normalizeType(row.type),
@@ -78,25 +78,29 @@ export class SqliteSchemaIntrospector extends AbstractSqlSchemaIntrospector {
             comment: undefined, // SQLite doesn't support column comments
         }));
     }
-    async mapIndexesResult(querier, _tableName, results) {
+    async mapIndexesResult(read, _tableName, results) {
         const indexSchemas = [];
         for (const index of results) {
-            const columns = await querier.all(`PRAGMA index_info(${this.escapeId(index.name)})`);
+            const columns = await this.getIndexColumns(read, index.name);
             // Include user-created indexes ('c') and multi-column unique constraints ('u')
             // Skip primary key indexes ('pk') and single-column unique constraints
             const isUserCreated = index.origin === 'c';
             const isCompositeUnique = index.origin === 'u' && columns.length > 1;
-            if (isUserCreated || isCompositeUnique) {
+            // `PRAGMA index_info` names an expression entry `null` (its `cid` is -2), and the expression text
+            // lives only in `sqlite_master.sql`. Reporting `{ column: null }` put a column literally named
+            // `null` into the diff, so an index UQL cannot describe is left out entirely instead.
+            const named = columns.filter((column) => column.name !== null);
+            if (named.length === columns.length && (isUserCreated || isCompositeUnique)) {
                 indexSchemas.push({
                     name: index.name,
-                    columns: columns.map((c) => c.name),
+                    columns: named.map((column) => ({ column: column.name })),
                     unique: Boolean(index.unique),
                 });
             }
         }
         return indexSchemas;
     }
-    async mapForeignKeysResult(_querier, tableName, results) {
+    async mapForeignKeysResult(_read, tableName, results) {
         // Group by id to handle composite foreign keys
         const grouped = new Map();
         for (const row of results) {
@@ -127,20 +131,24 @@ export class SqliteSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     // ============================================================================
     // SQLite-specific helpers
     // ============================================================================
-    async getUniqueColumns(querier, tableName) {
-        const results = await querier.all(`PRAGMA index_list(${this.escapeId(tableName)})`);
+    async getUniqueColumns(read, tableName) {
+        const indexes = await read(this.getIndexesQuery(tableName));
         const uniqueColumns = new Set();
-        for (const index of results) {
+        for (const index of indexes) {
             if (index.unique) {
-                const indexInfo = await querier.all(`PRAGMA index_info(${this.escapeId(index.name)})`);
-                // Only single-column unique constraints
-                if (indexInfo.length === 1) {
-                    uniqueColumns.add(indexInfo[0].name);
+                const columns = await this.getIndexColumns(read, index.name);
+                // Only single-column unique constraints, and only over a real column (not an expression)
+                const [column] = columns;
+                if (columns.length === 1 && column.name !== null) {
+                    uniqueColumns.add(column.name);
                 }
             }
         }
         return uniqueColumns;
     }
+    getIndexColumns(read, indexName) {
+        return read(/*sql*/ `PRAGMA index_info(${this.escapeId(indexName)})`);
+    }
     normalizeType(type) {
         // Extract base type without length/precision
         const match = type.match(/^([A-Za-z]+)/);
@@ -180,4 +188,3 @@ export class SqliteSchemaIntrospector extends AbstractSqlSchemaIntrospector {
         return defaultValue;
     }
 }
-//# sourceMappingURL=sqliteIntrospector.js.map

package/dist/migrate/migrator.d.ts

@@ -1,4 +1,4 @@
-import type { DialectName, LoggingOptions, Migration, MigrationDefinition, MigrationResult, MigrationStorage, MigratorOptions, MongoQuerier, NamingStrategy, Querier, QuerierPool, SchemaDiff, SchemaGenerator, SchemaIntrospector, Type } from '../type/index.js';
+import type { DialectName, LoggingOptions, Migration, MigrationDefinition, MigrationResult, MigrationStorage, MigratorOptions, MongoQuerier, Querier, QuerierPool, SchemaDiff, SchemaGenerator, SchemaIntrospector, Type } from '../type/index.js';
 import { LoggerWrapper } from '../util/index.js';
 import type { IMigrationBuilder } from './builder/types.js';
 /**
@@ -16,7 +16,7 @@ export declare class Migrator {
     readonly dialectName: DialectName;
     schemaGenerator?: SchemaGenerator;
     schemaIntrospector?: SchemaIntrospector;
-    private readonly _namingStrategy?;
+    private readonly _defaultForeignKeyAction?;
     private _mongoSchemaLoadPromise?;
     constructor(pool: QuerierPool, options?: MigratorOptions);
     /** Loads MongoDB schema generator on first use; SQL generators are set in the constructor (or via {@link setSchemaGenerator}). */
@@ -26,7 +26,7 @@ export declare class Migrator {
      */
     setSchemaGenerator(generator: SchemaGenerator): void;
     protected createIntrospector(): SchemaIntrospector | undefined;
-    protected createGenerator(namingStrategy?: NamingStrategy): SchemaGenerator | undefined;
+    protected createGenerator(): SchemaGenerator | undefined;
     /**
      * Get all discovered migrations from the migrations directory
      */
@@ -88,6 +88,26 @@ export declare class Migrator {
         drop?: boolean;
         logging?: boolean;
     }): Promise<void>;
+    /**
+     * The DDL {@link autoSync} would run, without running it. Separate so `--dry-run` shows the real
+     * statements rather than a summary of a second, differently-computed diff.
+     */
+    planSync(options?: {
+        safe?: boolean;
+        drop?: boolean;
+    }): Promise<string[]>;
+    /**
+     * Each pending diff with the entity it came from, since resolving that is async and every caller
+     * needs it. What to emit stays with the caller: a sync narrows the forward direction to what the
+     * caller allows and never asks for the rollback, which on SQLite cannot even be expressed (no
+     * `ALTER COLUMN`), so computing it eagerly for everyone would throw there.
+     */
+    private pendingDiffs;
+    /**
+     * The schema generator. A getter because MongoDB's loads lazily (see {@link ensureSchemaGenerator}),
+     * so every caller had to repeat the same assertion after awaiting it.
+     */
+    private get generator();
     protected filterDiff(diff: SchemaDiff, options: {
         safe?: boolean;
         drop?: boolean;
@@ -165,4 +185,3 @@ export interface BuilderMigrationDefinition {
  * ```
  */
 export declare function defineBuilderMigration(migration: BuilderMigrationDefinition): BuilderMigrationDefinition;
-//# sourceMappingURL=migrator.d.ts.map