uql-orm 0.20.2 → 0.22.0

package/dist/migrate/codegen/entityCodeGenerator.js

@@ -9,8 +9,9 @@
  * - Indexes
  * - JSDoc comments for sync-added fields
  */
-import { canonicalToColumnType, canonicalToTypeScript } from '../../schema/canonicalType.js';
+import { canonicalToTypeScript } from '../../schema/canonicalType.js';
 import { camelCase, pascalCase, singularize } from '../../util/string.util.js';
+import { buildFieldOptionsSource } from './fieldOptionsSource.js';
 /**
  * Generates TypeScript entity code from SchemaAST.
  */
@@ -183,44 +184,9 @@ export class EntityCodeGenerator {
      * Build Field decorator options.
      */
     buildFieldOptions(col) {
-        const options = [];
-        // Column type
-        const columnType = canonicalToColumnType(col.type);
-        if (columnType) {
-            options.push(`columnType: '${columnType}'`);
-        }
-        // Length
-        if (col.type.length && col.type.category === 'string') {
-            options.push(`length: ${col.type.length}`);
-        }
-        // Precision and scale
-        if (col.type.precision) {
-            options.push(`precision: ${col.type.precision}`);
-            if (col.type.scale) {
-                options.push(`scale: ${col.type.scale}`);
-            }
-        }
-        // Nullable
-        if (col.nullable) {
-            options.push('nullable: true');
-        }
-        // Unique
-        if (col.isUnique) {
-            options.push('unique: true');
-        }
-        // Default value
-        if (col.defaultValue !== undefined) {
-            options.push(`defaultValue: ${this.formatDefaultValue(col.defaultValue)}`);
-        }
-        // Index (single column)
-        if (this.options.includeIndexes) {
-            const indexes = this.ast.getTableIndexes(col.table.name);
-            const singleColIndex = indexes.find((idx) => idx.columns.length === 1 && idx.columns[0].name === col.name);
-            if (singleColIndex) {
-                options.push(`index: '${singleColIndex.name}'`);
-            }
-        }
-        return options.length > 0 ? `{ ${options.join(', ')} }` : '';
+        const indexes = this.options.includeIndexes ? this.ast.getTableIndexes(col.table.name) : [];
+        const singleColIndex = indexes.find((idx) => idx.columns.length === 1 && idx.columns[0].name === col.name);
+        return buildFieldOptionsSource(col, singleColIndex?.name);
     }
     /**
      * Build relation definitions.
@@ -340,30 +306,6 @@ export class EntityCodeGenerator {
             desc += ' UNSIGNED';
         return desc;
     }
-    /**
-     * Format default value for code.
-     */
-    formatDefaultValue(value) {
-        if (typeof value === 'string') {
-            // Check for SQL expressions
-            if (value.includes('(') ||
-                value.toUpperCase() === 'CURRENT_TIMESTAMP' ||
-                value.toUpperCase().includes('NEXTVAL')) {
-                return `'${value}'`; // Keep as string for expressions
-            }
-            return `'${value.replace(/'/g, "\\'")}'`;
-        }
-        if (typeof value === 'boolean') {
-            return value.toString();
-        }
-        if (typeof value === 'number') {
-            return value.toString();
-        }
-        if (value === null) {
-            return 'null';
-        }
-        return JSON.stringify(value);
-    }
     /**
      * Default class name transformer: table_name -> TableName (PascalCase, singular).
      */
@@ -402,4 +344,3 @@ export class EntityCodeGenerator {
 export function createEntityCodeGenerator(ast, options) {
     return new EntityCodeGenerator(ast, options);
 }
-//# sourceMappingURL=entityCodeGenerator.js.map

package/dist/migrate/codegen/fieldOptionsSource.d.ts

@@ -0,0 +1,10 @@
+import type { ColumnNode } from '../../schema/types.js';
+/**
+ * A column's `@Field({ ... })` options as source, or `''` when it needs none.
+ *
+ * Shared by the entity generator and the merger because they emit the same decorator. They each had
+ * their own copy, and the copies had drifted: the merger's dropped `unique` and `defaultValue`, so
+ * merging a column into an existing entity file quietly produced a weaker field than generating the
+ * file from scratch.
+ */
+export declare function buildFieldOptionsSource(col: ColumnNode, indexName?: string): string;

package/dist/migrate/codegen/fieldOptionsSource.js

@@ -0,0 +1,55 @@
+import { canonicalToColumnType } from '../../schema/canonicalType.js';
+/**
+ * A column's `@Field({ ... })` options as source, or `''` when it needs none.
+ *
+ * Shared by the entity generator and the merger because they emit the same decorator. They each had
+ * their own copy, and the copies had drifted: the merger's dropped `unique` and `defaultValue`, so
+ * merging a column into an existing entity file quietly produced a weaker field than generating the
+ * file from scratch.
+ */
+export function buildFieldOptionsSource(col, indexName) {
+    const options = [];
+    const columnType = canonicalToColumnType(col.type);
+    if (columnType) {
+        options.push(`columnType: '${columnType}'`);
+    }
+    if (col.type.length && col.type.category === 'string') {
+        options.push(`length: ${col.type.length}`);
+    }
+    if (col.type.precision !== undefined) {
+        options.push(`precision: ${col.type.precision}`);
+        if (col.type.scale !== undefined) {
+            options.push(`scale: ${col.type.scale}`);
+        }
+    }
+    if (col.nullable) {
+        options.push('nullable: true');
+    }
+    if (col.isUnique) {
+        options.push('unique: true');
+    }
+    if (col.defaultValue !== undefined) {
+        options.push(`defaultValue: ${formatDefaultValueSource(col.defaultValue)}`);
+    }
+    if (indexName) {
+        options.push(`index: '${indexName}'`);
+    }
+    return options.length > 0 ? `{ ${options.join(', ')} }` : '';
+}
+/**
+ * A default value as source. Strings stay single-quoted, expressions included: `defaultValue: 'now()'`
+ * is what reaches the DDL. The generator used to branch on `CURRENT_TIMESTAMP`/`NEXTVAL`/`(` first, but
+ * both branches emitted a quoted string and only the fallthrough escaped embedded quotes.
+ */
+function formatDefaultValueSource(value) {
+    if (typeof value === 'string') {
+        return `'${value.replace(/'/g, "\\'")}'`;
+    }
+    if (typeof value === 'boolean' || typeof value === 'number') {
+        return value.toString();
+    }
+    if (value === null) {
+        return 'null';
+    }
+    return JSON.stringify(value);
+}

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

@@ -4,8 +4,5 @@
  * Generates TypeScript entity code from database schemas.
  */
 export { createEntityCodeGenerator, EntityCodeGenerator, type EntityCodeGeneratorOptions, type GeneratedEntity, } from './entityCodeGenerator.js';
-export { createEntityMerger, EntityMerger, type EntityMergerOptions, type FieldToAdd, type FieldToDeprecate, type MergeResult, } from './entityMerger.js';
-export { createMigrationCodeGenerator, type GeneratedMigration, MigrationCodeGenerator, type MigrationCodeOptions, } from './migrationCodeGenerator.js';
 export { buildSqlQuerierMigrationModule, EMPTY_MANUAL_MIGRATION_DOWN_INNER, EMPTY_MANUAL_MIGRATION_UP_INNER, emitSqlRunCall, emitSqlRunCalls, type SqlMigrationModuleOptions, } from './migrationFile.js';
 export { createRelationDetector, type RelationDetectorOptions, SmartRelationDetector, } from './smartRelationDetector.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/migrate/codegen/index.js

@@ -5,11 +5,6 @@
  */
 // Entity code generator
 export { createEntityCodeGenerator, EntityCodeGenerator, } from './entityCodeGenerator.js';
-// Entity merger
-export { createEntityMerger, EntityMerger, } from './entityMerger.js';
-// Migration code generator
-export { createMigrationCodeGenerator, MigrationCodeGenerator, } from './migrationCodeGenerator.js';
 export { buildSqlQuerierMigrationModule, EMPTY_MANUAL_MIGRATION_DOWN_INNER, EMPTY_MANUAL_MIGRATION_UP_INNER, emitSqlRunCall, emitSqlRunCalls, } from './migrationFile.js';
 // Smart relation detector
 export { createRelationDetector, SmartRelationDetector, } from './smartRelationDetector.js';
-//# sourceMappingURL=index.js.map

package/dist/migrate/codegen/migrationFile.d.ts

@@ -26,4 +26,3 @@ export declare const EMPTY_MANUAL_MIGRATION_DOWN_INNER = "    // Add your rollba
  * Full contents of a `export default { async up/down(querier) { ... } }` migration module.
  */
 export declare function buildSqlQuerierMigrationModule(options: SqlMigrationModuleOptions): string;
-//# sourceMappingURL=migrationFile.d.ts.map

package/dist/migrate/codegen/migrationFile.js

@@ -45,4 +45,3 @@ ${options.downInner}
 };
 `;
 }
-//# sourceMappingURL=migrationFile.js.map

package/dist/migrate/codegen/smartRelationDetector.d.ts

@@ -45,4 +45,3 @@ export declare class SmartRelationDetector {
  * Create a SmartRelationDetector for the given AST.
  */
 export declare function createRelationDetector(ast: SchemaAST, options?: RelationDetectorOptions): SmartRelationDetector;
-//# sourceMappingURL=smartRelationDetector.d.ts.map

package/dist/migrate/codegen/smartRelationDetector.js

@@ -132,4 +132,3 @@ export class SmartRelationDetector {
 export function createRelationDetector(ast, options) {
     return new SmartRelationDetector(ast, options);
 }
-//# sourceMappingURL=smartRelationDetector.js.map

package/dist/migrate/drift/driftDetector.d.ts

@@ -77,4 +77,3 @@ export declare function createDriftDetector(expectedAST: SchemaAST, actualAST: S
  * Quick check for schema drift.
  */
 export declare function detectDrift(expectedAST: SchemaAST, actualAST: SchemaAST, options?: DriftDetectorOptions): DriftReport;
-//# sourceMappingURL=driftDetector.d.ts.map

package/dist/migrate/drift/driftDetector.js

@@ -244,4 +244,3 @@ export function detectDrift(expectedAST, actualAST, options) {
     const detector = new DriftDetector(expectedAST, actualAST, options);
     return detector.detect();
 }
-//# sourceMappingURL=driftDetector.js.map

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

@@ -4,4 +4,3 @@
  * Detects schema drift between expected and actual database schemas.
  */
 export { createDriftDetector, DriftDetector, type DriftDetectorOptions, detectDrift, } from './driftDetector.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/migrate/drift/index.js

@@ -4,4 +4,3 @@
  * Detects schema drift between expected and actual database schemas.
  */
 export { createDriftDetector, DriftDetector, detectDrift, } from './driftDetector.js';
-//# sourceMappingURL=index.js.map

package/dist/migrate/generator/indexNodeToSchema.d.ts

@@ -0,0 +1,9 @@
+import type { IndexNode } from '../../schema/types.js';
+import type { IndexSchema } from '../../type/index.js';
+/**
+ * An AST index as the generators and dialects want it. Spread rather than copied field by field:
+ * rebuilding it by hand is how the partial-index `where` once vanished without a trace. The node-only
+ * keys (`table`, `source`, `syncStatus`) are ignored downstream, and the vector type travels along
+ * because pgvector's operator-class names are built from it.
+ */
+export declare function indexNodeToSchema(index: IndexNode): IndexSchema;

package/dist/migrate/generator/indexNodeToSchema.js

@@ -0,0 +1,14 @@
+import { isVectorCategory } from '../../schema/canonicalType.js';
+/**
+ * An AST index as the generators and dialects want it. Spread rather than copied field by field:
+ * rebuilding it by hand is how the partial-index `where` once vanished without a trace. The node-only
+ * keys (`table`, `source`, `syncStatus`) are ignored downstream, and the vector type travels along
+ * because pgvector's operator-class names are built from it.
+ */
+export function indexNodeToSchema(index) {
+    return {
+        ...index,
+        columns: index.entries ?? index.columns.map((col) => ({ column: col.name })),
+        vectorType: index.columns.map((col) => col.type?.category).find(isVectorCategory),
+    };
+}

package/dist/migrate/generator/mongoCommand.d.ts

@@ -0,0 +1,57 @@
+/** The direction, or `'text'`, of one field in a MongoDB index key spec. */
+export type MongoIndexKey = Record<string, 1 | -1 | 'text'>;
+/**
+ * `SchemaGenerator` yields one string per statement, so {@link MongoSchemaGenerator} emits its
+ * commands as JSON and this is their schema.
+ *
+ * Declared next to the generator that writes them because the migrator used to restate the shape
+ * inline from `JSON.parse`, with `cmd.name!` assertions and a bare `action: string` - where a command
+ * it had no branch for (`renameCollection`) was silently a no-op.
+ */
+export type MongoCommand = {
+    readonly action: 'createCollection';
+    readonly name: string;
+} | {
+    readonly action: 'dropCollection';
+    readonly name: string;
+} | {
+    readonly action: 'renameCollection';
+    readonly from: string;
+    readonly to: string;
+} | {
+    readonly action: 'createIndex';
+    readonly collection: string;
+    readonly name: string;
+    readonly key: MongoIndexKey;
+    readonly options: {
+        readonly unique: boolean;
+        readonly name: string;
+    };
+} | {
+    readonly action: 'dropIndex';
+    readonly collection: string;
+    readonly name: string;
+};
+export declare function serializeMongoCommand(command: MongoCommand): string;
+/**
+ * What executing these commands needs of a database handle. Declared structurally rather than as the
+ * driver's `Db` so this module carries no dependency on the optional `mongodb` peer, and so a test can
+ * satisfy it with a plain object.
+ */
+export type MongoCommandTarget = {
+    createCollection(name: string): Promise<unknown>;
+    renameCollection(from: string, to: string): Promise<unknown>;
+    collection(name: string): {
+        drop(): Promise<unknown>;
+        createIndex(key: MongoIndexKey, options: {
+            unique: boolean;
+            name: string;
+        }): Promise<unknown>;
+        dropIndex(name: string): Promise<unknown>;
+    };
+};
+/**
+ * Execute one emitted command. The single cast lives here, where the union it casts to is defined
+ * alongside the only code that writes these strings.
+ */
+export declare function runMongoCommand(db: MongoCommandTarget, statement: string): Promise<unknown>;

package/dist/migrate/generator/mongoCommand.js

@@ -0,0 +1,26 @@
+export function serializeMongoCommand(command) {
+    return JSON.stringify(command);
+}
+/**
+ * Execute one emitted command. The single cast lives here, where the union it casts to is defined
+ * alongside the only code that writes these strings.
+ */
+export function runMongoCommand(db, statement) {
+    const command = JSON.parse(statement);
+    switch (command.action) {
+        case 'createCollection':
+            return db.createCollection(command.name);
+        case 'dropCollection':
+            return db.collection(command.name).drop();
+        case 'renameCollection':
+            return db.renameCollection(command.from, command.to);
+        case 'createIndex':
+            return db.collection(command.collection).createIndex(command.key, command.options);
+        case 'dropIndex':
+            return db.collection(command.collection).dropIndex(command.name);
+        default:
+            // Unreachable for a command this module produced; a hand-written statement lands here rather
+            // than being silently skipped, which is how `renameCollection` went unnoticed.
+            throw new TypeError(`unsupported MongoDB migration command: ${statement}`);
+    }
+}

package/dist/migrate/generator/mongoSchemaGenerator.d.ts

@@ -11,39 +11,27 @@ export declare class MongoSchemaGenerator extends AbstractDialect implements Sch
     generateCreateTable<E>(entity: Type<E>, _options?: {
         ifNotExists?: boolean;
     }): string[];
-    generateDropTable<E>(entity: Type<E>): string;
+    generateDropTable(tableName: string): string;
     generateAlterTable(diff: SchemaDiff): string[];
     generateAlterTableDown(diff: SchemaDiff): string[];
+    /**
+     * 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: string, index: IndexSchema): string;
     generateDropIndex(tableName: string, indexName: string): string;
     getSqlType(fieldOptions: FieldOptions, fieldType?: unknown): string;
-    getBooleanType(): string;
-    generateColumnDefinitions(): string[];
-    generateColumnDefinition(): string;
-    generateColumnDefinitionFromSchema(): string;
-    generateTableConstraints(): string[];
-    generateAlterColumnStatements(): string[];
-    getTableOptions(): string;
-    generateColumnComment(): string;
-    formatDefaultValue(): string;
     generateCreateTableFromNode(table: TableNode, _options?: {
         ifNotExists?: boolean;
     }): string[];
     generateCreateIndexFromNode(index: IndexNode): string;
-    generateDropTableFromNode(table: TableNode): string;
     generateCreateTableFromDefinition(table: TableDefinition, _options?: {
         ifNotExists?: boolean;
     }): string[];
-    generateDropTableSql(tableName: string): string;
     generateRenameTableSql(oldName: string, newName: string): string;
-    generateAddColumnSql(): string;
-    generateDropColumnSql(): string;
-    generateRenameColumnSql(): string;
-    generateAlterColumnSql(): string;
-    generateCreateIndexSql(tableName: string, index: IndexSchema): string;
-    generateDropIndexSql(tableName: string, indexName: string): string;
-    generateAddForeignKeySql(): string;
-    generateDropForeignKeySql(): string;
     diffSchema<E>(entity: Type<E>, currentTable: TableNode | undefined): SchemaDiff | undefined;
 }
-//# sourceMappingURL=mongoSchemaGenerator.d.ts.map

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,
                     });
                 }
@@ -186,4 +144,3 @@ export class MongoSchemaGenerator extends AbstractDialect {
         };
     }
 }
-//# sourceMappingURL=mongoSchemaGenerator.js.map

package/dist/migrate/index.d.ts

@@ -12,5 +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';
-//# sourceMappingURL=index.d.ts.map

package/dist/migrate/index.js

@@ -19,5 +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';
-//# sourceMappingURL=index.js.map

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,14 +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;
 }
-//# sourceMappingURL=abstractSqlSchemaIntrospector.d.ts.map