@studiosonrai/nestjs-migrations 1.0.0

package/dist/bin/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/cli.js

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeorm_1 = require("typeorm");
+const path = require("path");
+const migration_core_1 = require("../src/migration-core");
+function printUsage() {
+    console.log(`
+@studiosonrai/nestjs-migrations CLI
+
+Usage:
+  nestjs-migrations run [options]
+  nestjs-migrations status [options]
+
+Commands:
+  run       Run all pending migrations
+  status    Show migration status
+
+Options:
+  --migrations-dir, -d    Path to migrations directory (required)
+  --host, -h              Database host (default: localhost)
+  --port, -p              Database port (default: 1433)
+  --database, -D          Database name (required)
+  --username, -u          Database username
+  --password, -P          Database password
+  --encrypt               Enable encryption (default: false)
+  --trust-cert            Trust server certificate (default: false)
+  --dry-run               Show pending migrations without applying
+  --verbose, -v           Verbose output (default: true)
+  --help                  Show this help message
+
+Environment variables:
+  DB_HOST                 Database host
+  DB_PORT                 Database port
+  DB_DATABASE             Database name
+  DB_USERNAME             Database username
+  DB_PASSWORD             Database password
+  DB_ENCRYPT              Enable encryption
+  MIGRATIONS_DIR          Path to migrations directory
+
+Examples:
+  nestjs-migrations run -d ./migrations -D mydb -u sa -P password
+  nestjs-migrations status --migrations-dir ./migrations --database mydb
+  nestjs-migrations run --dry-run -d ./migrations -D mydb
+`);
+}
+function parseArgs(args) {
+    const options = {
+        verbose: true,
+    };
+    let command = '';
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        const nextArg = args[i + 1];
+        switch (arg) {
+            case 'run':
+            case 'status':
+                command = arg;
+                break;
+            case '--migrations-dir':
+            case '-d':
+                options.migrationsDir = nextArg;
+                i++;
+                break;
+            case '--host':
+            case '-h':
+                options.host = nextArg;
+                i++;
+                break;
+            case '--port':
+            case '-p':
+                options.port = parseInt(nextArg, 10);
+                i++;
+                break;
+            case '--database':
+            case '-D':
+                options.database = nextArg;
+                i++;
+                break;
+            case '--username':
+            case '-u':
+                options.username = nextArg;
+                i++;
+                break;
+            case '--password':
+            case '-P':
+                options.password = nextArg;
+                i++;
+                break;
+            case '--encrypt':
+                options.encrypt = true;
+                break;
+            case '--trust-cert':
+                options.trustServerCertificate = true;
+                break;
+            case '--dry-run':
+                options.dryRun = true;
+                break;
+            case '--verbose':
+            case '-v':
+                options.verbose = true;
+                break;
+            case '--help':
+                printUsage();
+                process.exit(0);
+        }
+    }
+    return { command, options };
+}
+function resolveOptions(cliOptions) {
+    // Load environment variables
+    const dotenv = require('dotenv');
+    dotenv.config();
+    const options = {
+        migrationsDir: cliOptions.migrationsDir || process.env.MIGRATIONS_DIR || '',
+        host: cliOptions.host || process.env.DB_HOST || 'localhost',
+        port: cliOptions.port || parseInt(process.env.DB_PORT || '1433', 10),
+        database: cliOptions.database || process.env.DB_DATABASE || '',
+        username: cliOptions.username || process.env.DB_USERNAME,
+        password: cliOptions.password || process.env.DB_PASSWORD,
+        encrypt: cliOptions.encrypt || process.env.DB_ENCRYPT === 'true',
+        trustServerCertificate: cliOptions.trustServerCertificate || false,
+        dryRun: cliOptions.dryRun || false,
+        verbose: cliOptions.verbose ?? true,
+    };
+    // Resolve relative paths
+    if (options.migrationsDir && !path.isAbsolute(options.migrationsDir)) {
+        options.migrationsDir = path.resolve(process.cwd(), options.migrationsDir);
+    }
+    return options;
+}
+function validateOptions(options) {
+    if (!options.migrationsDir) {
+        console.error('Error: --migrations-dir is required');
+        process.exit(1);
+    }
+    if (!options.database) {
+        console.error('Error: --database is required');
+        process.exit(1);
+    }
+}
+async function createDataSource(options) {
+    const dataSource = new typeorm_1.DataSource({
+        type: 'mssql',
+        host: options.host,
+        port: options.port,
+        database: options.database,
+        username: options.username,
+        password: options.password,
+        options: {
+            encrypt: options.encrypt || false,
+            trustServerCertificate: options.trustServerCertificate || false,
+        },
+    });
+    await dataSource.initialize();
+    return dataSource;
+}
+async function runCommand(options) {
+    console.log('Starting migration runner...');
+    console.log(`Migrations directory: ${options.migrationsDir}`);
+    console.log(`Database: ${options.database}`);
+    console.log(`Host: ${options.host}:${options.port}`);
+    console.log('');
+    const dataSource = await createDataSource(options);
+    console.log('Database connection established');
+    try {
+        const migrationCore = new migration_core_1.MigrationCore(dataSource, {
+            migrationsDir: options.migrationsDir,
+        });
+        const result = await migrationCore.runMigrations({
+            dryRun: options.dryRun,
+            verbose: options.verbose,
+        });
+        if (result.success) {
+            console.log('');
+            console.log('Migration completed successfully!');
+        }
+    }
+    finally {
+        await dataSource.destroy();
+        console.log('Database connection closed');
+    }
+}
+async function statusCommand(options) {
+    console.log('Checking migration status...');
+    console.log(`Migrations directory: ${options.migrationsDir}`);
+    console.log(`Database: ${options.database}`);
+    console.log('');
+    const dataSource = await createDataSource(options);
+    try {
+        const migrationCore = new migration_core_1.MigrationCore(dataSource, {
+            migrationsDir: options.migrationsDir,
+        });
+        const status = await migrationCore.getStatus();
+        console.log(`Total migrations: ${status.total}`);
+        console.log(`Applied: ${status.applied}`);
+        console.log(`Pending: ${status.pending}`);
+        if (status.pendingFiles.length > 0) {
+            console.log('');
+            console.log('Pending migrations:');
+            status.pendingFiles.forEach((file) => console.log(`  - ${file}`));
+        }
+    }
+    finally {
+        await dataSource.destroy();
+    }
+}
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.length === 0 || args.includes('--help')) {
+        printUsage();
+        process.exit(0);
+    }
+    const { command, options: cliOptions } = parseArgs(args);
+    const options = resolveOptions(cliOptions);
+    if (!command) {
+        console.error('Error: No command specified. Use "run" or "status".');
+        printUsage();
+        process.exit(1);
+    }
+    validateOptions(options);
+    try {
+        switch (command) {
+            case 'run':
+                await runCommand(options);
+                break;
+            case 'status':
+                await statusCommand(options);
+                break;
+            default:
+                console.error(`Unknown command: ${command}`);
+                printUsage();
+                process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error('Migration failed:', error);
+        process.exit(1);
+    }
+}
+main();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../bin/cli.ts"],"names":[],"mappings":";;;AAEA,qCAAqC;AACrC,6BAA6B;AAC7B,0DAAsD;AAetD,SAAS,UAAU;IACjB,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCb,CAAC,CAAC;AACH,CAAC;AAED,SAAS,SAAS,CAAC,IAAc;IAC/B,MAAM,OAAO,GAAwB;QACnC,OAAO,EAAE,IAAI;KACd,CAAC;IACF,IAAI,OAAO,GAAG,EAAE,CAAC;IAEjB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QACpB,MAAM,OAAO,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAE5B,QAAQ,GAAG,EAAE,CAAC;YACZ,KAAK,KAAK,CAAC;YACX,KAAK,QAAQ;gBACX,OAAO,GAAG,GAAG,CAAC;gBACd,MAAM;YACR,KAAK,kBAAkB,CAAC;YACxB,KAAK,IAAI;gBACP,OAAO,CAAC,aAAa,GAAG,OAAO,CAAC;gBAChC,CAAC,EAAE,CAAC;gBACJ,MAAM;YACR,KAAK,QAAQ,CAAC;YACd,KAAK,IAAI;gBACP,OAAO,CAAC,IAAI,GAAG,OAAO,CAAC;gBACvB,CAAC,EAAE,CAAC;gBACJ,MAAM;YACR,KAAK,QAAQ,CAAC;YACd,KAAK,IAAI;gBACP,OAAO,CAAC,IAAI,GAAG,QAAQ,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;gBACrC,CAAC,EAAE,CAAC;gBACJ,MAAM;YACR,KAAK,YAAY,CAAC;YAClB,KAAK,IAAI;gBACP,OAAO,CAAC,QAAQ,GAAG,OAAO,CAAC;gBAC3B,CAAC,EAAE,CAAC;gBACJ,MAAM;YACR,KAAK,YAAY,CAAC;YAClB,KAAK,IAAI;gBACP,OAAO,CAAC,QAAQ,GAAG,OAAO,CAAC;gBAC3B,CAAC,EAAE,CAAC;gBACJ,MAAM;YACR,KAAK,YAAY,CAAC;YAClB,KAAK,IAAI;gBACP,OAAO,CAAC,QAAQ,GAAG,OAAO,CAAC;gBAC3B,CAAC,EAAE,CAAC;gBACJ,MAAM;YACR,KAAK,WAAW;gBACd,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;gBACvB,MAAM;YACR,KAAK,cAAc;gBACjB,OAAO,CAAC,sBAAsB,GAAG,IAAI,CAAC;gBACtC,MAAM;YACR,KAAK,WAAW;gBACd,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;gBACtB,MAAM;YACR,KAAK,WAAW,CAAC;YACjB,KAAK,IAAI;gBACP,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;gBACvB,MAAM;YACR,KAAK,QAAQ;gBACX,UAAU,EAAE,CAAC;gBACb,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACpB,CAAC;IACH,CAAC;IAED,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC;AAC9B,CAAC;AAED,SAAS,cAAc,CAAC,UAA+B;IACrD,6BAA6B;IAC7B,MAAM,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IACjC,MAAM,CAAC,MAAM,EAAE,CAAC;IAEhB,MAAM,OAAO,GAAe;QAC1B,aAAa,EAAE,UAAU,CAAC,aAAa,IAAI,OAAO,CAAC,GAAG,CAAC,cAAc,IAAI,EAAE;QAC3E,IAAI,EAAE,UAAU,CAAC,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC,OAAO,IAAI,WAAW;QAC3D,IAAI,EAAE,UAAU,CAAC,IAAI,IAAI,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,IAAI,MAAM,EAAE,EAAE,CAAC;QACpE,QAAQ,EAAE,UAAU,CAAC,QAAQ,IAAI,OAAO,CAAC,GAAG,CAAC,WAAW,IAAI,EAAE;QAC9D,QAAQ,EAAE,UAAU,CAAC,QAAQ,IAAI,OAAO,CAAC,GAAG,CAAC,WAAW;QACxD,QAAQ,EAAE,UAAU,CAAC,QAAQ,IAAI,OAAO,CAAC,GAAG,CAAC,WAAW;QACxD,OAAO,EAAE,UAAU,CAAC,OAAO,IAAI,OAAO,CAAC,GAAG,CAAC,UAAU,KAAK,MAAM;QAChE,sBAAsB,EAAE,UAAU,CAAC,sBAAsB,IAAI,KAAK;QAClE,MAAM,EAAE,UAAU,CAAC,MAAM,IAAI,KAAK;QAClC,OAAO,EAAE,UAAU,CAAC,OAAO,IAAI,IAAI;KACpC,CAAC;IAEF,yBAAyB;IACzB,IAAI,OAAO,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE,CAAC;QACrE,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;IAC7E,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,SAAS,eAAe,CAAC,OAAmB;IAC1C,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;QAC3B,OAAO,CAAC,KAAK,CAAC,qCAAqC,CAAC,CAAC;QACrD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IAED,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;QACtB,OAAO,CAAC,KAAK,CAAC,+BAA+B,CAAC,CAAC;QAC/C,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;AACH,CAAC;AAED,KAAK,UAAU,gBAAgB,CAAC,OAAmB;IACjD,MAAM,UAAU,GAAG,IAAI,oBAAU,CAAC;QAChC,IAAI,EAAE,OAAO;QACb,IAAI,EAAE,OAAO,CAAC,IAAI;QAClB,IAAI,EAAE,OAAO,CAAC,IAAI;QAClB,QAAQ,EAAE,OAAO,CAAC,QAAQ;QAC1B,QAAQ,EAAE,OAAO,CAAC,QAAQ;QAC1B,QAAQ,EAAE,OAAO,CAAC,QAAQ;QAC1B,OAAO,EAAE;YACP,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,KAAK;YACjC,sBAAsB,EAAE,OAAO,CAAC,sBAAsB,IAAI,KAAK;SAChE;KACF,CAAC,CAAC;IAEH,MAAM,UAAU,CAAC,UAAU,EAAE,CAAC;IAC9B,OAAO,UAAU,CAAC;AACpB,CAAC;AAED,KAAK,UAAU,UAAU,CAAC,OAAmB;IAC3C,OAAO,CAAC,GAAG,CAAC,8BAA8B,CAAC,CAAC;IAC5C,OAAO,CAAC,GAAG,CAAC,yBAAyB,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC;IAC9D,OAAO,CAAC,GAAG,CAAC,aAAa,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC7C,OAAO,CAAC,GAAG,CAAC,SAAS,OAAO,CAAC,IAAI,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;IACrD,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAEhB,MAAM,UAAU,GAAG,MAAM,gBAAgB,CAAC,OAAO,CAAC,CAAC;IACnD,OAAO,CAAC,GAAG,CAAC,iCAAiC,CAAC,CAAC;IAE/C,IAAI,CAAC;QACH,MAAM,aAAa,GAAG,IAAI,8BAAa,CAAC,UAAU,EAAE;YAClD,aAAa,EAAE,OAAO,CAAC,aAAa;SACrC,CAAC,CAAC;QAEH,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,aAAa,CAAC;YAC/C,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,OAAO,EAAE,OAAO,CAAC,OAAO;SACzB,CAAC,CAAC;QAEH,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;YACnB,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAChB,OAAO,CAAC,GAAG,CAAC,mCAAmC,CAAC,CAAC;QACnD,CAAC;IACH,CAAC;YAAS,CAAC;QACT,MAAM,UAAU,CAAC,OAAO,EAAE,CAAC;QAC3B,OAAO,CAAC,GAAG,CAAC,4BAA4B,CAAC,CAAC;IAC5C,CAAC;AACH,CAAC;AAED,KAAK,UAAU,aAAa,CAAC,OAAmB;IAC9C,OAAO,CAAC,GAAG,CAAC,8BAA8B,CAAC,CAAC;IAC5C,OAAO,CAAC,GAAG,CAAC,yBAAyB,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC;IAC9D,OAAO,CAAC,GAAG,CAAC,aAAa,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC7C,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAEhB,MAAM,UAAU,GAAG,MAAM,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAEnD,IAAI,CAAC;QACH,MAAM,aAAa,GAAG,IAAI,8BAAa,CAAC,UAAU,EAAE;YAClD,aAAa,EAAE,OAAO,CAAC,aAAa;SACrC,CAAC,CAAC;QAEH,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,SAAS,EAAE,CAAC;QAE/C,OAAO,CAAC,GAAG,CAAC,qBAAqB,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;QACjD,OAAO,CAAC,GAAG,CAAC,YAAY,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC;QAC1C,OAAO,CAAC,GAAG,CAAC,YAAY,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC;QAE1C,IAAI,MAAM,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACnC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAChB,OAAO,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC;YACnC,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,CAAC;QACpE,CAAC;IACH,CAAC;YAAS,CAAC;QACT,MAAM,UAAU,CAAC,OAAO,EAAE,CAAC;IAC7B,CAAC;AACH,CAAC;AAED,KAAK,UAAU,IAAI;IACjB,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAEnC,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;QACjD,UAAU,EAAE,CAAC;QACb,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IAED,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;IACzD,MAAM,OAAO,GAAG,cAAc,CAAC,UAAU,CAAC,CAAC;IAE3C,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,CAAC,KAAK,CAAC,qDAAqD,CAAC,CAAC;QACrE,UAAU,EAAE,CAAC;QACb,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IAED,eAAe,CAAC,OAAO,CAAC,CAAC;IAEzB,IAAI,CAAC;QACH,QAAQ,OAAO,EAAE,CAAC;YAChB,KAAK,KAAK;gBACR,MAAM,UAAU,CAAC,OAAO,CAAC,CAAC;gBAC1B,MAAM;YACR,KAAK,QAAQ;gBACX,MAAM,aAAa,CAAC,OAAO,CAAC,CAAC;gBAC7B,MAAM;YACR;gBACE,OAAO,CAAC,KAAK,CAAC,oBAAoB,OAAO,EAAE,CAAC,CAAC;gBAC7C,UAAU,EAAE,CAAC;gBACb,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACpB,CAAC;IACH,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,CAAC,KAAK,CAAC,mBAAmB,EAAE,KAAK,CAAC,CAAC;QAC1C,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;AACH,CAAC;AAED,IAAI,EAAE,CAAC","sourcesContent":["#!/usr/bin/env node\n\nimport { DataSource } from 'typeorm';\nimport * as path from 'path';\nimport { MigrationCore } from '../src/migration-core';\n\ninterface CliOptions {\n  migrationsDir: string;\n  host: string;\n  port: number;\n  database: string;\n  username?: string;\n  password?: string;\n  encrypt?: boolean;\n  trustServerCertificate?: boolean;\n  dryRun?: boolean;\n  verbose?: boolean;\n}\n\nfunction printUsage(): void {\n  console.log(`\n@studiosonrai/nestjs-migrations CLI\n\nUsage:\n  nestjs-migrations run [options]\n  nestjs-migrations status [options]\n\nCommands:\n  run       Run all pending migrations\n  status    Show migration status\n\nOptions:\n  --migrations-dir, -d    Path to migrations directory (required)\n  --host, -h              Database host (default: localhost)\n  --port, -p              Database port (default: 1433)\n  --database, -D          Database name (required)\n  --username, -u          Database username\n  --password, -P          Database password\n  --encrypt               Enable encryption (default: false)\n  --trust-cert            Trust server certificate (default: false)\n  --dry-run               Show pending migrations without applying\n  --verbose, -v           Verbose output (default: true)\n  --help                  Show this help message\n\nEnvironment variables:\n  DB_HOST                 Database host\n  DB_PORT                 Database port\n  DB_DATABASE             Database name\n  DB_USERNAME             Database username\n  DB_PASSWORD             Database password\n  DB_ENCRYPT              Enable encryption\n  MIGRATIONS_DIR          Path to migrations directory\n\nExamples:\n  nestjs-migrations run -d ./migrations -D mydb -u sa -P password\n  nestjs-migrations status --migrations-dir ./migrations --database mydb\n  nestjs-migrations run --dry-run -d ./migrations -D mydb\n`);\n}\n\nfunction parseArgs(args: string[]): { command: string; options: Partial<CliOptions> } {\n  const options: Partial<CliOptions> = {\n    verbose: true,\n  };\n  let command = '';\n\n  for (let i = 0; i < args.length; i++) {\n    const arg = args[i];\n    const nextArg = args[i + 1];\n\n    switch (arg) {\n      case 'run':\n      case 'status':\n        command = arg;\n        break;\n      case '--migrations-dir':\n      case '-d':\n        options.migrationsDir = nextArg;\n        i++;\n        break;\n      case '--host':\n      case '-h':\n        options.host = nextArg;\n        i++;\n        break;\n      case '--port':\n      case '-p':\n        options.port = parseInt(nextArg, 10);\n        i++;\n        break;\n      case '--database':\n      case '-D':\n        options.database = nextArg;\n        i++;\n        break;\n      case '--username':\n      case '-u':\n        options.username = nextArg;\n        i++;\n        break;\n      case '--password':\n      case '-P':\n        options.password = nextArg;\n        i++;\n        break;\n      case '--encrypt':\n        options.encrypt = true;\n        break;\n      case '--trust-cert':\n        options.trustServerCertificate = true;\n        break;\n      case '--dry-run':\n        options.dryRun = true;\n        break;\n      case '--verbose':\n      case '-v':\n        options.verbose = true;\n        break;\n      case '--help':\n        printUsage();\n        process.exit(0);\n    }\n  }\n\n  return { command, options };\n}\n\nfunction resolveOptions(cliOptions: Partial<CliOptions>): CliOptions {\n  // Load environment variables\n  const dotenv = require('dotenv');\n  dotenv.config();\n\n  const options: CliOptions = {\n    migrationsDir: cliOptions.migrationsDir || process.env.MIGRATIONS_DIR || '',\n    host: cliOptions.host || process.env.DB_HOST || 'localhost',\n    port: cliOptions.port || parseInt(process.env.DB_PORT || '1433', 10),\n    database: cliOptions.database || process.env.DB_DATABASE || '',\n    username: cliOptions.username || process.env.DB_USERNAME,\n    password: cliOptions.password || process.env.DB_PASSWORD,\n    encrypt: cliOptions.encrypt || process.env.DB_ENCRYPT === 'true',\n    trustServerCertificate: cliOptions.trustServerCertificate || false,\n    dryRun: cliOptions.dryRun || false,\n    verbose: cliOptions.verbose ?? true,\n  };\n\n  // Resolve relative paths\n  if (options.migrationsDir && !path.isAbsolute(options.migrationsDir)) {\n    options.migrationsDir = path.resolve(process.cwd(), options.migrationsDir);\n  }\n\n  return options;\n}\n\nfunction validateOptions(options: CliOptions): void {\n  if (!options.migrationsDir) {\n    console.error('Error: --migrations-dir is required');\n    process.exit(1);\n  }\n\n  if (!options.database) {\n    console.error('Error: --database is required');\n    process.exit(1);\n  }\n}\n\nasync function createDataSource(options: CliOptions): Promise<DataSource> {\n  const dataSource = new DataSource({\n    type: 'mssql',\n    host: options.host,\n    port: options.port,\n    database: options.database,\n    username: options.username,\n    password: options.password,\n    options: {\n      encrypt: options.encrypt || false,\n      trustServerCertificate: options.trustServerCertificate || false,\n    },\n  });\n\n  await dataSource.initialize();\n  return dataSource;\n}\n\nasync function runCommand(options: CliOptions): Promise<void> {\n  console.log('Starting migration runner...');\n  console.log(`Migrations directory: ${options.migrationsDir}`);\n  console.log(`Database: ${options.database}`);\n  console.log(`Host: ${options.host}:${options.port}`);\n  console.log('');\n\n  const dataSource = await createDataSource(options);\n  console.log('Database connection established');\n\n  try {\n    const migrationCore = new MigrationCore(dataSource, {\n      migrationsDir: options.migrationsDir,\n    });\n\n    const result = await migrationCore.runMigrations({\n      dryRun: options.dryRun,\n      verbose: options.verbose,\n    });\n\n    if (result.success) {\n      console.log('');\n      console.log('Migration completed successfully!');\n    }\n  } finally {\n    await dataSource.destroy();\n    console.log('Database connection closed');\n  }\n}\n\nasync function statusCommand(options: CliOptions): Promise<void> {\n  console.log('Checking migration status...');\n  console.log(`Migrations directory: ${options.migrationsDir}`);\n  console.log(`Database: ${options.database}`);\n  console.log('');\n\n  const dataSource = await createDataSource(options);\n\n  try {\n    const migrationCore = new MigrationCore(dataSource, {\n      migrationsDir: options.migrationsDir,\n    });\n\n    const status = await migrationCore.getStatus();\n\n    console.log(`Total migrations: ${status.total}`);\n    console.log(`Applied: ${status.applied}`);\n    console.log(`Pending: ${status.pending}`);\n\n    if (status.pendingFiles.length > 0) {\n      console.log('');\n      console.log('Pending migrations:');\n      status.pendingFiles.forEach((file) => console.log(`  - ${file}`));\n    }\n  } finally {\n    await dataSource.destroy();\n  }\n}\n\nasync function main(): Promise<void> {\n  const args = process.argv.slice(2);\n\n  if (args.length === 0 || args.includes('--help')) {\n    printUsage();\n    process.exit(0);\n  }\n\n  const { command, options: cliOptions } = parseArgs(args);\n  const options = resolveOptions(cliOptions);\n\n  if (!command) {\n    console.error('Error: No command specified. Use \"run\" or \"status\".');\n    printUsage();\n    process.exit(1);\n  }\n\n  validateOptions(options);\n\n  try {\n    switch (command) {\n      case 'run':\n        await runCommand(options);\n        break;\n      case 'status':\n        await statusCommand(options);\n        break;\n      default:\n        console.error(`Unknown command: ${command}`);\n        printUsage();\n        process.exit(1);\n    }\n  } catch (error) {\n    console.error('Migration failed:', error);\n    process.exit(1);\n  }\n}\n\nmain();\n"]}

