uql-orm 0.21.0 → 0.23.0

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

@@ -4,6 +4,17 @@ import { BaseSqlIntrospector } from './baseSqlIntrospector.js';
  * Referential action type for foreign key constraints.
  */
 export type ReferentialAction = 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
+/**
+ * Reads the rows of one statement while introspecting a table.
+ *
+ * Identical statements share a single round trip, which is what the mappers get instead of a querier:
+ * describing one table needs four facts, and on SQLite three of them come out of the same two PRAGMAs
+ * (`table_info` is both the column list and the primary key; the column mapper walks `index_list` and
+ * `index_info` for single-column uniqueness while the index mapper is walking them too). That was four
+ * redundant statements out of ten per table - on D1 and Turso, where every PRAGMA is an HTTP round trip,
+ * it is four avoidable ones.
+ */
+export type TableRowReader = <T extends RawRow>(sql: string, params?: unknown[]) => Promise<T[]>;
 /**
  * Abstract base class for SQL schema introspectors.
  *
@@ -29,12 +40,16 @@ export declare abstract class AbstractSqlSchemaIntrospector extends BaseSqlIntro
     getTableSchema(tableName: string): Promise<TableSchema | undefined>;
     getTableNames(): Promise<string[]>;
     tableExists(tableName: string): Promise<boolean>;
-    protected getQuerier(): Promise<SqlQuerier>;
-    protected tableExistsInternal(querier: SqlQuerier, tableName: string): Promise<boolean>;
-    protected getColumns(querier: SqlQuerier, tableName: string): Promise<ColumnSchema[]>;
-    protected getIndexes(querier: SqlQuerier, tableName: string): Promise<IndexSchema[]>;
-    protected getForeignKeys(querier: SqlQuerier, tableName: string): Promise<ForeignKeySchema[]>;
-    protected getPrimaryKey(querier: SqlQuerier, tableName: string): Promise<string[] | undefined>;
+    /**
+     * Introspection reads, so `withQuerier` rather than `transaction`: the pool owns the release either
+     * way, and wrapping catalogue queries in a transaction would hold one open for nothing.
+     */
+    protected withSqlQuerier<T>(task: (querier: SqlQuerier) => Promise<T>): Promise<T>;
+    protected tableExistsInternal(read: TableRowReader, tableName: string): Promise<boolean>;
+    protected getColumns(read: TableRowReader, tableName: string): Promise<ColumnSchema[]>;
+    protected getIndexes(read: TableRowReader, tableName: string): Promise<IndexSchema[]>;
+    protected getForeignKeys(read: TableRowReader, tableName: string): Promise<ForeignKeySchema[]>;
+    protected getPrimaryKey(read: TableRowReader, tableName: string): Promise<string[] | undefined>;
     protected tableExistsParams(tableName: string): unknown[];
     protected getColumnsParams(tableName: string): unknown[];
     protected getIndexesParams(tableName: string): unknown[];
@@ -65,13 +80,17 @@ export declare abstract class AbstractSqlSchemaIntrospector extends BaseSqlIntro
     /** Extract table name from a row returned by getTableNamesQuery. */
     protected abstract mapTableNameRow(row: RawRow): string;
     /** Map column query results to ColumnSchema array. Allows async for SQLite's unique column check. */
-    protected abstract mapColumnsResult(querier: SqlQuerier, tableName: string, results: RawRow[]): Promise<ColumnSchema[]>;
+    protected abstract mapColumnsResult(read: TableRowReader, tableName: string, results: RawRow[]): Promise<ColumnSchema[]>;
     /** Map index query results to IndexSchema array. Allows async for SQLite's index_info calls. */
-    protected abstract mapIndexesResult(querier: SqlQuerier, tableName: string, results: RawRow[]): Promise<IndexSchema[]>;
+    protected abstract mapIndexesResult(read: TableRowReader, tableName: string, results: RawRow[]): Promise<IndexSchema[]>;
     /** Map foreign key query results to ForeignKeySchema array. */
