@uql/core 1.0.12 → 3.1.0

package/dist/migrate/migrator.js

@@ -0,0 +1,600 @@
+import { readdir } from 'node:fs/promises';
+import { basename, extname, join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { getEntities, getMeta } from '../entity/index.js';
+import { isSqlQuerier } from '../type/index.js';
+import { MariadbSchemaGenerator, MongoSchemaGenerator, MysqlSchemaGenerator, PostgresSchemaGenerator, SqliteSchemaGenerator, } from './generator/index.js';
+import { MariadbSchemaIntrospector, MongoSchemaIntrospector, MysqlSchemaIntrospector, PostgresSchemaIntrospector, SqliteSchemaIntrospector, } from './introspection/index.js';
+import { DatabaseMigrationStorage } from './storage/databaseStorage.js';
+/**
+ * Main class for managing database migrations
+ */
+export class Migrator {
+    querierPool;
+    storage;
+    migrationsPath;
+    logger;
+    entities;
+    dialect;
+    schemaGenerator;
+    schemaIntrospector;
+    constructor(querierPool, options = {}) {
+        this.querierPool = querierPool;
+        this.dialect = options.dialect ?? querierPool.dialect ?? 'postgres';
+        this.storage =
+            options.storage ??
+                new DatabaseMigrationStorage(querierPool, {
+                    tableName: options.tableName,
+                });
+        this.migrationsPath = options.migrationsPath ?? './migrations';
+        this.logger = options.logger ?? (() => { });
+        this.entities = options.entities ?? [];
+        this.schemaIntrospector = this.createIntrospector();
+        this.schemaGenerator = options.schemaGenerator ?? this.createGenerator(options.namingStrategy);
+    }
+    /**
+     * Set the schema generator for DDL operations
+     */
+    setSchemaGenerator(generator) {
+        this.schemaGenerator = generator;
+    }
+    createIntrospector() {
+        switch (this.dialect) {
+            case 'postgres':
+                return new PostgresSchemaIntrospector(this.querierPool);
+            case 'mysql':
+                return new MysqlSchemaIntrospector(this.querierPool);
+            case 'mariadb':
+                return new MariadbSchemaIntrospector(this.querierPool);
+            case 'sqlite':
+                return new SqliteSchemaIntrospector(this.querierPool);
+            case 'mongodb':
+                return new MongoSchemaIntrospector(this.querierPool);
+            default:
+                return undefined;
+        }
+    }
+    createGenerator(namingStrategy) {
+        switch (this.dialect) {
+            case 'postgres':
+                return new PostgresSchemaGenerator(namingStrategy);
+            case 'mysql':
+                return new MysqlSchemaGenerator(namingStrategy);
+            case 'mariadb':
+                return new MariadbSchemaGenerator(namingStrategy);
+            case 'sqlite':
+                return new SqliteSchemaGenerator(namingStrategy);
+            case 'mongodb':
+                return new MongoSchemaGenerator(namingStrategy);
+            default:
+                return undefined;
+        }
+    }
+    /**
+     * Get the SQL dialect
+     */
+    getDialect() {
+        return this.dialect;
+    }
+    /**
+     * Get all discovered migrations from the migrations directory
+     */
+    async getMigrations() {
+        const files = await this.getMigrationFiles();
+        const migrations = [];
+        for (const file of files) {
+            const migration = await this.loadMigration(file);
+            if (migration) {
+                migrations.push(migration);
+            }
+        }
+        // Sort by name (which typically includes timestamp)
+        return migrations.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    /**
+     * Get list of pending migrations (not yet executed)
+     */
+    async pending() {
+        const [migrations, executed] = await Promise.all([this.getMigrations(), this.storage.executed()]);
+        const executedSet = new Set(executed);
+        return migrations.filter((m) => !executedSet.has(m.name));
+    }
+    /**
+     * Get list of executed migrations
+     */
+    async executed() {
+        return this.storage.executed();
+    }
+    /**
+     * Run all pending migrations
+     */
+    async up(options = {}) {
+        const pendingMigrations = await this.pending();
+        const results = [];
+        let migrationsToRun = pendingMigrations;
+        if (options.to) {
+            const toIndex = migrationsToRun.findIndex((m) => m.name === options.to);
+            if (toIndex === -1) {
+                throw new Error(`Migration '${options.to}' not found`);
+            }
+            migrationsToRun = migrationsToRun.slice(0, toIndex + 1);
+        }
+        if (options.step !== undefined) {
+            migrationsToRun = migrationsToRun.slice(0, options.step);
+        }
+        for (const migration of migrationsToRun) {
+            const result = await this.runMigration(migration, 'up');
+            results.push(result);
+            if (!result.success) {
+                break; // Stop on first failure
+            }
+        }
+        return results;
+    }
+    /**
+     * Rollback migrations
+     */
+    async down(options = {}) {
+        const [migrations, executed] = await Promise.all([this.getMigrations(), this.storage.executed()]);
+        const executedSet = new Set(executed);
+        const executedMigrations = migrations.filter((m) => executedSet.has(m.name)).reverse(); // Rollback in reverse order
+        const results = [];
+        let migrationsToRun = executedMigrations;
+        if (options.to) {
+            const toIndex = migrationsToRun.findIndex((m) => m.name === options.to);
+            if (toIndex === -1) {
+                throw new Error(`Migration '${options.to}' not found`);
+            }
+            migrationsToRun = migrationsToRun.slice(0, toIndex + 1);
+        }
+        if (options.step !== undefined) {
+            migrationsToRun = migrationsToRun.slice(0, options.step);
+        }
+        for (const migration of migrationsToRun) {
+            const result = await this.runMigration(migration, 'down');
+            results.push(result);
+            if (!result.success) {
+                break; // Stop on first failure
+            }
+        }
+        return results;
+    }
+    /**
+     * Run a single migration within a transaction
+     */
+    async runMigration(migration, direction) {
+        const startTime = Date.now();
+        const querier = await this.querierPool.getQuerier();
+        if (!isSqlQuerier(querier)) {
+            await querier.release();
+            throw new Error('Migrator requires a SQL-based querier');
+        }
+        try {
+            this.logger(`${direction === 'up' ? 'Running' : 'Reverting'} migration: ${migration.name}`);
+            await querier.beginTransaction();
+            if (direction === 'up') {
+                await migration.up(querier);
+                // Log within the same transaction
+                await this.storage.logWithQuerier(querier, migration.name);
+            }
+            else {
+                await migration.down(querier);
+                // Unlog within the same transaction
+                await this.storage.unlogWithQuerier(querier, migration.name);
+            }
+            await querier.commitTransaction();
+            const duration = Date.now() - startTime;
+            this.logger(`Migration ${migration.name} ${direction === 'up' ? 'applied' : 'reverted'} in ${duration}ms`);
+            return {
+                name: migration.name,
+                direction,
+                duration,
+                success: true,
+            };
+        }
+        catch (error) {
+            await querier.rollbackTransaction();
+            const duration = Date.now() - startTime;
+            this.logger(`Migration ${migration.name} failed: ${error.message}`);
+            return {
+                name: migration.name,
+                direction,
+                duration,
+                success: false,
+                error: error,
+            };
+        }
+        finally {
+            await querier.release();
+        }
+    }
+    /**
+     * Generate a new migration file
+     */
+    async generate(name) {
+        const timestamp = this.getTimestamp();
+        const fileName = `${timestamp}_${this.slugify(name)}.ts`;
+        const filePath = join(this.migrationsPath, fileName);
+        const content = this.generateMigrationContent(name);
+        const { writeFile, mkdir } = await import('node:fs/promises');
+        await mkdir(this.migrationsPath, { recursive: true });
+        await writeFile(filePath, content, 'utf-8');
+        this.logger(`Created migration: ${filePath}`);
+        return filePath;
+    }
+    /**
+     * Generate a migration based on entity schema differences
+     */
+    async generateFromEntities(name) {
+        if (!this.schemaGenerator) {
+            throw new Error('Schema generator not set. Call setSchemaGenerator() first.');
+        }
+        const diffs = await this.getDiffs();
+        const upStatements = [];
+        const downStatements = [];
+        for (const diff of diffs) {
+            if (diff.type === 'create') {
+                const entity = this.findEntityForTable(diff.tableName);
+                if (entity) {
+                    upStatements.push(this.schemaGenerator.generateCreateTable(entity));
+                    downStatements.push(this.schemaGenerator.generateDropTable(entity));
+                }
+            }
+            else if (diff.type === 'alter') {
+                const alterStatements = this.schemaGenerator.generateAlterTable(diff);
+                upStatements.push(...alterStatements);
+                const alterDownStatements = this.schemaGenerator.generateAlterTableDown(diff);
+                downStatements.push(...alterDownStatements);
+            }
+        }
+        if (upStatements.length === 0) {
+            this.logger('No schema changes detected.');
+            return '';
+        }
+        const timestamp = this.getTimestamp();
+        const fileName = `${timestamp}_${this.slugify(name)}.ts`;
+        const filePath = join(this.migrationsPath, fileName);
+        const content = this.generateMigrationContentWithStatements(name, upStatements, downStatements.reverse());
+        const { writeFile, mkdir } = await import('node:fs/promises');
+        await mkdir(this.migrationsPath, { recursive: true });
+        await writeFile(filePath, content, 'utf-8');
+        this.logger(`Created migration from entities: ${filePath}`);
+        return filePath;
+    }
+    /**
+     * Get all schema differences between entities and database
+     */
+    async getDiffs() {
+        if (!this.schemaGenerator || !this.schemaIntrospector) {
+            throw new Error('Schema generator and introspector must be set');
+        }
+        const entities = this.entities.length > 0 ? this.entities : getEntities();
+        const diffs = [];
+        for (const entity of entities) {
+            const meta = getMeta(entity);
+            const tableName = this.schemaGenerator.resolveTableName(entity, meta);
+            const currentSchema = await this.schemaIntrospector.getTableSchema(tableName);
+            const diff = this.schemaGenerator.diffSchema(entity, currentSchema);
+            if (diff) {
+                diffs.push(diff);
+            }
+        }
+        return diffs;
+    }
+    findEntityForTable(tableName) {
+        const entities = this.entities.length > 0 ? this.entities : getEntities();
+        for (const entity of entities) {
+            const meta = getMeta(entity);
+            const name = this.schemaGenerator.resolveTableName(entity, meta);
+            if (name === tableName) {
+                return entity;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Sync schema directly (for development only - not for production!)
+     */
+    async sync(options = {}) {
+        if (options.force) {
+            return this.syncForce();
+        }
+        return this.autoSync({ safe: true });
+    }
+    /**
+     * Drops and recreates all tables (Development only!)
+     */
+    async syncForce() {
+        if (!this.schemaGenerator) {
+            throw new Error('Schema generator not set. Call setSchemaGenerator() first.');
+        }
+        const entities = this.entities.length > 0 ? this.entities : getEntities();
+        const querier = await this.querierPool.getQuerier();
+        if (!isSqlQuerier(querier)) {
+            await querier.release();
+            throw new Error('Migrator requires a SQL-based querier');
+        }
+        try {
+            await querier.beginTransaction();
+            // Drop all tables first (in reverse order for foreign keys)
+            for (const entity of [...entities].reverse()) {
+                const dropSql = this.schemaGenerator.generateDropTable(entity);
+                this.logger(`Executing: ${dropSql}`);
+                await querier.run(dropSql);
+            }
+            // Create all tables
+            for (const entity of entities) {
+                const createSql = this.schemaGenerator.generateCreateTable(entity);
+                this.logger(`Executing: ${createSql}`);
+                await querier.run(createSql);
+            }
+            await querier.commitTransaction();
+            this.logger('Schema sync (force) completed');
+        }
+        catch (error) {
+            await querier.rollbackTransaction();
+            throw error;
+        }
+        finally {
+            await querier.release();
+        }
+    }
+    /**
+     * Safely synchronizes the schema by only adding missing tables and columns.
+     */
+    async autoSync(options = {}) {
+        if (!this.schemaGenerator || !this.schemaIntrospector) {
+            throw new Error('Schema generator and introspector must be set');
+        }
+        const diffs = await this.getDiffs();
+        const statements = [];
+        for (const diff of diffs) {
+            if (diff.type === 'create') {
+                const entity = this.findEntityForTable(diff.tableName);
+                if (entity) {
+                    statements.push(this.schemaGenerator.generateCreateTable(entity));
+                }
+            }
+            else if (diff.type === 'alter') {
+                const filteredDiff = this.filterDiff(diff, options);
+                const alterStatements = this.schemaGenerator.generateAlterTable(filteredDiff);
+                statements.push(...alterStatements);
+            }
+        }
+        if (statements.length === 0) {
+            if (options.logging)
+                this.logger('Schema is already in sync.');
+            return;
+        }
+        await this.executeSyncStatements(statements, options);
+    }
+    filterDiff(diff, options) {
+        const filteredDiff = { ...diff };
+        if (options.safe !== false) {
+            // In safe mode, we only allow additions
+            delete filteredDiff.columnsToDrop;
+            delete filteredDiff.indexesToDrop;
+            delete filteredDiff.foreignKeysToDrop;
+        }
+        if (!options.drop) {
+            delete filteredDiff.columnsToDrop;
+        }
+        return filteredDiff;
+    }
+    async executeSyncStatements(statements, options) {
+        const querier = await this.querierPool.getQuerier();
+        try {
+            if (this.dialect === 'mongodb') {
+                await this.executeMongoSyncStatements(statements, options, querier);
+            }
+            else {
+                await this.executeSqlSyncStatements(statements, options, querier);
+            }
+            if (options.logging)
+                this.logger('Schema synchronization completed');
+        }
+        catch (error) {
+            if (this.dialect !== 'mongodb' && isSqlQuerier(querier)) {
+                await querier.rollbackTransaction();
+            }
+            throw error;
+        }
+        finally {
+            await querier.release();
+        }
+    }
+    async executeMongoSyncStatements(statements, options, querier) {
+        const db = querier.db;
+        for (const stmt of statements) {
+            const cmd = JSON.parse(stmt);
+            if (options.logging)
+                this.logger(`Executing MongoDB: ${stmt}`);
+            const collectionName = cmd.name || cmd.collection;
+            if (!collectionName) {
+                throw new Error(`MongoDB command missing collection name: ${stmt}`);
+            }
+            const collection = db.collection(collectionName);
+            if (cmd.action === 'createCollection') {
+                await db.createCollection(cmd.name);
+                if (cmd.indexes?.length) {
+                    for (const idx of cmd.indexes) {
+                        const key = Object.fromEntries(idx.columns.map((c) => [c, 1]));
+                        await collection.createIndex(key, { unique: idx.unique, name: idx.name });
+                    }
+                }
+            }
+            else if (cmd.action === 'dropCollection') {
+                await collection.drop();
+            }
+            else if (cmd.action === 'createIndex') {
+                await collection.createIndex(cmd.key, cmd.options);
+            }
+            else if (cmd.action === 'dropIndex') {
+                await collection.dropIndex(cmd.name);
+            }
+        }
+    }
+    async executeSqlSyncStatements(statements, options, querier) {
+        if (!isSqlQuerier(querier)) {
+            throw new Error('Migrator requires a SQL-based querier for this dialect');
+        }
+        await querier.beginTransaction();
+        for (const sql of statements) {
+            if (options.logging)
+                this.logger(`Executing: ${sql}`);
+            await querier.run(sql);
+        }
+        await querier.commitTransaction();
+    }
+    /**
+     * Get migration status
+     */
+    async status() {
+        const [pending, executed] = await Promise.all([this.pending().then((m) => m.map((x) => x.name)), this.executed()]);
+        return { pending, executed };
+    }
+    /**
+     * Get migration files from the migrations directory
+     */
+    async getMigrationFiles() {
+        try {
+            const files = await readdir(this.migrationsPath);
+            return files
+                .filter((f) => /\.(ts|js|mjs)$/.test(f))
+                .filter((f) => !f.endsWith('.d.ts'))
+                .sort();
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return [];
+            }
+            throw error;
+        }
+    }
+    /**
+     * Load a migration from a file
+     */
+    async loadMigration(fileName) {
+        const filePath = join(this.migrationsPath, fileName);
+        const fileUrl = pathToFileURL(filePath).href;
+        try {
+            const module = await import(fileUrl);
+            const migration = module.default ?? module;
+            if (this.isMigration(migration)) {
+                return {
+                    name: this.getMigrationName(fileName),
+                    up: migration.up.bind(migration),
+                    down: migration.down.bind(migration),
+                };
+            }
+            this.logger(`Warning: ${fileName} is not a valid migration`);
+            return undefined;
+        }
+        catch (error) {
+            this.logger(`Error loading migration ${fileName}: ${error.message}`);
+            return undefined;
+        }
+    }
+    /**
+     * Check if an object is a valid migration
+     */
+    isMigration(obj) {
+        return (typeof obj === 'object' &&
+            obj !== undefined &&
+            obj !== null &&
+            typeof obj.up === 'function' &&
+            typeof obj.down === 'function');
+    }
+    /**
+     * Extract migration name from filename
+     */
+    getMigrationName(fileName) {
+        return basename(fileName, extname(fileName));
+    }
+    /**
+     * Generate timestamp string for migration names
+     */
+    getTimestamp() {
+        const now = new Date();
+        return [
+            now.getFullYear(),
+            String(now.getMonth() + 1).padStart(2, '0'),
+            String(now.getDate()).padStart(2, '0'),
+            String(now.getHours()).padStart(2, '0'),
+            String(now.getMinutes()).padStart(2, '0'),
+            String(now.getSeconds()).padStart(2, '0'),
+        ].join('');
+    }
+    /**
+     * Convert a string to a slug for filenames
+     */
+    slugify(text) {
+        return text
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '_')
+            .replace(/^_+|_+$/g, '');
+    }
+    /**
+     * Generate migration file content
+     */
+    generateMigrationContent(name) {
+        return /*ts*/ `import type { SqlQuerier } from '@uql/migrate';
+
+/**
+ * Migration: ${name}
+ * Created: ${new Date().toISOString()}
+ */
+export default {
+  async up(querier: SqlQuerier): Promise<void> {
+    // Add your migration logic here
+    // Example:
+    // await querier.run(\`
+    //   CREATE TABLE "users" (
+    //     "id" SERIAL PRIMARY KEY,
+    //     "name" VARCHAR(255) NOT NULL,
+    //     "email" VARCHAR(255) UNIQUE NOT NULL,
+    //     "createdAt" TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    //   )
+    // \`);
+  },
+
+  async down(querier: SqlQuerier): Promise<void> {
+    // Add your rollback logic here
+    // Example:
+    // await querier.run(\`DROP TABLE IF EXISTS "users"\`);
+  },
+};
+`;
+    }
+    /**
+     * Generate migration file content with SQL statements
+     */
+    generateMigrationContentWithStatements(name, upStatements, downStatements) {
+        const upSql = upStatements.map((s) => /*ts*/ `    await querier.run(\`${s}\`);`).join('\n');
+        const downSql = downStatements.map((s) => /*ts*/ `    await querier.run(\`${s}\`);`).join('\n');
+        return /*ts*/ `import type { SqlQuerier } from '@uql/migrate';
+
+/**
+ * Migration: ${name}
+ * Created: ${new Date().toISOString()}
+ * Generated from entity definitions
+ */
+export default {
+  async up(querier: SqlQuerier): Promise<void> {
+${upSql}
+  },
+
+  async down(querier: SqlQuerier): Promise<void> {
+${downSql}
+  },
+};
+`;
+    }
+}
+/**
+ * Helper function to define a migration with proper typing
+ */
+export function defineMigration(migration) {
+    return migration;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"migrator.js","sourceRoot":"","sources":["../../src/migrate/migrator.ts"],"names":[],"mappings":"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","sourcesContent":["import { readdir } from 'node:fs/promises';\nimport { basename, extname, join } from 'node:path';\nimport { pathToFileURL } from 'node:url';\nimport { getEntities, getMeta } from '../entity/index.js';\nimport type {\n  Dialect,\n  Migration,\n  MigrationDefinition,\n  MigrationResult,\n  MigrationStorage,\n  MigratorOptions,\n  MongoQuerier,\n  NamingStrategy,\n  Querier,\n  QuerierPool,\n  SchemaDiff,\n  SchemaGenerator,\n  SchemaIntrospector,\n  Type,\n} from '../type/index.js';\nimport { isSqlQuerier } from '../type/index.js';\nimport {\n  MariadbSchemaGenerator,\n  MongoSchemaGenerator,\n  MysqlSchemaGenerator,\n  PostgresSchemaGenerator,\n  SqliteSchemaGenerator,\n} from './generator/index.js';\nimport {\n  MariadbSchemaIntrospector,\n  MongoSchemaIntrospector,\n  MysqlSchemaIntrospector,\n  PostgresSchemaIntrospector,\n  SqliteSchemaIntrospector,\n} from './introspection/index.js';\nimport { DatabaseMigrationStorage } from './storage/databaseStorage.js';\n\n/**\n * Main class for managing database migrations\n */\nexport class Migrator {\n  private readonly storage: MigrationStorage;\n  private readonly migrationsPath: string;\n  private readonly logger: (message: string) => void;\n  private readonly entities: Type<unknown>[];\n  private readonly dialect: Dialect;\n  private schemaGenerator?: SchemaGenerator;\n  public schemaIntrospector?: SchemaIntrospector;\n\n  constructor(\n    private readonly querierPool: QuerierPool,\n    options: MigratorOptions = {},\n  ) {\n    this.dialect = options.dialect ?? querierPool.dialect ?? 'postgres';\n    this.storage =\n      options.storage ??\n      new DatabaseMigrationStorage(querierPool, {\n        tableName: options.tableName,\n      });\n    this.migrationsPath = options.migrationsPath ?? './migrations';\n    this.logger = options.logger ?? (() => {});\n    this.entities = options.entities ?? [];\n    this.schemaIntrospector = this.createIntrospector();\n    this.schemaGenerator = options.schemaGenerator ?? this.createGenerator(options.namingStrategy);\n  }\n\n  /**\n   * Set the schema generator for DDL operations\n   */\n  setSchemaGenerator(generator: SchemaGenerator): void {\n    this.schemaGenerator = generator;\n  }\n\n  private createIntrospector(): SchemaIntrospector | undefined {\n    switch (this.dialect) {\n      case 'postgres':\n        return new PostgresSchemaIntrospector(this.querierPool);\n      case 'mysql':\n        return new MysqlSchemaIntrospector(this.querierPool);\n      case 'mariadb':\n        return new MariadbSchemaIntrospector(this.querierPool);\n      case 'sqlite':\n        return new SqliteSchemaIntrospector(this.querierPool);\n      case 'mongodb':\n        return new MongoSchemaIntrospector(this.querierPool);\n      default:\n        return undefined;\n    }\n  }\n\n  private createGenerator(namingStrategy?: NamingStrategy): SchemaGenerator | undefined {\n    switch (this.dialect) {\n      case 'postgres':\n        return new PostgresSchemaGenerator(namingStrategy);\n      case 'mysql':\n        return new MysqlSchemaGenerator(namingStrategy);\n      case 'mariadb':\n        return new MariadbSchemaGenerator(namingStrategy);\n      case 'sqlite':\n        return new SqliteSchemaGenerator(namingStrategy);\n      case 'mongodb':\n        return new MongoSchemaGenerator(namingStrategy);\n      default:\n        return undefined;\n    }\n  }\n\n  /**\n   * Get the SQL dialect\n   */\n  getDialect(): Dialect {\n    return this.dialect;\n  }\n\n  /**\n   * Get all discovered migrations from the migrations directory\n   */\n  async getMigrations(): Promise<Migration[]> {\n    const files = await this.getMigrationFiles();\n    const migrations: Migration[] = [];\n\n    for (const file of files) {\n      const migration = await this.loadMigration(file);\n      if (migration) {\n        migrations.push(migration);\n      }\n    }\n\n    // Sort by name (which typically includes timestamp)\n    return migrations.sort((a: any, b: any) => a.name.localeCompare(b.name));\n  }\n\n  /**\n   * Get list of pending migrations (not yet executed)\n   */\n  async pending(): Promise<Migration[]> {\n    const [migrations, executed] = await Promise.all([this.getMigrations(), this.storage.executed()]);\n\n    const executedSet = new Set(executed);\n    return migrations.filter((m: any) => !executedSet.has(m.name));\n  }\n\n  /**\n   * Get list of executed migrations\n   */\n  async executed(): Promise<string[]> {\n    return this.storage.executed();\n  }\n\n  /**\n   * Run all pending migrations\n   */\n  async up(options: { to?: string; step?: number } = {}): Promise<MigrationResult[]> {\n    const pendingMigrations = await this.pending();\n    const results: MigrationResult[] = [];\n\n    let migrationsToRun = pendingMigrations;\n\n    if (options.to) {\n      const toIndex = migrationsToRun.findIndex((m: any) => m.name === options.to);\n      if (toIndex === -1) {\n        throw new Error(`Migration '${options.to}' not found`);\n      }\n      migrationsToRun = migrationsToRun.slice(0, toIndex + 1);\n    }\n\n    if (options.step !== undefined) {\n      migrationsToRun = migrationsToRun.slice(0, options.step);\n    }\n\n    for (const migration of migrationsToRun) {\n      const result = await this.runMigration(migration, 'up');\n      results.push(result);\n\n      if (!result.success) {\n        break; // Stop on first failure\n      }\n    }\n\n    return results;\n  }\n\n  /**\n   * Rollback migrations\n   */\n  async down(options: { to?: string; step?: number } = {}): Promise<MigrationResult[]> {\n    const [migrations, executed] = await Promise.all([this.getMigrations(), this.storage.executed()]);\n\n    const executedSet = new Set(executed);\n    const executedMigrations = migrations.filter((m: any) => executedSet.has(m.name)).reverse(); // Rollback in reverse order\n\n    const results: MigrationResult[] = [];\n    let migrationsToRun = executedMigrations;\n\n    if (options.to) {\n      const toIndex = migrationsToRun.findIndex((m: any) => m.name === options.to);\n      if (toIndex === -1) {\n        throw new Error(`Migration '${options.to}' not found`);\n      }\n      migrationsToRun = migrationsToRun.slice(0, toIndex + 1);\n    }\n\n    if (options.step !== undefined) {\n      migrationsToRun = migrationsToRun.slice(0, options.step);\n    }\n\n    for (const migration of migrationsToRun) {\n      const result = await this.runMigration(migration, 'down');\n      results.push(result);\n\n      if (!result.success) {\n        break; // Stop on first failure\n      }\n    }\n\n    return results;\n  }\n\n  /**\n   * Run a single migration within a transaction\n   */\n  private async runMigration(migration: Migration, direction: 'up' | 'down'): Promise<MigrationResult> {\n    const startTime = Date.now();\n    const querier = await this.querierPool.getQuerier();\n\n    if (!isSqlQuerier(querier)) {\n      await querier.release();\n      throw new Error('Migrator requires a SQL-based querier');\n    }\n\n    try {\n      this.logger(`${direction === 'up' ? 'Running' : 'Reverting'} migration: ${migration.name}`);\n\n      await querier.beginTransaction();\n\n      if (direction === 'up') {\n        await migration.up(querier);\n        // Log within the same transaction\n        await this.storage.logWithQuerier(querier, migration.name);\n      } else {\n        await migration.down(querier);\n        // Unlog within the same transaction\n        await this.storage.unlogWithQuerier(querier, migration.name);\n      }\n\n      await querier.commitTransaction();\n\n      const duration = Date.now() - startTime;\n      this.logger(`Migration ${migration.name} ${direction === 'up' ? 'applied' : 'reverted'} in ${duration}ms`);\n\n      return {\n        name: migration.name,\n        direction,\n        duration,\n        success: true,\n      };\n    } catch (error) {\n      await querier.rollbackTransaction();\n\n      const duration = Date.now() - startTime;\n      this.logger(`Migration ${migration.name} failed: ${(error as Error).message}`);\n\n      return {\n        name: migration.name,\n        direction,\n        duration,\n        success: false,\n        error: error as Error,\n      };\n    } finally {\n      await querier.release();\n    }\n  }\n\n  /**\n   * Generate a new migration file\n   */\n  async generate(name: string): Promise<string> {\n    const timestamp = this.getTimestamp();\n    const fileName = `${timestamp}_${this.slugify(name)}.ts`;\n    const filePath = join(this.migrationsPath, fileName);\n\n    const content = this.generateMigrationContent(name);\n\n    const { writeFile, mkdir } = await import('node:fs/promises');\n    await mkdir(this.migrationsPath, { recursive: true });\n    await writeFile(filePath, content, 'utf-8');\n\n    this.logger(`Created migration: ${filePath}`);\n    return filePath;\n  }\n\n  /**\n   * Generate a migration based on entity schema differences\n   */\n  async generateFromEntities(name: string): Promise<string> {\n    if (!this.schemaGenerator) {\n      throw new Error('Schema generator not set. Call setSchemaGenerator() first.');\n    }\n\n    const diffs = await this.getDiffs();\n    const upStatements: string[] = [];\n    const downStatements: string[] = [];\n\n    for (const diff of diffs) {\n      if (diff.type === 'create') {\n        const entity = this.findEntityForTable(diff.tableName);\n        if (entity) {\n          upStatements.push(this.schemaGenerator.generateCreateTable(entity));\n          downStatements.push(this.schemaGenerator.generateDropTable(entity));\n        }\n      } else if (diff.type === 'alter') {\n        const alterStatements = this.schemaGenerator.generateAlterTable(diff);\n        upStatements.push(...alterStatements);\n\n        const alterDownStatements = this.schemaGenerator.generateAlterTableDown(diff);\n        downStatements.push(...alterDownStatements);\n      }\n    }\n\n    if (upStatements.length === 0) {\n      this.logger('No schema changes detected.');\n      return '';\n    }\n\n    const timestamp = this.getTimestamp();\n    const fileName = `${timestamp}_${this.slugify(name)}.ts`;\n    const filePath = join(this.migrationsPath, fileName);\n\n    const content = this.generateMigrationContentWithStatements(name, upStatements, downStatements.reverse());\n\n    const { writeFile, mkdir } = await import('node:fs/promises');\n    await mkdir(this.migrationsPath, { recursive: true });\n    await writeFile(filePath, content, 'utf-8');\n\n    this.logger(`Created migration from entities: ${filePath}`);\n    return filePath;\n  }\n\n  /**\n   * Get all schema differences between entities and database\n   */\n  async getDiffs(): Promise<SchemaDiff[]> {\n    if (!this.schemaGenerator || !this.schemaIntrospector) {\n      throw new Error('Schema generator and introspector must be set');\n    }\n\n    const entities = this.entities.length > 0 ? this.entities : getEntities();\n    const diffs: SchemaDiff[] = [];\n\n    for (const entity of entities) {\n      const meta = getMeta(entity);\n      const tableName = this.schemaGenerator.resolveTableName(entity, meta);\n      const currentSchema = await this.schemaIntrospector.getTableSchema(tableName);\n      const diff = this.schemaGenerator.diffSchema(entity, currentSchema);\n      if (diff) {\n        diffs.push(diff);\n      }\n    }\n\n    return diffs;\n  }\n\n  private findEntityForTable(tableName: string): Type<unknown> | undefined {\n    const entities = this.entities.length > 0 ? this.entities : getEntities();\n    for (const entity of entities) {\n      const meta = getMeta(entity);\n      const name = this.schemaGenerator.resolveTableName(entity, meta);\n      if (name === tableName) {\n        return entity;\n      }\n    }\n    return undefined;\n  }\n\n  /**\n   * Sync schema directly (for development only - not for production!)\n   */\n  async sync(options: { force?: boolean } = {}): Promise<void> {\n    if (options.force) {\n      return this.syncForce();\n    }\n    return this.autoSync({ safe: true });\n  }\n\n  /**\n   * Drops and recreates all tables (Development only!)\n   */\n  public async syncForce(): Promise<void> {\n    if (!this.schemaGenerator) {\n      throw new Error('Schema generator not set. Call setSchemaGenerator() first.');\n    }\n\n    const entities = this.entities.length > 0 ? this.entities : getEntities();\n    const querier = await this.querierPool.getQuerier();\n\n    if (!isSqlQuerier(querier)) {\n      await querier.release();\n      throw new Error('Migrator requires a SQL-based querier');\n    }\n\n    try {\n      await querier.beginTransaction();\n\n      // Drop all tables first (in reverse order for foreign keys)\n      for (const entity of [...entities].reverse()) {\n        const dropSql = this.schemaGenerator.generateDropTable(entity);\n        this.logger(`Executing: ${dropSql}`);\n        await querier.run(dropSql);\n      }\n\n      // Create all tables\n      for (const entity of entities) {\n        const createSql = this.schemaGenerator.generateCreateTable(entity);\n        this.logger(`Executing: ${createSql}`);\n        await querier.run(createSql);\n      }\n\n      await querier.commitTransaction();\n      this.logger('Schema sync (force) completed');\n    } catch (error) {\n      await querier.rollbackTransaction();\n      throw error;\n    } finally {\n      await querier.release();\n    }\n  }\n\n  /**\n   * Safely synchronizes the schema by only adding missing tables and columns.\n   */\n  async autoSync(options: { safe?: boolean; drop?: boolean; logging?: boolean } = {}): Promise<void> {\n    if (!this.schemaGenerator || !this.schemaIntrospector) {\n      throw new Error('Schema generator and introspector must be set');\n    }\n\n    const diffs = await this.getDiffs();\n    const statements: string[] = [];\n\n    for (const diff of diffs) {\n      if (diff.type === 'create') {\n        const entity = this.findEntityForTable(diff.tableName);\n        if (entity) {\n          statements.push(this.schemaGenerator.generateCreateTable(entity));\n        }\n      } else if (diff.type === 'alter') {\n        const filteredDiff = this.filterDiff(diff, options);\n        const alterStatements = this.schemaGenerator.generateAlterTable(filteredDiff);\n        statements.push(...alterStatements);\n      }\n    }\n\n    if (statements.length === 0) {\n      if (options.logging) this.logger('Schema is already in sync.');\n      return;\n    }\n\n    await this.executeSyncStatements(statements, options);\n  }\n\n  private filterDiff(diff: SchemaDiff, options: { safe?: boolean; drop?: boolean }): SchemaDiff {\n    const filteredDiff = { ...diff } as { -readonly [K in keyof SchemaDiff]: SchemaDiff[K] };\n    if (options.safe !== false) {\n      // In safe mode, we only allow additions\n      delete filteredDiff.columnsToDrop;\n      delete filteredDiff.indexesToDrop;\n      delete filteredDiff.foreignKeysToDrop;\n    }\n    if (!options.drop) {\n      delete filteredDiff.columnsToDrop;\n    }\n    return filteredDiff;\n  }\n\n  private async executeSyncStatements(statements: string[], options: { logging?: boolean }): Promise<void> {\n    const querier = await this.querierPool.getQuerier();\n    try {\n      if (this.dialect === 'mongodb') {\n        await this.executeMongoSyncStatements(statements, options, querier as MongoQuerier);\n      } else {\n        await this.executeSqlSyncStatements(statements, options, querier);\n      }\n      if (options.logging) this.logger('Schema synchronization completed');\n    } catch (error) {\n      if (this.dialect !== 'mongodb' && isSqlQuerier(querier)) {\n        await querier.rollbackTransaction();\n      }\n      throw error;\n    } finally {\n      await querier.release();\n    }\n  }\n\n  private async executeMongoSyncStatements(\n    statements: string[],\n    options: { logging?: boolean },\n    querier: MongoQuerier,\n  ): Promise<void> {\n    const db = querier.db;\n    for (const stmt of statements) {\n      const cmd = JSON.parse(stmt) as {\n        action: string;\n        name?: string;\n        collection?: string;\n        indexes?: { name: string; columns: string[]; unique?: boolean }[];\n        key?: Record<string, number>;\n        options?: any;\n      };\n      if (options.logging) this.logger(`Executing MongoDB: ${stmt}`);\n\n      const collectionName = cmd.name || cmd.collection;\n      if (!collectionName) {\n        throw new Error(`MongoDB command missing collection name: ${stmt}`);\n      }\n      const collection = db.collection(collectionName);\n\n      if (cmd.action === 'createCollection') {\n        await db.createCollection(cmd.name);\n        if (cmd.indexes?.length) {\n          for (const idx of cmd.indexes) {\n            const key = Object.fromEntries(idx.columns.map((c: string) => [c, 1]));\n            await collection.createIndex(key, { unique: idx.unique, name: idx.name });\n          }\n        }\n      } else if (cmd.action === 'dropCollection') {\n        await collection.drop();\n      } else if (cmd.action === 'createIndex') {\n        await collection.createIndex(cmd.key, cmd.options);\n      } else if (cmd.action === 'dropIndex') {\n        await collection.dropIndex(cmd.name);\n      }\n    }\n  }\n\n  private async executeSqlSyncStatements(\n    statements: string[],\n    options: { logging?: boolean },\n    querier: Querier,\n  ): Promise<void> {\n    if (!isSqlQuerier(querier)) {\n      throw new Error('Migrator requires a SQL-based querier for this dialect');\n    }\n    await querier.beginTransaction();\n    for (const sql of statements) {\n      if (options.logging) this.logger(`Executing: ${sql}`);\n      await querier.run(sql);\n    }\n    await querier.commitTransaction();\n  }\n\n  /**\n   * Get migration status\n   */\n  async status(): Promise<{ pending: string[]; executed: string[] }> {\n    const [pending, executed] = await Promise.all([this.pending().then((m) => m.map((x) => x.name)), this.executed()]);\n\n    return { pending, executed };\n  }\n\n  /**\n   * Get migration files from the migrations directory\n   */\n  private async getMigrationFiles(): Promise<string[]> {\n    try {\n      const files = await readdir(this.migrationsPath);\n      return files\n        .filter((f) => /\\.(ts|js|mjs)$/.test(f))\n        .filter((f) => !f.endsWith('.d.ts'))\n        .sort();\n    } catch (error) {\n      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {\n        return [];\n      }\n      throw error;\n    }\n  }\n\n  /**\n   * Load a migration from a file\n   */\n  private async loadMigration(fileName: string): Promise<Migration | undefined> {\n    const filePath = join(this.migrationsPath, fileName);\n    const fileUrl = pathToFileURL(filePath).href;\n\n    try {\n      const module = await import(fileUrl);\n      const migration = module.default ?? module;\n\n      if (this.isMigration(migration)) {\n        return {\n          name: this.getMigrationName(fileName),\n          up: migration.up.bind(migration),\n          down: migration.down.bind(migration),\n        };\n      }\n\n      this.logger(`Warning: ${fileName} is not a valid migration`);\n      return undefined;\n    } catch (error) {\n      this.logger(`Error loading migration ${fileName}: ${(error as Error).message}`);\n      return undefined;\n    }\n  }\n\n  /**\n   * Check if an object is a valid migration\n   */\n  private isMigration(obj: unknown): obj is MigrationDefinition {\n    return (\n      typeof obj === 'object' &&\n      obj !== undefined &&\n      obj !== null &&\n      typeof (obj as MigrationDefinition).up === 'function' &&\n      typeof (obj as MigrationDefinition).down === 'function'\n    );\n  }\n\n  /**\n   * Extract migration name from filename\n   */\n  private getMigrationName(fileName: string): string {\n    return basename(fileName, extname(fileName));\n  }\n\n  /**\n   * Generate timestamp string for migration names\n   */\n  private getTimestamp(): string {\n    const now = new Date();\n    return [\n      now.getFullYear(),\n      String(now.getMonth() + 1).padStart(2, '0'),\n      String(now.getDate()).padStart(2, '0'),\n      String(now.getHours()).padStart(2, '0'),\n      String(now.getMinutes()).padStart(2, '0'),\n      String(now.getSeconds()).padStart(2, '0'),\n    ].join('');\n  }\n\n  /**\n   * Convert a string to a slug for filenames\n   */\n  private slugify(text: string): string {\n    return text\n      .toLowerCase()\n      .replace(/[^a-z0-9]+/g, '_')\n      .replace(/^_+|_+$/g, '');\n  }\n\n  /**\n   * Generate migration file content\n   */\n  private generateMigrationContent(name: string): string {\n    return /*ts*/ `import type { SqlQuerier } from '@uql/migrate';\n\n/**\n * Migration: ${name}\n * Created: ${new Date().toISOString()}\n */\nexport default {\n  async up(querier: SqlQuerier): Promise<void> {\n    // Add your migration logic here\n    // Example:\n    // await querier.run(\\`\n    //   CREATE TABLE \"users\" (\n    //     \"id\" SERIAL PRIMARY KEY,\n    //     \"name\" VARCHAR(255) NOT NULL,\n    //     \"email\" VARCHAR(255) UNIQUE NOT NULL,\n    //     \"createdAt\" TIMESTAMP DEFAULT CURRENT_TIMESTAMP\n    //   )\n    // \\`);\n  },\n\n  async down(querier: SqlQuerier): Promise<void> {\n    // Add your rollback logic here\n    // Example:\n    // await querier.run(\\`DROP TABLE IF EXISTS \"users\"\\`);\n  },\n};\n`;\n  }\n\n  /**\n   * Generate migration file content with SQL statements\n   */\n  private generateMigrationContentWithStatements(\n    name: string,\n    upStatements: string[],\n    downStatements: string[],\n  ): string {\n    const upSql = upStatements.map((s) => /*ts*/ `    await querier.run(\\`${s}\\`);`).join('\\n');\n    const downSql = downStatements.map((s) => /*ts*/ `    await querier.run(\\`${s}\\`);`).join('\\n');\n\n    return /*ts*/ `import type { SqlQuerier } from '@uql/migrate';\n\n/**\n * Migration: ${name}\n * Created: ${new Date().toISOString()}\n * Generated from entity definitions\n */\nexport default {\n  async up(querier: SqlQuerier): Promise<void> {\n${upSql}\n  },\n\n  async down(querier: SqlQuerier): Promise<void> {\n${downSql}\n  },\n};\n`;\n  }\n}\n\n/**\n * Helper function to define a migration with proper typing\n */\nexport function defineMigration(migration: MigrationDefinition): MigrationDefinition {\n  return migration;\n}\n"]}