package/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+export { MigrationModule } from './migration.module';
+export { MigrationService } from './migration.service';
+export { MigrationCore } from './migration-core';
+export { MigrationModuleOptions, MigrationModuleAsyncOptions, MigrationModuleOptionsFactory, MigrationResult, MigrationRunOptions, MigrationCoreOptions, MIGRATION_MODULE_OPTIONS, } from './types';

package/dist/src/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIGRATION_MODULE_OPTIONS = exports.MigrationCore = exports.MigrationService = exports.MigrationModule = void 0;
+// Module
+var migration_module_1 = require("./migration.module");
+Object.defineProperty(exports, "MigrationModule", { enumerable: true, get: function () { return migration_module_1.MigrationModule; } });
+// Service
+var migration_service_1 = require("./migration.service");
+Object.defineProperty(exports, "MigrationService", { enumerable: true, get: function () { return migration_service_1.MigrationService; } });
+// Core (for standalone/CLI usage)
+var migration_core_1 = require("./migration-core");
+Object.defineProperty(exports, "MigrationCore", { enumerable: true, get: function () { return migration_core_1.MigrationCore; } });
+// Types
+var types_1 = require("./types");
+Object.defineProperty(exports, "MIGRATION_MODULE_OPTIONS", { enumerable: true, get: function () { return types_1.MIGRATION_MODULE_OPTIONS; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsU0FBUztBQUNULHVEQUFxRDtBQUE1QyxtSEFBQSxlQUFlLE9BQUE7QUFFeEIsVUFBVTtBQUNWLHlEQUF1RDtBQUE5QyxxSEFBQSxnQkFBZ0IsT0FBQTtBQUV6QixrQ0FBa0M7QUFDbEMsbURBQWlEO0FBQXhDLCtHQUFBLGFBQWEsT0FBQTtBQUV0QixRQUFRO0FBQ1IsaUNBUWlCO0FBRGYsaUhBQUEsd0JBQXdCLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBNb2R1bGVcbmV4cG9ydCB7IE1pZ3JhdGlvbk1vZHVsZSB9IGZyb20gJy4vbWlncmF0aW9uLm1vZHVsZSc7XG5cbi8vIFNlcnZpY2VcbmV4cG9ydCB7IE1pZ3JhdGlvblNlcnZpY2UgfSBmcm9tICcuL21pZ3JhdGlvbi5zZXJ2aWNlJztcblxuLy8gQ29yZSAoZm9yIHN0YW5kYWxvbmUvQ0xJIHVzYWdlKVxuZXhwb3J0IHsgTWlncmF0aW9uQ29yZSB9IGZyb20gJy4vbWlncmF0aW9uLWNvcmUnO1xuXG4vLyBUeXBlc1xuZXhwb3J0IHtcbiAgTWlncmF0aW9uTW9kdWxlT3B0aW9ucyxcbiAgTWlncmF0aW9uTW9kdWxlQXN5bmNPcHRpb25zLFxuICBNaWdyYXRpb25Nb2R1bGVPcHRpb25zRmFjdG9yeSxcbiAgTWlncmF0aW9uUmVzdWx0LFxuICBNaWdyYXRpb25SdW5PcHRpb25zLFxuICBNaWdyYXRpb25Db3JlT3B0aW9ucyxcbiAgTUlHUkFUSU9OX01PRFVMRV9PUFRJT05TLFxufSBmcm9tICcuL3R5cGVzJztcbiJdfQ==

package/dist/src/migration-core.d.ts

@@ -0,0 +1,49 @@
+import { DataSource, QueryRunner } from 'typeorm';
+import { MigrationCoreOptions, MigrationResult, MigrationRunOptions } from './types';
+/**
+ * Core migration runner for SQL Server databases.
+ * Handles reading SQL migration files, tracking applied migrations,
+ * and executing pending migrations within transactions.
+ */
+export declare class MigrationCore {
+    private readonly dataSource;
+    private readonly migrationsDir;
+    constructor(dataSource: DataSource, options: MigrationCoreOptions);
+    /**
+     * Ensures the migrations tracking table exists in the database.
+     * Creates it if it doesn't exist.
+     */
+    ensureMigrationsTable(): Promise<void>;
+    /**
+     * Gets the list of migrations that have already been applied.
+     */
+    getAppliedMigrations(): Promise<string[]>;
+    /**
+     * Gets all SQL migration files from the migrations directory.
+     * Files are sorted alphabetically (by convention, use numeric prefixes).
+     */
+    getMigrationFiles(): Promise<string[]>;
+    /**
+     * Runs a single migration file within the provided query runner.
+     * Handles SQL Server's GO batch separator.
+     */
+    runSingleMigration(file: string, queryRunner: QueryRunner): Promise<void>;
+    /**
+     * Runs all pending migrations.
+     * Each migration runs in its own transaction for isolation.
+     */
+    runMigrations(options?: MigrationRunOptions): Promise<MigrationResult>;
+    /**
+     * Gets the list of pending migrations without applying them.
+     */
+    getPendingMigrations(): Promise<string[]>;
+    /**
+     * Gets migration status information.
+     */
+    getStatus(): Promise<{
+        total: number;
+        applied: number;
+        pending: number;
+        pendingFiles: string[];
+    }>;
+}

package/dist/src/migration-core.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrationCore = void 0;
+const fs = require("fs");
+const path = require("path");
+const MIGRATION_TABLE = 'migrations';
+/**
+ * Core migration runner for SQL Server databases.
+ * Handles reading SQL migration files, tracking applied migrations,
+ * and executing pending migrations within transactions.
+ */
+class MigrationCore {
+    dataSource;
+    migrationsDir;
+    constructor(dataSource, options) {
+        this.dataSource = dataSource;
+        this.migrationsDir = options.migrationsDir;
+    }
+    /**
+     * Ensures the migrations tracking table exists in the database.
+     * Creates it if it doesn't exist.
+     */
+    async ensureMigrationsTable() {
+        const tableExists = await this.dataSource.query(`
+      SELECT COUNT(*) as count FROM sysobjects WHERE name='${MIGRATION_TABLE}' AND xtype='U'
+    `);
+        if (tableExists[0].count === 0) {
+            await this.dataSource.query(`
+        CREATE TABLE ${MIGRATION_TABLE} (
+          id INT IDENTITY(1,1) PRIMARY KEY,
+          name NVARCHAR(255) UNIQUE NOT NULL,
+          run_on DATETIME DEFAULT GETDATE() NOT NULL
+        )
+      `);
+        }
+    }
+    /**
+     * Gets the list of migrations that have already been applied.
+     */
+    async getAppliedMigrations() {
+        const rows = await this.dataSource.query(`SELECT name FROM ${MIGRATION_TABLE}`);
+        return rows.map((row) => row.name);
+    }
+    /**
+     * Gets all SQL migration files from the migrations directory.
+     * Files are sorted alphabetically (by convention, use numeric prefixes).
+     */
+    async getMigrationFiles() {
+        if (!fs.existsSync(this.migrationsDir)) {
+            throw new Error(`Migrations directory not found: ${this.migrationsDir}`);
+        }
+        return fs
+            .readdirSync(this.migrationsDir)
+            .filter((f) => f.endsWith('.sql'))
+            .sort();
+    }
+    /**
+     * Runs a single migration file within the provided query runner.
+     * Handles SQL Server's GO batch separator.
+     */
+    async runSingleMigration(file, queryRunner) {
+        const sql = fs.readFileSync(path.join(this.migrationsDir, file), 'utf8');
+        // Split SQL by GO statements (batch separator for SQL Server)
+        // GO is not part of T-SQL and must be handled by the client
+        const batches = sql
+            .split(/^\s*GO\s*$/im)
+            .map((batch) => batch.trim())
+            .filter((batch) => batch.length > 0);
+        // Run each batch separately
+        for (const batch of batches) {
+            await queryRunner.query(batch);
+        }
+        // Track the migration
+        await queryRunner.query(`INSERT INTO ${MIGRATION_TABLE} (name, run_on) VALUES (@0, GETDATE())`, [file]);
+    }
+    /**
+     * Runs all pending migrations.
+     * Each migration runs in its own transaction for isolation.
+     */
+    async runMigrations(options) {
+        const result = {
+            success: false,
+            totalMigrations: 0,
+            appliedMigrations: 0,
+            pendingMigrations: 0,
+        };
+        try {
+            await this.ensureMigrationsTable();
+            const files = await this.getMigrationFiles();
+            const applied = await this.getAppliedMigrations();
+            result.totalMigrations = files.length;
+            result.appliedMigrations = applied.length;
+            if (options?.verbose) {
+                console.log(`Found ${files.length} migration files`);
+                console.log(`${applied.length} migrations already applied`);
+            }
+            const pendingMigrations = files.filter((file) => !applied.includes(file));
+            result.pendingMigrations = pendingMigrations.length;
+            if (pendingMigrations.length === 0) {
+                if (options?.verbose) {
+                    console.log('No pending migrations to apply');
+                }
+                result.success = true;
+                return result;
+            }
+            if (options?.dryRun) {
+                console.log('Dry run mode - would apply:');
+                pendingMigrations.forEach((file) => console.log(`  - ${file}`));
+                result.success = true;
+                return result;
+            }
+            if (options?.verbose) {
+                console.log(`Running ${pendingMigrations.length} pending migrations...`);
+            }
+            for (const file of pendingMigrations) {
+                if (options?.verbose) {
+                    console.log(`Applying migration: ${file}`);
+                }
+                // Use a transaction for each migration
+                const queryRunner = this.dataSource.createQueryRunner();
+                await queryRunner.connect();
+                await queryRunner.startTransaction();
+                try {
+                    await this.runSingleMigration(file, queryRunner);
+                    await queryRunner.commitTransaction();
+                    if (options?.verbose) {
+                        console.log(`✓ Applied migration: ${file}`);
+                    }
+                }
+                catch (error) {
+                    await queryRunner.rollbackTransaction();
+                    if (options?.verbose) {
+                        console.error(`Failed to apply migration ${file}:`, error);
+                    }
+                    result.failedMigration = file;
+                    result.error = error;
+                    throw error;
+                }
+                finally {
+                    await queryRunner.release();
+                }
+            }
+            result.success = true;
+            result.appliedMigrations += pendingMigrations.length;
+            if (options?.verbose) {
+                console.log('All migrations completed successfully!');
+            }
+            return result;
+        }
+        catch (error) {
+            result.error = error;
+            if (options?.verbose) {
+                console.error('Migration failed:', error);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Gets the list of pending migrations without applying them.
+     */
+    async getPendingMigrations() {
+        await this.ensureMigrationsTable();
+        const files = await this.getMigrationFiles();
+        const applied = await this.getAppliedMigrations();
+        return files.filter((file) => !applied.includes(file));
+    }
+    /**
+     * Gets migration status information.
+     */
+    async getStatus() {
+        await this.ensureMigrationsTable();
+        const files = await this.getMigrationFiles();
+        const applied = await this.getAppliedMigrations();
+        const pendingFiles = files.filter((file) => !applied.includes(file));
+        return {
+            total: files.length,
+            applied: applied.length,
+            pending: pendingFiles.length,
+            pendingFiles,
+        };
+    }
+}
+exports.MigrationCore = MigrationCore;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"migration-core.js","sourceRoot":"","sources":["../../src/migration-core.ts"],"names":[],"mappings":"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","sourcesContent":["import { DataSource, QueryRunner } from 'typeorm';\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport { MigrationCoreOptions, MigrationResult, MigrationRunOptions } from './types';\n\nconst MIGRATION_TABLE = 'migrations';\n\n/**\n * Core migration runner for SQL Server databases.\n * Handles reading SQL migration files, tracking applied migrations,\n * and executing pending migrations within transactions.\n */\nexport class MigrationCore {\n  private readonly migrationsDir: string;\n\n  constructor(\n    private readonly dataSource: DataSource,\n    options: MigrationCoreOptions,\n  ) {\n    this.migrationsDir = options.migrationsDir;\n  }\n\n  /**\n   * Ensures the migrations tracking table exists in the database.\n   * Creates it if it doesn't exist.\n   */\n  async ensureMigrationsTable(): Promise<void> {\n    const tableExists = await this.dataSource.query(`\n      SELECT COUNT(*) as count FROM sysobjects WHERE name='${MIGRATION_TABLE}' AND xtype='U'\n    `);\n\n    if (tableExists[0].count === 0) {\n      await this.dataSource.query(`\n        CREATE TABLE ${MIGRATION_TABLE} (\n          id INT IDENTITY(1,1) PRIMARY KEY,\n          name NVARCHAR(255) UNIQUE NOT NULL,\n          run_on DATETIME DEFAULT GETDATE() NOT NULL\n        )\n      `);\n    }\n  }\n\n  /**\n   * Gets the list of migrations that have already been applied.\n   */\n  async getAppliedMigrations(): Promise<string[]> {\n    const rows = await this.dataSource.query<{ name: string }[]>(\n      `SELECT name FROM ${MIGRATION_TABLE}`,\n    );\n    return rows.map((row) => row.name);\n  }\n\n  /**\n   * Gets all SQL migration files from the migrations directory.\n   * Files are sorted alphabetically (by convention, use numeric prefixes).\n   */\n  async getMigrationFiles(): Promise<string[]> {\n    if (!fs.existsSync(this.migrationsDir)) {\n      throw new Error(`Migrations directory not found: ${this.migrationsDir}`);\n    }\n\n    return fs\n      .readdirSync(this.migrationsDir)\n      .filter((f) => f.endsWith('.sql'))\n      .sort();\n  }\n\n  /**\n   * Runs a single migration file within the provided query runner.\n   * Handles SQL Server's GO batch separator.\n   */\n  async runSingleMigration(\n    file: string,\n    queryRunner: QueryRunner,\n  ): Promise<void> {\n    const sql = fs.readFileSync(path.join(this.migrationsDir, file), 'utf8');\n\n    // Split SQL by GO statements (batch separator for SQL Server)\n    // GO is not part of T-SQL and must be handled by the client\n    const batches = sql\n      .split(/^\\s*GO\\s*$/im)\n      .map((batch) => batch.trim())\n      .filter((batch) => batch.length > 0);\n\n    // Run each batch separately\n    for (const batch of batches) {\n      await queryRunner.query(batch);\n    }\n\n    // Track the migration\n    await queryRunner.query(\n      `INSERT INTO ${MIGRATION_TABLE} (name, run_on) VALUES (@0, GETDATE())`,\n      [file],\n    );\n  }\n\n  /**\n   * Runs all pending migrations.\n   * Each migration runs in its own transaction for isolation.\n   */\n  async runMigrations(options?: MigrationRunOptions): Promise<MigrationResult> {\n    const result: MigrationResult = {\n      success: false,\n      totalMigrations: 0,\n      appliedMigrations: 0,\n      pendingMigrations: 0,\n    };\n\n    try {\n      await this.ensureMigrationsTable();\n\n      const files = await this.getMigrationFiles();\n      const applied = await this.getAppliedMigrations();\n\n      result.totalMigrations = files.length;\n      result.appliedMigrations = applied.length;\n\n      if (options?.verbose) {\n        console.log(`Found ${files.length} migration files`);\n        console.log(`${applied.length} migrations already applied`);\n      }\n\n      const pendingMigrations = files.filter((file) => !applied.includes(file));\n      result.pendingMigrations = pendingMigrations.length;\n\n      if (pendingMigrations.length === 0) {\n        if (options?.verbose) {\n          console.log('No pending migrations to apply');\n        }\n        result.success = true;\n        return result;\n      }\n\n      if (options?.dryRun) {\n        console.log('Dry run mode - would apply:');\n        pendingMigrations.forEach((file) => console.log(`  - ${file}`));\n        result.success = true;\n        return result;\n      }\n\n      if (options?.verbose) {\n        console.log(\n          `Running ${pendingMigrations.length} pending migrations...`,\n        );\n      }\n\n      for (const file of pendingMigrations) {\n        if (options?.verbose) {\n          console.log(`Applying migration: ${file}`);\n        }\n\n        // Use a transaction for each migration\n        const queryRunner = this.dataSource.createQueryRunner();\n        await queryRunner.connect();\n        await queryRunner.startTransaction();\n\n        try {\n          await this.runSingleMigration(file, queryRunner);\n          await queryRunner.commitTransaction();\n\n          if (options?.verbose) {\n            console.log(`✓ Applied migration: ${file}`);\n          }\n        } catch (error) {\n          await queryRunner.rollbackTransaction();\n\n          if (options?.verbose) {\n            console.error(`Failed to apply migration ${file}:`, error);\n          }\n\n          result.failedMigration = file;\n          result.error = error;\n          throw error;\n        } finally {\n          await queryRunner.release();\n        }\n      }\n\n      result.success = true;\n      result.appliedMigrations += pendingMigrations.length;\n\n      if (options?.verbose) {\n        console.log('All migrations completed successfully!');\n      }\n\n      return result;\n    } catch (error) {\n      result.error = error;\n\n      if (options?.verbose) {\n        console.error('Migration failed:', error);\n      }\n\n      throw error;\n    }\n  }\n\n  /**\n   * Gets the list of pending migrations without applying them.\n   */\n  async getPendingMigrations(): Promise<string[]> {\n    await this.ensureMigrationsTable();\n    const files = await this.getMigrationFiles();\n    const applied = await this.getAppliedMigrations();\n    return files.filter((file) => !applied.includes(file));\n  }\n\n  /**\n   * Gets migration status information.\n   */\n  async getStatus(): Promise<{\n    total: number;\n    applied: number;\n    pending: number;\n    pendingFiles: string[];\n  }> {\n    await this.ensureMigrationsTable();\n    const files = await this.getMigrationFiles();\n    const applied = await this.getAppliedMigrations();\n    const pendingFiles = files.filter((file) => !applied.includes(file));\n\n    return {\n      total: files.length,\n      applied: applied.length,\n      pending: pendingFiles.length,\n      pendingFiles,\n    };\n  }\n}\n"]}

package/dist/src/migration.module.d.ts

@@ -0,0 +1,37 @@
+import { DynamicModule } from '@nestjs/common';
+import { MigrationModuleAsyncOptions, MigrationModuleOptions } from './types';
+/**
+ * NestJS module for SQL Server migrations.
+ *
+ * @example
+ * // Synchronous configuration
+ * MigrationModule.forRoot({
+ *   migrationsDir: path.join(__dirname, '../migrations'),
+ *   autoRun: true,
+ *   verbose: true,
+ * })
+ *
+ * @example
+ * // Asynchronous configuration with ConfigService
+ * MigrationModule.forRootAsync({
+ *   imports: [ConfigModule],
+ *   inject: [ConfigService],
+ *   useFactory: (configService: ConfigService) => ({
+ *     migrationsDir: path.join(__dirname, '../migrations'),
+ *     autoRun: configService.get<boolean>('AUTO_RUN_MIGRATIONS', false),
+ *     verbose: true,
+ *   }),
+ * })
+ */
+export declare class MigrationModule {
+    /**
+     * Configure the migration module with static options.
+     */
+    static forRoot(options: MigrationModuleOptions): DynamicModule;
+    /**
+     * Configure the migration module with async options.
+     * Useful when options depend on ConfigService or other async providers.
+     */
+    static forRootAsync(options: MigrationModuleAsyncOptions): DynamicModule;
+    private static createAsyncProviders;
+}

package/dist/src/migration.module.js

@@ -0,0 +1,108 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var MigrationModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrationModule = void 0;
+const common_1 = require("@nestjs/common");
+const migration_service_1 = require("./migration.service");
+const types_1 = require("./types");
+/**
+ * NestJS module for SQL Server migrations.
+ *
+ * @example
+ * // Synchronous configuration
+ * MigrationModule.forRoot({
+ *   migrationsDir: path.join(__dirname, '../migrations'),
+ *   autoRun: true,
+ *   verbose: true,
+ * })
+ *
+ * @example
+ * // Asynchronous configuration with ConfigService
+ * MigrationModule.forRootAsync({
+ *   imports: [ConfigModule],
+ *   inject: [ConfigService],
+ *   useFactory: (configService: ConfigService) => ({
+ *     migrationsDir: path.join(__dirname, '../migrations'),
+ *     autoRun: configService.get<boolean>('AUTO_RUN_MIGRATIONS', false),
+ *     verbose: true,
+ *   }),
+ * })
+ */
+let MigrationModule = MigrationModule_1 = class MigrationModule {
+    /**
+     * Configure the migration module with static options.
+     */
+    static forRoot(options) {
+        return {
+            module: MigrationModule_1,
+            providers: [
+                {
+                    provide: types_1.MIGRATION_MODULE_OPTIONS,
+                    useValue: options,
+                },
+                migration_service_1.MigrationService,
+            ],
+            exports: [migration_service_1.MigrationService],
+        };
+    }
+    /**
+     * Configure the migration module with async options.
+     * Useful when options depend on ConfigService or other async providers.
+     */
+    static forRootAsync(options) {
+        return {
+            module: MigrationModule_1,
+            imports: options.imports || [],
+            providers: [
+                ...this.createAsyncProviders(options),
+                migration_service_1.MigrationService,
+            ],
+            exports: [migration_service_1.MigrationService],
+        };
+    }
+    static createAsyncProviders(options) {
+        if (options.useFactory) {
+            return [
+                {
+                    provide: types_1.MIGRATION_MODULE_OPTIONS,
+                    useFactory: options.useFactory,
+                    inject: options.inject || [],
+                },
+            ];
+        }
+        if (options.useClass) {
+            return [
+                {
+                    provide: options.useClass,
+                    useClass: options.useClass,
+                },
+                {
+                    provide: types_1.MIGRATION_MODULE_OPTIONS,
+                    useFactory: async (optionsFactory) => optionsFactory.createMigrationOptions(),
+                    inject: [options.useClass],
+                },
+            ];
+        }
+        if (options.useExisting) {
+            return [
+                {
+                    provide: types_1.MIGRATION_MODULE_OPTIONS,
+                    useFactory: async (optionsFactory) => optionsFactory.createMigrationOptions(),
+                    inject: [options.useExisting],
+                },
+            ];
+        }
+        return [];
+    }
+};
+exports.MigrationModule = MigrationModule;
+exports.MigrationModule = MigrationModule = MigrationModule_1 = __decorate([
+    (0, common_1.Module)({})
+], MigrationModule);
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/migration.service.d.ts

@@ -0,0 +1,32 @@
+import { OnModuleInit } from '@nestjs/common';
+import { DataSource } from 'typeorm';
+import { MigrationModuleOptions, MigrationResult, MigrationRunOptions } from './types';
+/**
+ * NestJS service for running SQL Server migrations.
+ * Automatically runs migrations on module initialization if autoRun is enabled.
+ */
+export declare class MigrationService implements OnModuleInit {
+    private readonly options;
+    private readonly migrationCore;
+    private readonly autoRun;
+    private readonly verbose;
+    constructor(options: MigrationModuleOptions, dataSource: DataSource);
+    onModuleInit(): Promise<void>;
+    /**
+     * Run all pending migrations.
+     */
+    runMigrations(options?: MigrationRunOptions): Promise<MigrationResult>;
+    /**
+     * Get list of pending migration files.
+     */
+    getPendingMigrations(): Promise<string[]>;
+    /**
+     * Get migration status information.
+     */
+    getStatus(): Promise<{
+        total: number;
+        applied: number;
+        pending: number;
+        pendingFiles: string[];
+    }>;
+}

package/dist/src/migration.service.js

@@ -0,0 +1,77 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrationService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("typeorm");
+const migration_core_1 = require("./migration-core");
+const types_1 = require("./types");
+/**
+ * NestJS service for running SQL Server migrations.
+ * Automatically runs migrations on module initialization if autoRun is enabled.
+ */
+let MigrationService = class MigrationService {
+    options;
+    migrationCore;
+    autoRun;
+    verbose;
+    constructor(options, dataSource) {
+        this.options = options;
+        this.migrationCore = new migration_core_1.MigrationCore(dataSource, {
+            migrationsDir: options.migrationsDir,
+        });
+        this.autoRun = options.autoRun ?? false;
+        this.verbose = options.verbose ?? true;
+    }
+    async onModuleInit() {
+        if (!this.autoRun) {
+            if (this.verbose) {
+                console.log('Auto migrations are disabled');
+            }
+            return;
+        }
+        if (this.verbose) {
+            console.log('Auto-running migrations...');
+        }
+        await this.runMigrations();
+    }
+    /**
+     * Run all pending migrations.
+     */
+    async runMigrations(options) {
+        return this.migrationCore.runMigrations({
+            verbose: this.verbose,
+            ...options,
+        });
+    }
+    /**
+     * Get list of pending migration files.
+     */
+    async getPendingMigrations() {
+        return this.migrationCore.getPendingMigrations();
+    }
+    /**
+     * Get migration status information.
+     */
+    async getStatus() {
+        return this.migrationCore.getStatus();
+    }
+};
+exports.MigrationService = MigrationService;
+exports.MigrationService = MigrationService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(types_1.MIGRATION_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [Object, typeorm_1.DataSource])
+], MigrationService);
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/types.d.ts

@@ -0,0 +1,83 @@
+import { ModuleMetadata, Type } from '@nestjs/common';
+export interface MigrationModuleOptions {
+    /**
+     * Path to the directory containing SQL migration files
+     */
+    migrationsDir: string;
+    /**
+     * Whether to automatically run migrations on module initialization
+     * @default false
+     */
+    autoRun?: boolean;
+    /**
+     * Whether to log verbose output during migration execution
+     * @default true
+     */
+    verbose?: boolean;
+}
+export interface MigrationModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    /**
+     * Factory function to create MigrationModuleOptions
+     */
+    useFactory: (...args: any[]) => Promise<MigrationModuleOptions> | MigrationModuleOptions;
+    /**
+     * Dependencies to inject into the factory function
+     */
+    inject?: any[];
+    /**
+     * Optional class to use for creating options
+     */
+    useClass?: Type<MigrationModuleOptionsFactory>;
+    /**
+     * Optional existing instance to use for options
+     */
+    useExisting?: Type<MigrationModuleOptionsFactory>;
+}
+export interface MigrationModuleOptionsFactory {
+    createMigrationOptions(): Promise<MigrationModuleOptions> | MigrationModuleOptions;
+}
+export interface MigrationResult {
+    /**
+     * Whether the migration run was successful
+     */
+    success: boolean;
+    /**
+     * Total number of migration files found
+     */
+    totalMigrations: number;
+    /**
+     * Number of migrations already applied
+     */
+    appliedMigrations: number;
+    /**
+     * Number of pending migrations to apply
+     */
+    pendingMigrations: number;
+    /**
+     * Name of the failed migration file (if any)
+     */
+    failedMigration?: string;
+    /**
+     * Error object if migration failed
+     */
+    error?: any;
+}
+export interface MigrationRunOptions {
+    /**
+     * If true, only list pending migrations without applying them
+     * @default false
+     */
+    dryRun?: boolean;
+    /**
+     * Whether to log verbose output
+     * @default false
+     */
+    verbose?: boolean;
+}
+export interface MigrationCoreOptions {
+    /**
+     * Path to the directory containing SQL migration files
+     */
+    migrationsDir: string;
+}
+export declare const MIGRATION_MODULE_OPTIONS: unique symbol;

package/dist/src/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIGRATION_MODULE_OPTIONS = void 0;
+exports.MIGRATION_MODULE_OPTIONS = Symbol('MIGRATION_MODULE_OPTIONS');
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@studiosonrai/nestjs-migrations",
+  "version": "1.0.0",
+  "description": "SQL Server migrations module for NestJS applications",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "bin": {
+    "nestjs-migrations": "./dist/bin/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "prepublishOnly": "npm run build",
+    "clean": "rm -rf dist"
+  },
+  "keywords": [
+    "nestjs",
+    "migrations",
+    "sql-server",
+    "mssql",
+    "typeorm"
+  ],
+  "author": "",
+  "license": "UNLICENSED",
+  "peerDependencies": {
+    "@nestjs/common": "^11.0.0",
+    "@nestjs/config": "^4.0.0",
+    "@nestjs/core": "^11.0.0",
+    "typeorm": "^0.3.0"
+  },
+  "dependencies": {
+    "dotenv": "^17.2.1"
+  },
+  "devDependencies": {
+    "@nestjs/common": "^11.0.1",
+    "@nestjs/config": "^4.0.2",
+    "@nestjs/core": "^11.0.1",
+    "@types/node": "^22.10.7",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.1",
+    "typeorm": "^0.3.25",
+    "typescript": "^5.7.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}