uql-orm 0.21.0 → 0.22.0

package/dist/migrate/generator/mongoSchemaGenerator.js

@@ -2,6 +2,8 @@ import { AbstractDialect } from '../../dialect/abstractDialect.js';
 import { getMeta } from '../../entity/index.js';
 import { mongoDialectFeatures } from '../../mongo/mongoDialect.js';
 import { getKeys } from '../../util/index.js';
+import { indexNodeToSchema } from './indexNodeToSchema.js';
+import { serializeMongoCommand } from './mongoCommand.js';
 export class MongoSchemaGenerator extends AbstractDialect {
     defaultForeignKeyAction;
     dialectName = 'mongodb';
@@ -22,17 +24,20 @@ export class MongoSchemaGenerator extends AbstractDialect {
                 const indexName = typeof field.index === 'string' ? field.index : `idx_${collectionName}_${columnName}`;
                 indexes.push({
                     name: indexName,
-                    columns: [columnName],
+                    columns: [{ column: columnName }],
                     unique: !!field.unique,
                 });
             }
         }
-        return [JSON.stringify({ action: 'createCollection', name: collectionName, indexes })];
+        // One `createIndex` command each, mirroring the SQL generator's `[CREATE TABLE, ...CREATE INDEX]`,
+        // so the key spec is built here and the migrator only executes it.
+        return [
+            serializeMongoCommand({ action: 'createCollection', name: collectionName }),
+            ...indexes.map((index) => this.generateCreateIndex(collectionName, index)),
+        ];
     }
