ts-prorm-orm 1.1.0

package/dist/migrations/migrator.js

@@ -0,0 +1,411 @@
+"use strict";
+/**
+ * Migrator class - Manages the migration workflow
+ * Handles registering, running, and reverting migrations
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Migrator = void 0;
+exports.createMigrator = createMigrator;
+exports.createMigration = createMigration;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const migration_1 = require("./migration");
+const prormmigration_1 = require("./prormmigration");
+/**
+ * Migrator class - Manages database migrations
+ */
+class Migrator {
+    /**
+     * Create a new Migrator instance
+     * @param options - Configuration options
+     */
+    constructor(options) {
+        this.migrations = new Map();
+        /**
+         * Default filter for migration files
+         */
+        this.defaultFilter = (filename) => {
+            const ext = path.extname(filename);
+            return ext === this.extension || ext === '.ts';
+        };
+        this.prorm = options.prorm;
+        this.path = options.path || './migrations';
+        this.extension = options.extension || '.js';
+        this.filter = options.filter || this.defaultFilter;
+        const migrationOptions = {
+            prorm: options.prorm,
+            tableName: options.tableName || 'PrormMeta',
+            schema: options.schema,
+        };
+        this.PrormMigration = new prormmigration_1.PrormMigration(migrationOptions);
+    }
+    /**
+     * Get the PrormMigration instance
+     */
+    getPrormMigration() {
+        return this.PrormMigration;
+    }
+    /**
+     * Get the QueryInterface
+     */
+    getQueryInterface() {
+        return this.PrormMigration.getQueryInterface();
+    }
+    /**
+     * Register a migration file
+     * @param migrationPath - Path to the migration file
+     */
+    async migration(migrationPath) {
+        const migration = await this.loadMigrationFile(migrationPath);
+        const name = path.basename(migrationPath, path.extname(migrationPath));
+        this.migrations.set(name, migration);
+    }
+    /**
+     * Ensure TypeScript migration files can be loaded via require().
+     * Lazily registers ts-node/register the first time a .ts migration is loaded.
+     */
+    ensureTsNodeRegistered(filePath) {
+        if (Migrator.tsNodeRegistered) {
+            return;
+        }
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            require('ts-node/register');
+            Migrator.tsNodeRegistered = true;
+        }
+        catch (error) {
+            throw new Error(`Cannot load TypeScript migration "${filePath}": ts-node is required to run ` +
+                `.ts migration files but could not be loaded. Install it with ` +
+                `"npm install --save-dev ts-node", or generate migrations with a .js extension ` +
+                `instead. Original error: ${error}`);
+        }
+    }
+    /**
+     * Load a migration file
+     * @param filePath - Path to the migration file
+     */
+    async loadMigrationFile(filePath) {
+        const name = path.basename(filePath, path.extname(filePath));
+        try {
+            const ext = path.extname(filePath);
+            const fullPath = path.resolve(filePath);
+            if (ext === '.ts') {
+                // Register ts-node so require() can transpile .ts migrations on the fly.
+                this.ensureTsNodeRegistered(filePath);
+            }
+            // Clear require cache to allow hot reloading
+            delete require.cache[require.resolve(fullPath)];
+            const migrationModule = require(fullPath);
+            const migration = new migration_1.Migration({ name });
+            // Support both CommonJS (module.exports = { up, down }) and
+            // ESM-interop (export const up/down) shapes, and default exports.
+            const up = migrationModule.up ?? migrationModule.default?.up;
+            const down = migrationModule.down ?? migrationModule.default?.down;
+            if (up && typeof up === 'function') {
+                migration.setUp(up);
+            }
+            if (down && typeof down === 'function') {
+                migration.setDown(down);
+            }
+            return migration;
+        }
+        catch (error) {
+            throw new Error(`Failed to load migration from ${filePath}: ${error}`);
+        }
+    }
+    /**
+     * Find and register all migration files in a directory
+     */
+    async findMigrations() {
+        if (!fs.existsSync(this.path)) {
+            console.log(`Migration directory not found: ${this.path}`);
+            return;
+        }
+        const files = fs.readdirSync(this.path);
+        for (const file of files) {
+            if (this.filter(file)) {
+                const filePath = path.join(this.path, file);
+                const stat = fs.statSync(filePath);
+                if (stat.isFile()) {
+                    await this.migration(filePath);
+                }
+            }
+        }
+    }
+    /**
+     * Get all registered migrations
+     */
+    getMigrations() {
+        return Array.from(this.migrations.values());
+    }
+    /**
+     * Get migration by name
+     */
+    getMigration(name) {
+        return this.migrations.get(name);
+    }
+    /**
+     * List pending (not yet executed) migrations
+     */
+    async pending() {
+        // Load all migrations if not already loaded. Without this, calling
+        // pending() before up()/down() (e.g. from the CLI's migration:run,
+        // which inspects pending() to decide whether there's anything to do)
+        // would see an empty `this.migrations` map and always report zero
+        // pending migrations, even when migration files exist on disk.
+        if (this.migrations.size === 0) {
+            await this.findMigrations();
+        }
+        const executed = await this.PrormMigration.getExecutedMigrations();
+        const executedNames = new Set(executed.map((m) => m.name));
+        const pending = [];
+        for (const [name, migration] of this.migrations) {
+            if (!executedNames.has(name)) {
+                pending.push(migration);
+            }
+        }
+        // Sort by name (which typically includes timestamp)
+        return pending.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    /**
+     * List all executed migrations
+     */
+    async executed() {
+        // See pending() above: the migrations map must be populated from disk
+        // before we can match it up against the executed-migrations table.
+        if (this.migrations.size === 0) {
+            await this.findMigrations();
+        }
+        const executed = await this.PrormMigration.getExecutedMigrations();
+        const executedNames = new Set(executed.map((m) => m.name));
+        const executedMigrations = [];
+        for (const [name, migration] of this.migrations) {
+            if (executedNames.has(name)) {
+                executedMigrations.push(migration);
+            }
+        }
+        return executedMigrations.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    /**
+     * Get migration status for all migrations
+     */
+    async status() {
+        // See pending() above: the migrations map must be populated from disk
+        // before status can be computed for each migration file.
+        if (this.migrations.size === 0) {
+            await this.findMigrations();
+        }
+        const executed = await this.PrormMigration.getExecutedMigrations();
+        const executedMap = new Map(executed.map((m) => [m.name, m]));
+        const allStatuses = [];
+        for (const [name, migration] of this.migrations) {
+            const meta = executedMap.get(name);
+            allStatuses.push({
+                name,
+                status: meta ? 'up' : 'pending',
+                batch: meta?.batch,
+                timestamp: meta?.timestamp,
+            });
+        }
+        return allStatuses.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    /**
+     * Run all pending migrations
+     * @param options - Migration options
+     */
+    async up(options) {
+        // Load all migrations if not already loaded
+        if (this.migrations.size === 0) {
+            await this.findMigrations();
+        }
+        const result = {
+            executed: 0,
+            reverted: 0,
+            migrations: [],
+        };
+        if (options?.migration) {
+            // Run specific migration
+            const migration = this.migrations.get(options.migration);
+            if (!migration) {
+                throw new Error(`Migration ${options.migration} not found`);
+            }
+            const isExecuted = await this.PrormMigration.isMigrationExecuted(migration.name);
+            if (!isExecuted) {
+                await this.PrormMigration.runMigration(migration);
+                result.executed = 1;
+                result.migrations.push(migration.name);
+            }
+        }
+        else {
+            // Run all pending migrations
+            const pendingMigrations = await this.pending();
+            for (const migration of pendingMigrations) {
+                await this.PrormMigration.runMigration(migration);
+                result.executed++;
+                result.migrations.push(migration.name);
+            }
+        }
+        return result;
+    }
+    /**
+     * Revert migrations
+     * @param options - Revert options
+     */
+    async down(options) {
+        // Load all migrations if not already loaded
+        if (this.migrations.size === 0) {
+            await this.findMigrations();
+        }
+        const result = {
+            executed: 0,
+            reverted: 0,
+            migrations: [],
+        };
+        const executedMigrations = await this.executed();
+        if (options?.migration) {
+            // Revert specific migration
+            const migration = this.migrations.get(options.migration);
+            if (!migration) {
+                throw new Error(`Migration ${options.migration} not found`);
+            }
+            const isExecuted = await this.PrormMigration.isMigrationExecuted(migration.name);
+            if (isExecuted) {
+                await this.PrormMigration.revertMigration(migration);
+                result.reverted = 1;
+                result.migrations.push(migration.name);
+            }
+        }
+        else if (options?.steps !== undefined && options.steps > 0) {
+            // Revert N migrations
+            const toRevert = executedMigrations
+                .sort((a, b) => b.name.localeCompare(a.name))
+                .slice(0, options.steps);
+            for (const migration of toRevert) {
+                await this.PrormMigration.revertMigration(migration);
+                result.reverted++;
+                result.migrations.push(migration.name);
+            }
+        }
+        else {
+            // Revert last migration
+            const lastMigration = executedMigrations[executedMigrations.length - 1];
+            if (lastMigration) {
+                await this.PrormMigration.revertMigration(lastMigration);
+                result.reverted = 1;
+                result.migrations.push(lastMigration.name);
+            }
+        }
+        return result;
+    }
+    /**
+     * Revert all executed migrations with a batch number greater than
+     * `targetBatch`, actually running each migration's `down()` function
+     * (loaded the same way `up()` is) before removing its tracking row.
+     * @param targetBatch - Batch number to revert down to
+     */
+    async downToBatch(targetBatch) {
+        // Load all migrations if not already loaded
+        if (this.migrations.size === 0) {
+            await this.findMigrations();
+        }
+        const before = await this.PrormMigration.getExecutedMigrations();
+        await this.PrormMigration.revertToBatch(targetBatch, this.migrations);
+        const after = await this.PrormMigration.getExecutedMigrations();
+        const afterNames = new Set(after.map((m) => m.name));
+        const revertedNames = before.filter((m) => !afterNames.has(m.name)).map((m) => m.name);
+        return {
+            executed: 0,
+            reverted: revertedNames.length,
+            migrations: revertedNames,
+        };
+    }
+    /**
+     * Get database version
+     */
+    async getDatabaseVersion() {
+        return this.PrormMigration.getDatabaseVersion();
+    }
+    /**
+     * Sync the migrations table
+     */
+    async syncMigrationsTable() {
+        await this.PrormMigration.syncMigrationsTable();
+    }
+    /**
+     * Set the migration path
+     */
+    setPath(newPath) {
+        this.path = newPath;
+        this.migrations.clear();
+    }
+    /**
+     * Get the current migration path
+     */
+    getPath() {
+        return this.path;
+    }
+}
+exports.Migrator = Migrator;
+/**
+ * Whether ts-node/register has already been registered in this process.
+ * Registering more than once is harmless but wasteful, so we only do it once.
+ */
+Migrator.tsNodeRegistered = false;
+/**
+ * Create a Migrator instance
+ */
+function createMigrator(options) {
+    return new Migrator(options);
+}
+/**
+ * Create migration file template
+ * @param name - Migration name
+ * @param options - Template options
+ */
+function createMigration(name, options) {
+    const timestamp = migration_1.Migration.getTimestamp();
+    const filename = `${timestamp}-${name}${options?.extension || '.js'}`;
+    const filepath = path.join(options?.path || './migrations', filename);
+    // Ensure directory exists
+    const dir = path.dirname(filepath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const template = (0, migration_1.buildMigrationTemplate)(name);
+    fs.writeFileSync(filepath, template);
+    console.log(`Migration created: ${filepath}`);
+    return filepath;
+}

package/dist/migrations/prormmigration.js

@@ -0,0 +1,275 @@
+"use strict";
+/**
+ * PrormMigration class - Integration layer between migrations and Prorm
+ * Handles running migrations with the Prorm instance
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrormMigration = void 0;
+const query_interface_1 = require("./query-interface");
+/**
+ * PrormMigration - Integrates with Prorm to manage migrations
+ */
+class PrormMigration {
+    /**
+     * Create a new PrormMigration instance
+     * @param options - Configuration options
+     */
+    constructor(options) {
+        this.migrationMeta = new Map();
+        this.prorm = options.prorm;
+        this.tableName = options.tableName || 'PrormMeta';
+        this.schema = options.schema;
+        this.queryInterface = this.createQueryInterface();
+    }
+    /**
+     * Create a QueryInterface from the Prorm instance
+     */
+    createQueryInterface() {
+        const dialect = this.prorm.getDialectInstance();
+        if (!dialect) {
+            throw new Error('Prorm is not connected. Please call prorm.connect() first.');
+        }
+        return new query_interface_1.QueryInterface(dialect);
+    }
+    /**
+     * Get the QueryInterface
+     */
+    getQueryInterface() {
+        return this.queryInterface;
+    }
+    /**
+     * Get the Prorm instance
+     */
+    getProrm() {
+        return this.prorm;
+    }
+    /**
+     * Get the migrations table name
+     */
+    getTableName() {
+        return this.tableName;
+    }
+    /**
+     * Ensure the migrations table exists
+     */
+    async ensureMigrationsTable() {
+        const tableExists = await this.queryInterface.tableExists(this.tableName);
+        if (!tableExists) {
+            await this.queryInterface.createTable(this.tableName, {
+                name: {
+                    type: 'STRING',
+                    allowNull: false,
+                    unique: true,
+                },
+                batch: {
+                    type: 'INTEGER',
+                    allowNull: false,
+                    defaultValue: 0,
+                },
+                timestamp: {
+                    type: 'INTEGER',
+                    allowNull: false,
+                    defaultValue: Math.floor(Date.now() / 1000),
+                },
+            });
+        }
+    }
+    /**
+     * Load migration metadata from the database
+     */
+    async loadMigrationMeta() {
+        await this.ensureMigrationsTable();
+        const result = await this.queryInterface.prormQuery(`SELECT * FROM ${this.queryInterface.getDialect().escapeId(this.tableName)} ORDER BY timestamp ASC`);
+        this.migrationMeta.clear();
+        for (const row of result.rows) {
+            const meta = {
+                id: row.id,
+                name: row.name,
+                batch: row.batch,
+                timestamp: row.timestamp,
+            };
+            this.migrationMeta.set(row.name, meta);
+        }
+    }
+    /**
+     * Record a migration as executed in the database
+     * @param migration - The migration to record
+     * @param batch - The batch number
+     */
+    async recordMigration(migration, batch) {
+        const dialect = this.queryInterface.getDialect();
+        const timestamp = Math.floor(Date.now() / 1000);
+        await this.queryInterface.prormQuery(`INSERT INTO ${dialect.escapeId(this.tableName)} (name, batch, timestamp) VALUES (${dialect.escape(migration.name)}, ${dialect.escape(batch)}, ${dialect.escape(timestamp)})`);
+        // Update local cache
+        const meta = {
+            name: migration.name,
+            batch,
+            timestamp,
+        };
+        this.migrationMeta.set(migration.name, meta);
+    }
+    /**
+     * Remove a migration record from the database
+     * @param migrationName - Name of the migration to remove
+     */
+    async removeMigration(migrationName) {
+        const dialect = this.queryInterface.getDialect();
+        await this.queryInterface.prormQuery(`DELETE FROM ${dialect.escapeId(this.tableName)} WHERE name = ${dialect.escape(migrationName)}`);
+        this.migrationMeta.delete(migrationName);
+    }
+    /**
+     * Get all executed migrations
+     */
+    async getExecutedMigrations() {
+        await this.loadMigrationMeta();
+        return Array.from(this.migrationMeta.values());
+    }
+    /**
+     * Check if a migration has been executed
+     * @param migrationName - Name of the migration
+     */
+    async isMigrationExecuted(migrationName) {
+        await this.loadMigrationMeta();
+        return this.migrationMeta.has(migrationName);
+    }
+    /**
+     * Compute the next batch number from the currently loaded migration meta.
+     * Callers are expected to have called `loadMigrationMeta()` beforehand.
+     */
+    computeNextBatch() {
+        const migrations = Array.from(this.migrationMeta.values());
+        const maxBatch = migrations.reduce((max, m) => Math.max(max, m.batch), 0);
+        return maxBatch + 1;
+    }
+    /**
+     * Run a migration
+     * @param migration - The migration to run
+     * @param batch - Optional batch number to record this migration under. When
+     *   omitted, a fresh batch number is computed for this single migration.
+     *   `runMigrations()` passes an explicit shared batch so that all migrations
+     *   applied in one run land in the same batch.
+     */
+    async runMigration(migration, batch) {
+        // Load fresh meta before running
+        await this.loadMigrationMeta();
+        if (this.migrationMeta.has(migration.name)) {
+            console.log(`Migration ${migration.name} already executed`);
+            return;
+        }
+        // Use the caller-provided batch (shared across a run) or compute one.
+        const newBatch = batch ?? this.computeNextBatch();
+        try {
+            console.log(`Running migration: ${migration.name}`);
+            await migration.up(this.queryInterface, this.prorm);
+            await this.recordMigration(migration, newBatch);
+            console.log(`Migration ${migration.name} completed`);
+        }
+        catch (error) {
+            console.error(`Migration ${migration.name} failed:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Revert a migration
+     * @param migration - The migration to revert
+     */
+    async revertMigration(migration) {
+        // Load fresh meta before reverting
+        await this.loadMigrationMeta();
+        if (!this.migrationMeta.has(migration.name)) {
+            console.log(`Migration ${migration.name} not executed`);
+            return;
+        }
+        if (!migration.down) {
+            console.warn(`Migration ${migration.name} has no down() function defined; removing its tracking ` +
+                `record without reverting any changes.`);
+            await this.removeMigration(migration.name);
+            return;
+        }
+        try {
+            console.log(`Reverting migration: ${migration.name}`);
+            await migration.down(this.queryInterface, this.prorm);
+            await this.removeMigration(migration.name);
+            console.log(`Migration ${migration.name} reverted`);
+        }
+        catch (error) {
+            console.error(`Failed to revert migration ${migration.name}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Execute all pending migrations
+     * @param migrations - Array of migrations to run
+     */
+    async runMigrations(migrations) {
+        // All migrations applied in a single run share one batch number so they
+        // can be reverted together as a unit. Compute it once up front rather than
+        // recomputing (maxBatch + 1) per migration, which would put each migration
+        // in its own batch.
+        await this.loadMigrationMeta();
+        const batch = this.computeNextBatch();
+        for (const migration of migrations) {
+            await this.runMigration(migration, batch);
+        }
+    }
+    /**
+     * Revert migrations to a specific batch
+     *
+     * For each executed migration with a batch number greater than
+     * `targetBatch`, this loads its `down()` function (via the supplied
+     * `migrations` lookup) and actually executes it before removing its
+     * tracking row. If `down()` throws, the error is logged and re-thrown, and
+     * the tracking row for that migration (and any migrations after it) is
+     * left in place so the revert can be retried.
+     *
+     * @param targetBatch - Target batch number to revert down to
+     * @param migrations - The loaded Migration definitions (with `down()`
+     *   functions attached), keyed by migration name. Typically
+     *   `Migrator.getMigrations()` / the Migrator's internal migrations map.
+     */
+    async revertToBatch(targetBatch, migrations) {
+        const migrationMap = migrations instanceof Map ? migrations : new Map(migrations.map((m) => [m.name, m]));
+        await this.loadMigrationMeta();
+        const migrationsToRevert = Array.from(this.migrationMeta.values())
+            .filter((m) => m.batch > targetBatch)
+            .sort((a, b) => b.batch - a.batch || b.timestamp - a.timestamp);
+        for (const meta of migrationsToRevert) {
+            const migration = migrationMap.get(meta.name);
+            if (!migration) {
+                throw new Error(`Cannot revert migration "${meta.name}" to batch ${targetBatch}: no loaded ` +
+                    `migration definition was found for it, so its down() function is unavailable. ` +
+                    `Ensure the migration file still exists and has been registered (e.g. via ` +
+                    `Migrator.findMigrations()) before calling revertToBatch().`);
+            }
+            if (!migration.down) {
+                console.warn(`Migration ${meta.name} has no down() function defined; removing its tracking ` +
+                    `record without reverting any changes.`);
+                await this.removeMigration(meta.name);
+                continue;
+            }
+            try {
+                console.log(`Reverting migration: ${meta.name}`);
+                await migration.down(this.queryInterface, this.prorm);
+                await this.removeMigration(meta.name);
+                console.log(`Migration ${meta.name} reverted`);
+            }
+            catch (error) {
+                console.error(`Failed to revert migration ${meta.name} while reverting to batch ${targetBatch}:`, error);
+                throw error;
+            }
+        }
+    }
+    /**
+     * Get the current database version
+     */
+    async getDatabaseVersion() {
+        return this.queryInterface.getDatabaseVersion();
+    }
+    /**
+     * Sync the migrations table
+     */
+    async syncMigrationsTable() {
+        await this.ensureMigrationsTable();
+    }
+}
+exports.PrormMigration = PrormMigration;