uql-orm 0.21.0 → 0.23.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.
  */
@@ -82,7 +83,6 @@ export class EntityCodeGenerator {
         if (this.options.includeRelations) {
             for (const rel of [...table.incomingRelations, ...table.outgoingRelations]) {
                 uqlImports.add(this.getRelationDecoratorName(rel.type));
-                uqlImports.add('Relation');
                 const relatedTable = rel.from.table === table ? rel.to.table : rel.from.table;
                 const relatedClassName = this.options.classNameTransformer(relatedTable.name);
                 if (!relatedImports.includes(relatedClassName)) {
@@ -183,44 +183,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.
@@ -272,7 +237,7 @@ export class EntityCodeGenerator {
         // Decorator
         lines.push(`  @${decoratorName}({ entity: () => ${relatedClassName} })`);
         // Property
-        lines.push(`  ${propertyName}?: Relation<${relatedClassName}>;`);
+        lines.push(`  ${propertyName}?: ${relatedClassName};`);
         return lines.join('\n');
     }
     /**
@@ -296,10 +261,10 @@ export class EntityCodeGenerator {
         lines.push(`  @${decoratorName}({ entity: () => ${relatedClassName}, references: '${inverseProp}' })`);
         // Property
         if (inverseType === 'OneToMany' || inverseType === 'ManyToMany') {
-            lines.push(`  ${propertyName}?: Relation<${relatedClassName}[]>;`);
+            lines.push(`  ${propertyName}?: ${relatedClassName}[];`);
         }
         else {
-            lines.push(`  ${propertyName}?: Relation<${relatedClassName}>;`);
+            lines.push(`  ${propertyName}?: ${relatedClassName};`);
         }
         return lines.join('\n');
     }
@@ -340,30 +305,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,4 @@
  * 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,4 @@
  */
 // 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/drift/driftDetector.d.ts

@@ -19,8 +19,17 @@ export interface DriftDetectorOptions {
     checkIndexes?: boolean;
     /** Include foreign key differences */
     checkForeignKeys?: boolean;
-    /** Include default value differences */
+    /**
+     * Include default value differences. Off by default: an engine reports a default as it stored it
+     * (`now()`, `CURRENT_TIMESTAMP`, `'active'::text`), which rarely matches the entity's literal.
+     */
     checkDefaults?: boolean;
+    /**
+     * Tables to leave out of the comparison. The migrations bookkeeping table belongs here - it exists in
+     * the database by design and has no entity, so reporting it as unexpected told every project to
+     * "create entity or drop table" for its own migration log.
+     */
+    excludeTables?: string[];
     /** Dialect instance for type formatting */
     dialect?: AbstractDialect;
 }

package/dist/migrate/drift/driftDetector.js

@@ -22,6 +22,7 @@ export class DriftDetector {
             checkIndexes: options.checkIndexes ?? true,
             checkForeignKeys: options.checkForeignKeys ?? true,
             checkDefaults: options.checkDefaults ?? false,
+            excludeTables: options.excludeTables ?? [],
             dialect: options.dialect,
         };
     }
@@ -30,7 +31,11 @@ export class DriftDetector {
      */
     detect() {
         const differ = new SchemaASTDiffer();
-        const diff = differ.diff(this.expectedAST, this.actualAST);
+        const diff = differ.diff(this.expectedAST, this.actualAST, {
+            compareIndexes: this.options.checkIndexes,
+            compareRelationships: this.options.checkForeignKeys,
+            excludeTables: this.options.excludeTables,
+        });
         const drifts = [
             ...this.detectTableDrifts(diff),
             ...this.detectColumnDrifts(diff),
@@ -137,13 +142,27 @@ export class DriftDetector {
                 });
             }
         }
+        if (this.options.checkDefaults && colDiff.expected && colDiff.actual) {
+            const expected = String(colDiff.expected.defaultValue ?? 'NULL');
+            const actual = String(colDiff.actual.defaultValue ?? 'NULL');
+            if (expected !== actual) {
+                drifts.push({
+                    type: 'constraint_mismatch',
+                    severity: 'info',
+                    table: colDiff.table,
+                    column: colDiff.column,
+                    expected,
+                    actual,
+                    details: `Default mismatch for "${colDiff.column}"`,
+                    suggestion: 'Align the default in the entity or the database',
+                });
+            }
+        }
     }
     /**
      * Detect index drifts.
      */
     detectIndexDrifts(diff) {
-        if (!this.options.checkIndexes)
-            return [];
         const drifts = [];
         for (const idxDiff of diff.indexDiffs) {
             if (idxDiff.type === 'create') {
@@ -173,8 +192,6 @@ export class DriftDetector {
      * Detect relationship/FK drifts.
      */
     detectRelationshipDrifts(diff) {
-        if (!this.options.checkForeignKeys)
-            return [];
         const drifts = [];
         for (const relDiff of diff.relationshipDiffs) {
             if (relDiff.type === 'create') {

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;
 }

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