-    protected abstract mapForeignKeysResult(querier: SqlQuerier, tableName: string, results: RawRow[]): Promise<ForeignKeySchema[]>;
-    /** Map primary key query results to column names array. */
-    protected abstract mapPrimaryKeyResult(results: RawRow[]): string[] | undefined;
+    protected abstract mapForeignKeysResult(read: TableRowReader, tableName: string, results: RawRow[]): Promise<ForeignKeySchema[]>;
+    /**
+     * 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.
+     */
+    protected mapPrimaryKeyResult(results: RawRow[]): string[] | undefined;
     /** Parse default value string to appropriate type. */
     protected abstract parseDefaultValue(defaultValue: string | null): unknown;
 }

package/dist/migrate/introspection/abstractSqlSchemaIntrospector.js

@@ -29,17 +29,17 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
     // Template Methods (shared control flow)
     // ============================================================================
     async getTableSchema(tableName) {
-        const querier = await this.getQuerier();
-        try {
-            const exists = await this.tableExistsInternal(querier, tableName);
+        return this.withSqlQuerier(async (querier) => {
+            const read = createTableRowReader(querier);
+            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,
@@ -48,66 +48,47 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
                 indexes,
                 foreignKeys,
             };
-        }
-        finally {
-            await querier.release();
-        }
+        });
     }
     async getTableNames() {
-        const querier = await this.getQuerier();
-        try {
+        return this.withSqlQuerier(async (querier) => {
             const results = await querier.all(this.getTableNamesQuery());
             return results.map((row) => this.mapTableNameRow(row));
-        }
-        finally {
-            await querier.release();
-        }
+        });
     }
     async tableExists(tableName) {
-        const querier = await this.getQuerier();
-        try {
-            return this.tableExistsInternal(querier, tableName);
-        }
-        finally {
-            await querier.release();
-        }
+        return this.withSqlQuerier((querier) => this.tableExistsInternal(createTableRowReader(querier), tableName));
     }
-    async getQuerier() {
-        const querier = await this.pool.getQuerier();
-        if (!isSqlQuerier(querier)) {
-            await querier.release();
-            throw new Error(`${this.constructor.name} requires a SQL-based querier`);
-        }
-        return querier;
+    /**
+     * Introspection reads, so `withQuerier` rather than `transaction`: the pool owns the release either
+     * way, and wrapping catalogue queries in a transaction would hold one open for nothing.
+     */
+    withSqlQuerier(task) {
+        return this.pool.withQuerier((querier) => {
+            if (!isSqlQuerier(querier)) {
+                throw new Error(`${this.constructor.name} requires a SQL-based querier`);
+            }
+            return task(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,4 +138,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;
+    };
 }

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

@@ -21,5 +21,4 @@ export declare abstract class BaseSqlIntrospector {
     private buildTables;
     private buildRelationships;
     private buildIndexes;
-    private columnSchemaToCanonical;
 }

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,13 +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,
-        };
-    }
 }

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 = {
@@ -58,39 +58,33 @@ export class MongoSchemaIntrospector {
         return ast;
     }
     async getTableSchema(tableName) {
-        const querier = await this.pool.getQuerier();
-        try {
+        return this.pool.withQuerier(async (querier) => {
             const { db } = querier;
             const collections = await db.listCollections({ name: tableName }).toArray();
             if (collections.length === 0) {
                 return undefined;
             }
-            // MongoDB doesn't have a fixed schema, but we can look at the indexes
+            // MongoDB doesn't have a fixed schema, but we can look at the indexes. Annotated rather than
+            // inferred: the driver's `indexes()` is overloaded and resolves to `any` on some versions, which
+            // silently made every field below unchecked.
             const indexes = await db.collection(tableName).indexes();
             return {
                 name: tableName,
                 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,
                 })),
             };
-        }
-        finally {
-            await querier.release();
-        }
+        });
     }
     async getTableNames() {
-        const querier = await this.pool.getQuerier();
-        try {
+        return this.pool.withQuerier(async (querier) => {
             const { db } = querier;
             const collections = await db.listCollections().toArray();
             return collections.map((c) => c.name);
-        }
-        finally {
-            await querier.release();
-        }
+        });
     }
     async tableExists(tableName) {
         const names = await this.getTableNames();

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 = {

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;

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;

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
     // ============================================================================

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;

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]+)/);

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;