mysql-migration 1.2.6 → 1.4.0

package/src/commands/create.js

@@ -1,78 +1,95 @@
 "use strict";
-//---------------------------------------
+
 const fs = require("fs");
 const dayjs = require("dayjs");
 const path = require("path");
-//---------------------------------------
+
 const currentPath = process.cwd();
-const config = require(`${currentPath}/migrations/mysql-migration.config.json`);
-//---------------------------------------
+const configPath = path.join(currentPath, "migrations", "mysql-migration.config.json");
+
+const { loadConfig, getDatabaseNames, isValidDatabase } = require("../utils/config");
+
+/**
+ * Scaffold a new migration file for the selected database.
+ * @param {string} migrationName - Slug for the migration file (no spaces recommended).
+ * @param {string} dbName - Target database identifier.
+ * @returns {void}
+ */
 function create_migration(migrationName, dbName) {
    if (!migrationName) {
-      console.error("\x1b[31m%s\x1b[0m", `Error: Migration name is empty !`);
+      console.error("\x1b[31m%s\x1b[0m", `Error: Migration name is required.`);
       process.exit(1);
    }
-   //---------------------------------------
-   const databases = Object.keys(config.databases);
-   //---------------------------------------
-   if (!databases.includes(dbName)) {
-      console.error("\x1b[31m%s\x1b[0m", `Error: Invalid database name "${dbName}" can be: ${databases.join(", ")}.`);
+
+   const config = loadConfig(configPath);
+   const databases = getDatabaseNames(config);
+
+   if (!isValidDatabase(dbName, config)) {
+      console.error("\x1b[31m%s\x1b[0m", `Error: Invalid database name "${dbName}". Available databases: ${databases.join(", ")}.`);
       process.exit(1);
    }
-   //---------------------------------------
-   if (!fs.existsSync(`${currentPath}/migrations/${dbName}_db`))
-      fs.mkdirSync(`${currentPath}/migrations/${dbName}_db`);
-   //---------------------------------------
+
+   const migrationsDir = path.join(currentPath, "migrations", `${dbName}_db`);
+   if (!fs.existsSync(migrationsDir)) {
+      fs.mkdirSync(migrationsDir, { recursive: true });
+   }
+
    const currentDate = dayjs().format("YYYY_MM_DD_HHmmss");
    const fileName = `${currentDate}_${migrationName}.js`;
-   const filePath = `${currentPath}/migrations/${dbName}_db/${fileName}`;
-   //---------------------------------------
-   if (fs.existsSync(filePath))
-      console.warn("\x1b[33m%s\x1b[0m", `Warning: File "${fileName}" already exists in the "migrations" directory.`);
-   else {
-      let isEsm = false;
-      try {
-         const packageJsonPath = path.join(currentPath, "package.json");
-         if (fs.existsSync(packageJsonPath)) {
-            const packageJson = require(packageJsonPath);
-            if (packageJson.type === "module") {
-               isEsm = true;
-            }
+   const filePath = path.join(migrationsDir, fileName);
+
+   if (fs.existsSync(filePath)) {
+      console.warn("\x1b[33m%s\x1b[0m", `Warning: File "${fileName}" already exists in the migrations directory.`);
+      return;
+   }
+
+   let isEsm = false;
+   try {
+      const packageJsonPath = path.join(currentPath, "package.json");
+      if (fs.existsSync(packageJsonPath)) {
+         const packageJson = require(packageJsonPath);
+         if (packageJson.type === "module") {
+            isEsm = true;
          }
-      } catch (e) {
-         // Ignore error, default to CJS
       }
+   } catch (e) {
+      // Ignore error, default to CJS
+   }
 
-      const exportPrefix = isEsm ? "export default" : "module.exports =";
+   const exportPrefix = isEsm ? "export default" : "module.exports =";
 
-      const dataText = `${exportPrefix} {
-   up: (connection) => {
+   const dataText = `${exportPrefix} {
+   /**
+    * Run the migration
+    * @param {import('mysql2').Connection} connection
+    */
+   up: async (connection) => {
       const query = "";
 
-      return new Promise((resolve, reject) => {
-         if (!query) reject('Migration query is empty !');
-         connection.query(query, (err) => {
-            if (err) reject(err);
-            resolve();
-         });
-      });
+      if (!query) {
+         throw new Error('Migration query is empty.');
+      }
+
+      await connection.promise().query(query);
    },
 
-   down: (connection) => {
+   /**
+    * Rollback the migration
+    * @param {import('mysql2').Connection} connection
+    */
+   down: async (connection) => {
       const query = "";
 
-      return new Promise((resolve, reject) => {
-         if (!query) reject('Migration query is empty !');
-         connection.query(query, (err) => {
-            if (err) reject(err);
-            resolve();
-         });
-      });
+      if (!query) {
+         throw new Error('Migration query is empty.');
+      }
+
+      await connection.promise().query(query);
    }
 };`;
-      fs.writeFileSync(filePath, dataText);
-      console.log("\x1b[32m%s\x1b[0m", `Created migration file: "${fileName}".`);
-   }
+
+   fs.writeFileSync(filePath, dataText);
+   console.log("\x1b[32m%s\x1b[0m", `Created migration file: "${fileName}".`);
 }
-//---------------------------------------
+
 module.exports = create_migration;

package/src/commands/init.js

@@ -1,29 +1,36 @@
 "use strict";
-//---------------------------------------
+
 const fs = require("fs");
-//---------------------------------------
+const path = require("path");
+
 const currentPath = process.cwd();
-//---------------------------------------
-if (!fs.existsSync(`${currentPath}/migrations`)) fs.mkdirSync(`${currentPath}/migrations`);
-if (!fs.existsSync(`${currentPath}/migrations/mysql-migration.config.json`))
-    fs.writeFileSync(
-        `${currentPath}/migrations/mysql-migration.config.json`,
-        JSON.stringify(
-            {
-                databases: {
-                    db_name: {
-                        host: "db_host",
-                        user: "db_user",
-                        password: "db_password",
-                        database: "db_name",
-                    },
-                },
+
+const migrationsDir = path.join(currentPath, "migrations");
+const configPath = path.join(migrationsDir, "mysql-migration.config.json");
+
+if (!fs.existsSync(migrationsDir)) {
+    fs.mkdirSync(migrationsDir, { recursive: true });
+}
+
+if (!fs.existsSync(configPath)) {
+    const defaultConfig = {
+        databases: {
+            db_name: {
+                host: "db_host",
+                user: "db_user",
+                password: "db_password",
+                database: "db_name",
             },
-            null,
-            3
-        )
+        },
+    };
+
+    fs.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 3));
+    console.log(
+        "\x1b[32m%s\x1b[0m",
+        `Created migration config file: "mysql-migration.config.json" in the "migrations" directory.`
     );
-console.log(
-    "\x1b[32m%s\x1b[0m",
-    `Created migration config file: "mysql-migration.config.json" in the "migrations" directory.`
-);
+    console.log("\x1b[36m%s\x1b[0m", "\nTip: You can use environment variables to override config values:");
+    console.log("  - DB_NAME_HOST, DB_NAME_USER, DB_NAME_PASSWORD, DB_NAME_DATABASE, DB_NAME_PORT");
+} else {
+    console.warn("\x1b[33m%s\x1b[0m", 'Config file "mysql-migration.config.json" already exists.');
+}

package/src/commands/run.js

@@ -1,131 +1,203 @@
-"use strict";
-//==============================================================================
-const fs = require("fs");
-const mysql = require("mysql2");
-const path = require("path");
-//---------------------------------------
-const currentPath = process.cwd();
-const configPath = path.join(currentPath, "migrations", "mysql-migration.config.json");
-if (!fs.existsSync(configPath)) {
-    console.error(
-        "\x1b[31m%s\x1b[0m",
-        'Error: Config file "mysql-migration.config.json" not found. Run "mysql-migration init" first.'
-    );
-    process.exit(1);
-}
-const config = require(configPath);
-const {
-    checkTableMigrations,
-    createTableMigrations,
-    getAllMigrations,
-    getCurrentBatch,
-    insertMigration,
-} = require("../utils/functions");
-const { loadModule } = require("../utils/moduleLoader");
-//==============================================================================
-async function run_migration(dbName) {
-    const connection = {},
-        migrations = [];
-    const databases = config.databases;
-    //---------------------------------------
-    if (dbName) {
-        if (!databases[dbName]) {
-            console.error("\x1b[31m%s\x1b[0m", `Error: Invalid database name "${dbName}".`);
-            process.exit(1);
-        }
-        //---------------------------------------
-        connection[dbName] = mysql.createConnection(databases[dbName]);
-        try {
-            await connection[dbName].promise().connect();
-        } catch (err) {
-            console.error("\x1b[31m%s\x1b[0m", `Error: Unable to connect to database "${dbName}".\n${err}`);
-            process.exit(1);
-        }
-        //---------------------------------------
-        const tableMigrations = await checkTableMigrations(connection[dbName]);
-        if (!tableMigrations) await createTableMigrations(connection[dbName]);
-        //---------------------------------------
-        const batch = (await getCurrentBatch(connection[dbName])) + 1;
-        const allMigrations = await getAllMigrations(connection[dbName]);
-        const migrationsDir = `${currentPath}/migrations/${dbName}_db`;
-        if (!fs.existsSync(migrationsDir)) {
-            console.log("\x1b[32m%s\x1b[0m", "Nothing to migrate.\n");
-            await connection[dbName].promise().end();
-            process.exit(0);
-        }
-        const migrationFiles = fs.readdirSync(migrationsDir);
-        //---------------------------------------
-        const pendingMigrations = migrationFiles.filter(
-            (val) => !allMigrations.some((val2) => val.includes(val2.migration))
-        );
-        //---------------------------------------
-        if (pendingMigrations.length === 0) {
-            console.log("\x1b[32m%s\x1b[0m", "Nothing to migrate.\n");
-            await connection[dbName].promise().end();
-            process.exit(0);
-        }
-        //---------------------------------------
-        for (let file of pendingMigrations) {
-            const migrationPath = `${currentPath}/migrations/${dbName}_db/${file}`;
-            const migration = await loadModule(migrationPath);
-            try {
-                await migration.up(connection[dbName]);
-                await insertMigration(connection[dbName], file.replace(".js", ""), batch);
-                console.log("\x1b[36m%s\x1b[0m", `Migrated: "${file}" successfully.`);
-            } catch (err) {
-                console.warn("\x1b[33m%s\x1b[0m", `Warning: "${err}" in migration "${file}".`);
-            }
-        }
-        console.log("\x1b[32m%s\x1b[0m", "All migrations have been completed successfully.\n");
-        await connection[dbName].promise().end();
-    } else {
-        for (let key in databases) {
-            connection[key] = mysql.createConnection(databases[key]);
-            try {
-                await connection[key].promise().connect();
-            } catch (err) {
-                console.error("\x1b[31m%s\x1b[0m", `Error: Unable to connect to database "${key}".`);
-                process.exit(1);
-            }
-            //---------------------------------------
-            const tableMigrations = await checkTableMigrations(connection[key]);
-            if (!tableMigrations) await createTableMigrations(connection[key]);
-            //---------------------------------------
-            const batch = (await getCurrentBatch(connection[key])) + 1;
-
-            const allMigrations = await getAllMigrations(connection[key]);
-            //---------------------------------------
-            if (!fs.existsSync(`${currentPath}/migrations/${key}_db`)) continue;
-            const migration = fs.readdirSync(`${currentPath}/migrations/${key}_db`);
-            //---------------------------------------
-            const diffMigrations = migration.filter(
-                (val) => !allMigrations.some((val2) => val.includes(val2.migration))
-            );
-            //---------------------------------------
-            for (let m of diffMigrations) migrations.push([m, key, batch]);
-        }
-
-        //---------------------------------------
-        if (migrations.length === 0) {
-            console.log("\x1b[32m%s\x1b[0m", "Nothing to migrate.\n");
-            for (let key in connection) await connection[key].promise().end();
-            process.exit(0);
-        }
-        //---------------------------------------
-        for (let [file, key, batch] of migrations) {
-            const migrationPath = `${currentPath}/migrations/${key}_db/${file}`;
-            const migration = await loadModule(migrationPath);
-            try {
-                await migration.up(connection[key]);
-                await insertMigration(connection[key], file.replace(".js", ""), batch);
-                console.log("\x1b[36m%s\x1b[0m", `Migrated: "${file}" in database "${key}" successfully.`);
-            } catch (err) {
-                console.warn("\x1b[33m%s\x1b[0m", `Warning: "${err}" in migration "${file}" in database "${key}".`);
-            }
-        }
-        console.log("\x1b[32m%s\x1b[0m", "All migrations have been completed successfully.\n");
-        for (let key in connection) await connection[key].promise().end();
-    }
-}
-//==============================================================================
-module.exports = run_migration;
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const currentPath = process.cwd();
+const configPath = path.join(currentPath, "migrations", "mysql-migration.config.json");
+
+if (!fs.existsSync(configPath)) {
+    console.error(
+        "\x1b[31m%s\x1b[0m",
+        'Error: Config file "mysql-migration.config.json" not found. Run "mysql-migration init" first.'
+    );
+    process.exit(1);
+}
+
+const ConnectionManager = require("../utils/connectionManager");
+const { loadConfig, getDatabaseConfig, isValidDatabase } = require("../utils/config");
+const {
+    checkTableMigrations,
+    createTableMigrations,
+    getAllMigrations,
+    getCurrentBatch,
+    insertMigration,
+    withTransaction,
+} = require("../utils/functions");
+const { loadModule } = require("../utils/moduleLoader");
+
+/**
+ * Run migration with optional dry-run mode.
+ * @param {string|null} dbName - Target database name or null to process all databases.
+ * @param {boolean} dryRun - When true, preview migrations without executing them.
+ * @param {boolean} useTransaction - When true, wrap migrations in a transaction per database.
+ * @returns {Promise<void>}
+ */
+async function run_migration(dbName, dryRun = false, useTransaction = false) {
+    const config = loadConfig(configPath);
+    const connectionManager = new ConnectionManager();
+
+    try {
+        if (dbName) {
+            if (!isValidDatabase(dbName, config)) {
+                console.error("\x1b[31m%s\x1b[0m", `Error: Invalid database name "${dbName}".`);
+                process.exit(1);
+            }
+            await runForDatabase(dbName, config, connectionManager, dryRun, useTransaction);
+        } else {
+            await runForAllDatabases(config, connectionManager, dryRun, useTransaction);
+        }
+    } finally {
+        await connectionManager.closeAll();
+    }
+}
+
+/**
+ * Run migrations for a single database.
+ * @param {string} dbName - Database identifier.
+ * @param {{databases: Record<string, any>}} config - Loaded migration configuration.
+ * @param {ConnectionManager} connectionManager - Shared connection manager instance.
+ * @param {boolean} dryRun - Whether to preview migrations only.
+ * @param {boolean} useTransaction - Whether to wrap execution in a transaction.
+ * @returns {Promise<void>}
+ */
+async function runForDatabase(dbName, config, connectionManager, dryRun, useTransaction) {
+    const dbConfig = getDatabaseConfig(dbName, config);
+    const migrationsDir = path.join(currentPath, "migrations", `${dbName}_db`);
+
+    await connectionManager.withConnection(dbName, dbConfig, async (connection) => {
+        const tableMigrations = await checkTableMigrations(connection);
+        if (!tableMigrations) await createTableMigrations(connection);
+
+        const batch = (await getCurrentBatch(connection)) + 1;
+        const allMigrations = await getAllMigrations(connection);
+
+        if (!fs.existsSync(migrationsDir)) {
+            console.log("\x1b[32m%s\x1b[0m", "Nothing to migrate.\n");
+            return;
+        }
+
+        const migrationFiles = fs.readdirSync(migrationsDir);
+        const pendingMigrations = migrationFiles.filter(
+            (val) => !allMigrations.some((val2) => val.includes(val2.migration))
+        );
+
+        if (pendingMigrations.length === 0) {
+            console.log("\x1b[32m%s\x1b[0m", "Nothing to migrate.\n");
+            return;
+        }
+
+        if (dryRun) {
+            console.log("\x1b[33m%s\x1b[0m", `Dry-run mode: Previewing migrations for database "${dbName}":\n`);
+            for (let file of pendingMigrations) {
+                console.log(`  Would migrate: "${file}"`);
+            }
+            console.log(`\nBatch: ${batch}`);
+            return;
+        }
+
+        const executeMigration = async (connection) => {
+            for (let file of pendingMigrations) {
+                const migrationPath = path.join(migrationsDir, file);
+                const migration = await loadModule(migrationPath);
+                try {
+                    await migration.up(connection);
+                    await insertMigration(connection, file.replace(".js", ""), batch);
+                    console.log("\x1b[36m%s\x1b[0m", `Migrated: "${file}" successfully.`);
+                } catch (err) {
+                    console.warn("\x1b[33m%s\x1b[0m", `Warning: "${err}" in migration "${file}".`);
+                    throw err;
+                }
+            }
+        };
+
+        if (useTransaction) {
+            await withTransaction(connection, executeMigration);
+        } else {
+            await executeMigration(connection);
+        }
+
+        console.log("\x1b[32m%s\x1b[0m", "All migrations have been completed successfully.\n");
+    });
+}
+
+/**
+ * Run migrations for all configured databases.
+ * @param {{databases: Record<string, any>}} config - Loaded migration configuration.
+ * @param {ConnectionManager} connectionManager - Shared connection manager instance.
+ * @param {boolean} dryRun - Whether to preview migrations only.
+ * @param {boolean} useTransaction - Whether to wrap execution in transactions.
+ * @returns {Promise<void>}
+ */
+async function runForAllDatabases(config, connectionManager, dryRun, useTransaction) {
+    const databases = config.databases;
+    const migrations = [];
+
+    for (let key in databases) {
+        const dbConfig = getDatabaseConfig(key, config);
+        const migrationsDir = path.join(currentPath, "migrations", `${key}_db`);
+
+        try {
+            await connectionManager.createConnection(key, dbConfig);
+            const connection = connectionManager.getConnection(key);
+
+            const tableMigrations = await checkTableMigrations(connection);
+            if (!tableMigrations) await createTableMigrations(connection);
+
+            const batch = (await getCurrentBatch(connection)) + 1;
+            const allMigrations = await getAllMigrations(connection);
+
+            if (!fs.existsSync(migrationsDir)) continue;
+
+            const migrationFiles = fs.readdirSync(migrationsDir);
+            const diffMigrations = migrationFiles.filter(
+                (val) => !allMigrations.some((val2) => val.includes(val2.migration))
+            );
+
+            for (let m of diffMigrations) migrations.push([m, key, batch]);
+        } catch (err) {
+            console.error("\x1b[31m%s\x1b[0m", `Error: Unable to connect to database "${key}".`);
+            process.exit(1);
+        }
+    }
+
+    if (migrations.length === 0) {
+        console.log("\x1b[32m%s\x1b[0m", "Nothing to migrate.\n");
+        return;
+    }
+
+    if (dryRun) {
+        console.log("\x1b[33m%s\x1b[0m", "Dry-run mode: Previewing migrations:\n");
+        for (let [file, key, batch] of migrations) {
+            console.log(`  Would migrate: "${file}" in database "${key}" [Batch ${batch}]`);
+        }
+        return;
+    }
+
+    for (let [file, key, batch] of migrations) {
+        const connection = connectionManager.getConnection(key);
+        const migrationPath = path.join(currentPath, "migrations", `${key}_db`, file);
+        const migration = await loadModule(migrationPath);
+
+        const executeMigration = async (conn) => {
+            try {
+                await migration.up(conn);
+                await insertMigration(conn, file.replace(".js", ""), batch);
+                console.log("\x1b[36m%s\x1b[0m", `Migrated: "${file}" in database "${key}" successfully.`);
+            } catch (err) {
+                console.warn("\x1b[33m%s\x1b[0m", `Warning: "${err}" in migration "${file}" in database "${key}".`);
+                throw err;
+            }
+        };
+
+        if (useTransaction) {
+            await withTransaction(connection, executeMigration);
+        } else {
+            await executeMigration(connection);
+        }
+    }
+
+    console.log("\x1b[32m%s\x1b[0m", "All migrations have been completed successfully.\n");
+}
+
+module.exports = run_migration;

package/src/commands/to-cjs.js

@@ -1,26 +1,33 @@
 "use strict";
-//---------------------------------------
+
 const fs = require("fs");
 const path = require("path");
-//---------------------------------------
+
 const currentPath = process.cwd();
-const config = require(`${currentPath}/migrations/mysql-migration.config.json`);
-//---------------------------------------
+const configPath = path.join(currentPath, "migrations", "mysql-migration.config.json");
+
+const { loadConfig, getDatabaseNames, isValidDatabase } = require("../utils/config");
+
+/**
+ * Convert migration files within a database directory from ESM to CommonJS format.
+ * @param {string} dbName - Target database identifier.
+ * @returns {void}
+ */
 function convert_to_cjs(dbName) {
-    //---------------------------------------
-    const databases = Object.keys(config.databases);
-    //---------------------------------------
-    if (!databases.includes(dbName)) {
-        console.error("\x1b[31m%s\x1b[0m", `Error: Invalid database name "${dbName}" can be: ${databases.join(", ")}.`);
+    const config = loadConfig(configPath);
+    const databases = getDatabaseNames(config);
+
+    if (!isValidDatabase(dbName, config)) {
+        console.error("\x1b[31m%s\x1b[0m", `Error: Invalid database name "${dbName}". Available databases: ${databases.join(", ")}.`);
         process.exit(1);
     }
-    //---------------------------------------
-    const migrationsDir = `${currentPath}/migrations/${dbName}_db`;
+
+    const migrationsDir = path.join(currentPath, "migrations", `${dbName}_db`);
     if (!fs.existsSync(migrationsDir)) {
         console.error("\x1b[31m%s\x1b[0m", `Error: Migrations directory for "${dbName}" not found.`);
         process.exit(1);
     }
-    //---------------------------------------
+
     const files = fs.readdirSync(migrationsDir);
     let convertedCount = 0;
 
@@ -45,5 +52,5 @@ function convert_to_cjs(dbName) {
         console.log("\x1b[32m%s\x1b[0m", `\nSuccessfully converted ${convertedCount} files to CJS.`);
     }
 }
-//---------------------------------------
+
 module.exports = convert_to_cjs;