-    generateDropTable(entity) {
-        const meta = getMeta(entity);
-        const collectionName = this.resolveTableName(entity, meta);
-        return JSON.stringify({ action: 'dropCollection', name: collectionName });
+    generateDropTable(tableName) {
+        return serializeMongoCommand({ action: 'dropCollection', name: tableName });
     }
     generateAlterTable(diff) {
         const statements = [];
@@ -52,12 +57,26 @@ export class MongoSchemaGenerator extends AbstractDialect {
         }
         return statements;
     }
+    /**
+     * MongoDB's key spec is where its index options live: `-1` for a descending entry and `'text'` for a
+     * full-text index, which is what `$text` needs since a text index declares its own fields.
+     *
+     * @remarks The SQL-only modifiers are refused rather than dropped, for the same reason the SQL
+     * dialects refuse each other's - a silently weaker index is worse than a clear failure. `where`
+     * included: MongoDB's partial indexes take a filter document, not a SQL predicate.
+     */
     generateCreateIndex(tableName, index) {
         const key = {};
-        for (const col of index.columns) {
-            key[col] = 1;
+        for (const entry of index.columns) {
+            if (entry.expression || entry.length !== undefined || entry.nulls || entry.opsClass) {
+                throw new TypeError(`mongodb does not support that index column option (index "${index.name}")`);
+            }
+            key[entry.column] = index.type === 'fulltext' ? 'text' : entry.order === 'desc' ? -1 : 1;
         }
-        return JSON.stringify({
+        if (index.where) {
+            throw new TypeError(`mongodb does not support partial indexes from a SQL predicate (index "${index.name}")`);
+        }
+        return serializeMongoCommand({
             action: 'createIndex',
             collection: tableName,
             name: index.name,
@@ -66,7 +85,7 @@ export class MongoSchemaGenerator extends AbstractDialect {
         });
     }
     generateDropIndex(tableName, indexName) {
-        return JSON.stringify({
+        return serializeMongoCommand({
             action: 'dropIndex',
             collection: tableName,
             name: indexName,
@@ -75,84 +94,23 @@ export class MongoSchemaGenerator extends AbstractDialect {
     getSqlType(fieldOptions, fieldType) {
         return '';
     }
-    getBooleanType() {
-        return '';
-    }
-    generateColumnDefinitions() {
-        return [];
-    }
-    generateColumnDefinition() {
-        return '';
-    }
-    generateColumnDefinitionFromSchema() {
-        return '';
-    }
-    generateTableConstraints() {
-        return [];
-    }
-    generateAlterColumnStatements() {
-        return [];
-    }
-    getTableOptions() {
-        return '';
-    }
-    generateColumnComment() {
-        return '';
-    }
-    formatDefaultValue() {
-        return '';
-    }
     generateCreateTableFromNode(table, _options) {
-        return [JSON.stringify({ action: 'createCollection', name: table.name })];
+        return [
+            serializeMongoCommand({ action: 'createCollection', name: table.name }),
+            ...table.indexes.map((index) => this.generateCreateIndexFromNode(index)),
+        ];
     }
     generateCreateIndexFromNode(index) {
-        const key = {};
-        for (const col of index.columns) {
-            key[col.name] = 1;
-        }
-        return JSON.stringify({
-            action: 'createIndex',
-            collection: index.table.name,
-            name: index.name,
-            key,
-            options: { unique: index.unique, name: index.name },
-        });
-    }
-    generateDropTableFromNode(table) {
-        return JSON.stringify({ action: 'dropCollection', name: table.name });
+        return this.generateCreateIndex(index.table.name, indexNodeToSchema(index));
     }
     generateCreateTableFromDefinition(table, _options) {
-        return [JSON.stringify({ action: 'createCollection', name: table.name })];
-    }
-    generateDropTableSql(tableName) {
-        return JSON.stringify({ action: 'dropCollection', name: tableName });
+        return [
+            serializeMongoCommand({ action: 'createCollection', name: table.name }),
+            ...table.indexes.map((index) => this.generateCreateIndex(table.name, index)),
+        ];
     }
     generateRenameTableSql(oldName, newName) {
-        return JSON.stringify({ action: 'renameCollection', from: oldName, to: newName });
-    }
-    generateAddColumnSql() {
-        return '';
-    }
-    generateDropColumnSql() {
-        return '';
-    }
-    generateRenameColumnSql() {
-        return '';
-    }
-    generateAlterColumnSql() {
-        return '';
-    }
-    generateCreateIndexSql(tableName, index) {
-        return this.generateCreateIndex(tableName, index);
-    }
-    generateDropIndexSql(tableName, indexName) {
-        return this.generateDropIndex(tableName, indexName);
-    }
-    generateAddForeignKeySql() {
-        return '';
-    }
-    generateDropForeignKeySql() {
-        return '';
+        return serializeMongoCommand({ action: 'renameCollection', from: oldName, to: newName });
     }
     diffSchema(entity, currentTable) {
         const meta = getMeta(entity);
@@ -170,7 +128,7 @@ export class MongoSchemaGenerator extends AbstractDialect {
                 if (!existingIndexes.has(indexName)) {
                     indexesToAdd.push({
                         name: indexName,
-                        columns: [columnName],
+                        columns: [{ column: columnName }],
                         unique: !!field.unique,
                     });
                 }

package/dist/migrate/index.d.ts

@@ -12,4 +12,3 @@ export { createSchemaGenerator, SqlSchemaGenerator } from './schemaGenerator.js'
 export { createSchemaGeneratorAsync } from './schemaGeneratorAsync.js';
 export { DatabaseMigrationStorage } from './storage/databaseStorage.js';
 export { JsonMigrationStorage } from './storage/jsonStorage.js';
-export * from './sync/index.js';

package/dist/migrate/index.js

@@ -19,4 +19,3 @@ export { createSchemaGeneratorAsync } from './schemaGeneratorAsync.js';
 export { DatabaseMigrationStorage } from './storage/databaseStorage.js';
 export { JsonMigrationStorage } from './storage/jsonStorage.js';
 // Schema sync
-export * from './sync/index.js';

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.
  *
@@ -30,11 +41,11 @@ export declare abstract class AbstractSqlSchemaIntrospector extends BaseSqlIntro
     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>;
+    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 +76,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

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

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 = {
@@ -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,
                 })),
             };

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;