uql-orm 0.21.0 → 0.22.0

package/dist/migrate/builder/types.d.ts

@@ -4,7 +4,8 @@
  * Type definitions for the fluent migration builder API.
  * Enables type-safe migrations without raw SQL.
  */
-import type { CanonicalType, ForeignKeyAction, IndexType } from '../../schema/types.js';
+import type { CanonicalType, ForeignKeyAction } from '../../schema/types.js';
+import type { IndexColumnInput, IndexOptions, IndexSchema } from '../../type/index.js';
 /**
  * Foreign key reference options.
  */
@@ -110,21 +111,6 @@ export interface FullColumnDefinition extends ColumnDefinition {
     /** Index name (if indexed) */
     index?: string | boolean;
 }
-/**
- * Index definition.
- */
-export interface IndexDefinition {
-    /** Index name */
-    name: string;
-    /** Column names */
-    columns: string[];
-    /** Whether unique */
-    unique: boolean;
-    /** Index type (btree, hash, etc.) */
-    type?: IndexType;
-    /** Partial index WHERE clause */
-    where?: string;
-}
 /**
  * Complete table definition.
  */
@@ -136,7 +122,7 @@ export interface TableDefinition {
     /** Primary key columns (for composite keys) */
     primaryKey?: string[];
     /** Index definitions */
-    indexes: IndexDefinition[];
+    indexes: IndexSchema[];
     /** Foreign key definitions at table level */
     foreignKeys: TableForeignKeyDefinition[];
     /** Table comment */
@@ -234,7 +220,7 @@ export interface RenameColumnOperation extends MigrationOperation {
 export interface CreateIndexOperation extends MigrationOperation {
     type: 'createIndex';
     tableName: string;
-    index: IndexDefinition;
+    index: IndexSchema;
     ifNotExists?: boolean;
 }
 /**
@@ -310,9 +296,13 @@ export interface IForeignKeyBuilder extends IColumnBuilder {
     onUpdate(action: ForeignKeyAction): this;
 }
 /**
- * Interface for table builder (fluent API).
+ * The column vocabulary: every column type the builder can declare, name first.
+ *
+ * Split out of {@link ITableBuilder} so `addColumn`/`alterColumn` can hand it to their callback. They
+ * used to take an {@link IColumnBuilder}, which has no way to say what type a column is - so the
+ * builder hard-coded `VARCHAR`, and every column a generated migration added or altered was a string.
  */
-export interface ITableBuilder {
+export interface IColumnFactory {
     /** Add an auto-incrementing primary key */
     id(name?: string, options?: BaseColumnOptions): IColumnBuilder;
     /** Add an integer column */
@@ -353,6 +343,11 @@ export interface ITableBuilder {
     blob(name: string, options?: BaseColumnOptions): IColumnBuilder;
     /** Add a vector column (for embeddings) */
     vector(name: string, options?: VectorColumnOptions): IColumnBuilder;
+}
+/**
+ * Interface for table builder (fluent API).
+ */
+export interface ITableBuilder extends IColumnFactory {
     /** Add createdAt timestamp column */
     createdAt(): IColumnBuilder;
     /** Add updatedAt timestamp column */
@@ -361,10 +356,10 @@ export interface ITableBuilder {
     timestamps(): void;
     /** Add composite primary key */
     primaryKey(columns: string[]): this;
-    /** Add composite unique constraint */
-    unique(columns: string[], name?: string): this;
-    /** Add composite index */
-    index(columns: string[], name?: string): this;
+    /** Add a composite unique index; takes the same options as `@Index`, or just its name. */
+    unique(columns: readonly IndexColumnInput[], options?: string | IndexOptions): this;
+    /** Add a composite index; takes the same options as `@Index`, or just its name. */
+    index(columns: readonly IndexColumnInput[], options?: string | IndexOptions): this;
     /** Add table-level foreign key */
     foreignKey(columns: string[]): ITableForeignKeyBuilder;
     /** Add a comment to the table */
@@ -389,19 +384,16 @@ export interface ITableForeignKeyBuilder {
  * Interface for altering a table.
  */
 export interface IAlterTableBuilder {
-    /** Add a column to the table */
-    addColumn(name: string, callback: (column: IColumnBuilder) => void): this;
+    /** Add a column, declared exactly as in `createTable`: `addColumn((c) => c.timestamp('createdAt'))`. */
+    addColumn(callback: (columns: IColumnFactory) => IColumnBuilder): this;
     /** Drop a column from the table */
     dropColumn(name: string): this;
     /** Rename a column */
     renameColumn(oldName: string, newName: string): this;
-    /** Alter a column definition */
-    alterColumn(name: string, callback: (column: IColumnBuilder) => void): this;
+    /** Redeclare a column, named and typed as it should end up. */
+    alterColumn(callback: (columns: IColumnFactory) => IColumnBuilder): this;
     /** Add an index to the table */
-    addIndex(columns: string[], options?: {
-        name?: string;
-        unique?: boolean;
-    }): this;
+    addIndex(columns: readonly IndexColumnInput[], options?: IndexOptions): this;
     /** Drop an index from the table */
     dropIndex(name: string): this;
     /** Add a foreign key to the table */
@@ -431,19 +423,16 @@ export interface IMigrationBuilder {
     renameTable(oldName: string, newName: string): Promise<void>;
     /** Alter an existing table */
     alterTable(name: string, callback: (table: IAlterTableBuilder) => void): Promise<void>;
-    /** Add a column to an existing table */
-    addColumn(tableName: string, columnName: string, callback: (column: IColumnBuilder) => void): Promise<void>;
+    /** Add a column, declared exactly as in `createTable`: `addColumn('t', (c) => c.timestamp('at'))`. */
+    addColumn(tableName: string, callback: (columns: IColumnFactory) => IColumnBuilder): Promise<void>;
     /** Drop a column from a table */
     dropColumn(tableName: string, columnName: string): Promise<void>;
-    /** Alter a column */
-    alterColumn(tableName: string, columnName: string, callback: (column: IColumnBuilder) => void): Promise<void>;
+    /** Redeclare a column, named and typed as it should end up. */
+    alterColumn(tableName: string, callback: (columns: IColumnFactory) => IColumnBuilder): Promise<void>;
     /** Rename a column */
     renameColumn(tableName: string, oldName: string, newName: string): Promise<void>;
-    /** Create an index */
-    createIndex(tableName: string, columns: string[], options?: {
-        name?: string;
-        unique?: boolean;
-    }): Promise<void>;
+    /** Create an index; takes the same options as `@Index`, so a generated migration can restate them. */
+    createIndex(tableName: string, columns: readonly IndexColumnInput[], options?: IndexOptions): Promise<void>;
     /** Drop an index */
     dropIndex(tableName: string, indexName: string): Promise<void>;
     /** Add a foreign key */

package/dist/migrate/cli.d.ts

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 import type { AbstractDialect } from '../dialect/index.js';
-import type { Config, NamingStrategy } from '../type/index.js';
+import type { ForeignKeyAction } from '../schema/types.js';
+import type { Config } from '../type/index.js';
 import { Migrator } from './migrator.js';
 import { createSchemaGeneratorAsync } from './schemaGeneratorAsync.js';
 /** Sync helper for SQL dialects only; returns `undefined` for MongoDB - use {@link createSchemaGeneratorAsync}. */
-export declare function getSchemaGenerator(dialect: AbstractDialect, namingStrategy?: NamingStrategy): import("../type/migration.js").SchemaGenerator | undefined;
+export declare function getSchemaGenerator(dialect: AbstractDialect, defaultForeignKeyAction?: ForeignKeyAction): import("./schemaGenerator.js").SqlSchemaGenerator | undefined;
 export { createSchemaGeneratorAsync };
 export declare function main(args?: string[]): Promise<void>;
 export declare function runUp(migrator: Migrator, args: string[]): Promise<void>;

package/dist/migrate/cli.js

@@ -9,10 +9,9 @@ import { detectDrift } from './drift/driftDetector.js';
 import { Migrator } from './migrator.js';
 import { createSchemaGenerator } from './schemaGenerator.js';
 import { createSchemaGeneratorAsync } from './schemaGeneratorAsync.js';
-import { createSchemaSync } from './sync/schemaSync.js';
 /** Sync helper for SQL dialects only; returns `undefined` for MongoDB - use {@link createSchemaGeneratorAsync}. */
-export function getSchemaGenerator(dialect, namingStrategy) {
-    return createSchemaGenerator(dialect, namingStrategy);
+export function getSchemaGenerator(dialect, defaultForeignKeyAction) {
+    return createSchemaGenerator(dialect, defaultForeignKeyAction);
 }
 export { createSchemaGeneratorAsync };
 export async function main(args = process.argv.slice(2)) {
@@ -40,11 +39,11 @@ export async function main(args = process.argv.slice(2)) {
             tableName: config.tableName,
             logger: console.log,
             entities: config.entities,
-            namingStrategy: config.namingStrategy,
+            defaultForeignKeyAction: config.defaultForeignKeyAction,
         };
         const migrator = new Migrator(config.pool, options);
         if (!migrator.schemaGenerator) {
-            const generator = await createSchemaGeneratorAsync(config.pool.dialect, config.namingStrategy);
+            const generator = await createSchemaGeneratorAsync(config.pool.dialect, config.defaultForeignKeyAction);
             if (!generator) {
                 throw new TypeError(`Could not find a schema generator for dialect: ${dialectName}`);
             }
@@ -191,49 +190,25 @@ export async function runGenerateFromEntities(migrator, args) {
     console.log(`\nCreated migration from entities: ${filePath}`);
 }
 export async function runSync(migrator, args, config) {
-    const force = args.includes('--force');
-    const push = args.includes('--push');
-    const pull = args.includes('--pull');
-    const dryRun = args.includes('--dry-run');
-    // Parse direction
-    let direction = 'bidirectional';
-    for (let i = 0; i < args.length; i++) {
-        if (args[i] === '--direction' && args[i + 1]) {
-            direction = args[++i];
-        }
-    }
-    // Shorthand flags
-    if (push)
-        direction = 'entity-to-db';
-    if (pull)
-        direction = 'db-to-entity';
-    if (force) {
+    if (args.includes('--force')) {
         console.log('\n⚠️  WARNING: This will drop and recreate all tables!');
         console.log('   All data will be lost. This should only be used in development.\n');
-        await migrator.sync({ force });
+        await migrator.sync({ force: true });
         console.log('\nSchema sync completed.');
         return;
     }
-    // Use SchemaSync for direction-aware sync
-    if (config.entities && migrator.schemaIntrospector) {
-        const schemaSync = createSchemaSync({
-            entities: config.entities,
-            introspector: migrator.schemaIntrospector,
-            direction,
-            safe: !args.includes('--unsafe'),
-            dryRun,
-        });
-        const result = await schemaSync.sync();
-        console.log('\n' + result.summary);
-        if (result.conflicts.length > 0) {
-            console.log('\n⚠️  Conflicts require manual resolution.');
-            process.exit(1);
-        }
+    // Pulling the database into entity files is what `generate:from-db` does; one implementation.
+    if (args.includes('--pull')) {
+        return runGenerateFromDb(migrator, args, config);
     }
-    else {
-        await migrator.sync({ force: false });
-        console.log('\nSchema sync completed.');
+    const safe = !args.includes('--unsafe');
+    if (args.includes('--dry-run')) {
+        const statements = await migrator.planSync({ safe, drop: !safe });
+        console.log(statements.length ? `\n${statements.join('\n')}` : '\nSchema is already in sync.');
+        return;
     }
+    await migrator.autoSync({ safe, drop: !safe, logging: true });
+    console.log('\nSchema sync completed.');
 }
 export async function runGenerateFromDb(migrator, args, config) {
     // Parse output directory
@@ -359,13 +334,11 @@ Commands:
   generate:from-db      Generate TypeScript entities from database
     --output, -o <dir>  Output directory (default: ./src/entities)
 
-  sync                  Sync schema with direction support
+  sync                  Apply the entity schema to the database
+    --dry-run           Print the statements instead of running them
+    --unsafe            Allow destructive changes (drops, column alterations)
+    --pull              Go the other way: generate entities from the database
     --force             Drop and recreate all tables (dangerous!)
-    --direction <mode>  Sync direction: bidirectional, entity-to-db, db-to-entity
-    --push              Shorthand for --direction entity-to-db
-    --pull              Shorthand for --direction db-to-entity
-    --dry-run           Preview changes without applying
-    --unsafe            Allow destructive changes
 
   drift:check           Check for schema drift between entities and database
 
@@ -391,7 +364,7 @@ Examples:
   uql-orm/migrate generate add_users_table
   uql-orm/migrate generate:entities initial_schema
   uql-orm/migrate generate:from-db --output ./src/entities
-  uql-orm/migrate sync --push
+  uql-orm/migrate sync --dry-run
   uql-orm/migrate sync --pull
   uql-orm/migrate drift:check
 `);

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

@@ -105,10 +105,6 @@ export declare class EntityCodeGenerator {
      * Format type for description.
      */
     private formatTypeDescription;
-    /**
-     * Format default value for code.
-     */
-    private formatDefaultValue;
     /**
      * Default class name transformer: table_name -> TableName (PascalCase, singular).
      */

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).
      */

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,7 +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';

package/dist/migrate/codegen/index.js

@@ -5,10 +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';

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