mysql-migration 1.2.5 → 1.4.0

package/src/commands/to-esm.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 CommonJS to ESM format.
+ * @param {string} dbName - Target database identifier.
+ * @returns {void}
+ */
 function convert_to_esm(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_esm(dbName) {
         console.log("\x1b[32m%s\x1b[0m", `\nSuccessfully converted ${convertedCount} files to ESM.`);
     }
 }
-//---------------------------------------
+
 module.exports = convert_to_esm;

package/src/utils/config.js

@@ -0,0 +1,66 @@
+"use strict";
+
+const fs = require("fs");
+
+/**
+ * Load and parse configuration file
+ * @param {string} configPath - Path to config file
+ * @returns {{databases: Record<string, import('mysql2').ConnectionOptions>}}
+ * @throws {Error} If config file not found or invalid
+ */
+function loadConfig(configPath) {
+    if (!fs.existsSync(configPath)) {
+        throw new Error('Config file not found. Run "mysql-migration init" first.');
+    }
+
+    const rawConfig = JSON.parse(fs.readFileSync(configPath, "utf8"));
+
+    // Validate config structure
+    if (!rawConfig.databases || typeof rawConfig.databases !== "object") {
+        throw new Error('Invalid config file: missing or invalid "databases" object');
+    }
+
+    return rawConfig;
+}
+
+/**
+ * Get database configuration
+ * @param {string} dbName - Database name
+ * @param {{databases: Record<string, any>}} config - Raw config object
+ * @returns {import('mysql2').ConnectionOptions}
+ */
+function getDatabaseConfig(dbName, config) {
+    const dbConfig = config.databases[dbName];
+
+    if (!dbConfig) {
+        throw new Error(`Database "${dbName}" not found in configuration`);
+    }
+
+    return { ...dbConfig };
+}
+
+/**
+ * Get all database names from config
+ * @param {{databases: Record<string, any>}} config - Raw config object
+ * @returns {string[]}
+ */
+function getDatabaseNames(config) {
+    return Object.keys(config.databases);
+}
+
+/**
+ * Validate database name exists in config
+ * @param {string} dbName - Database name to validate
+ * @param {{databases: Record<string, any>}} config - Raw config object
+ * @returns {boolean}
+ */
+function isValidDatabase(dbName, config) {
+    return dbName in config.databases;
+}
+
+module.exports = {
+    loadConfig,
+    getDatabaseConfig,
+    getDatabaseNames,
+    isValidDatabase,
+};

package/src/utils/connectionManager.js

@@ -0,0 +1,102 @@
+"use strict";
+
+const mysql = require("mysql2");
+
+/**
+ * Connection manager for handling database connections with proper cleanup
+ */
+class ConnectionManager {
+    constructor() {
+        /** @type {Map<string, import('mysql2').Connection>} */
+        this.connections = new Map();
+    }
+
+    /**
+     * Create a new database connection
+     * @param {string} name - Connection name/identifier
+     * @param {import('mysql2').ConnectionOptions} config - Database configuration
+     * @returns {Promise<import('mysql2').Connection>}
+     */
+    async createConnection(name, config) {
+        if (this.connections.has(name)) {
+            throw new Error(`Connection "${name}" already exists`);
+        }
+
+        const connection = mysql.createConnection(config);
+        await connection.promise().connect();
+        this.connections.set(name, connection);
+        return connection;
+    }
+
+    /**
+     * Get an existing connection
+     * @param {string} name - Connection name/identifier
+     * @returns {import('mysql2').Connection|undefined}
+     */
+    getConnection(name) {
+        return this.connections.get(name);
+    }
+
+    /**
+     * Close a specific connection
+     * @param {string} name - Connection name/identifier
+     * @returns {Promise<void>}
+     */
+    async closeConnection(name) {
+        const connection = this.connections.get(name);
+        if (connection) {
+            await connection.promise().end();
+            this.connections.delete(name);
+        }
+    }
+
+    /**
+     * Close all connections
+     * @returns {Promise<void>}
+     */
+    async closeAll() {
+        const closePromises = [];
+        for (const [name, connection] of this.connections.entries()) {
+            closePromises.push(
+                connection.promise().end().catch((err) => {
+                    console.warn(`Warning: Error closing connection "${name}": ${err.message}`);
+                })
+            );
+        }
+        await Promise.all(closePromises);
+        this.connections.clear();
+    }
+
+    /**
+     * Execute a callback with automatic connection cleanup
+     * @template T
+     * @param {string} name - Connection name/identifier
+     * @param {import('mysql2').ConnectionOptions} config - Database configuration
+     * @param {(connection: import('mysql2').Connection) => Promise<T>} callback - Function to execute with the connection
+     * @returns {Promise<T>}
+     */
+    async withConnection(name, config, callback) {
+        const connection = await this.createConnection(name, config);
+        try {
+            return await callback(connection);
+        } finally {
+            await this.closeConnection(name);
+        }
+    }
+
+    /**
+     * Execute a callback with automatic cleanup of all connections
+     * @template T
+     * @param {() => Promise<T>} callback - Function to execute
+     * @returns {Promise<T>}
+     */
+    async withCleanup(callback) {
+        try {
+            return await callback();
+        } finally {
+            await this.closeAll();
+        }
+    }
+}
+
+module.exports = ConnectionManager;

package/src/utils/functions.js

@@ -1,3 +1,8 @@
+/**
+ * Check if the migrations table exists in the current database.
+ * @param {import('mysql2').Connection} connection - Active MySQL connection.
+ * @returns {Promise<boolean>} True if the table exists, false if it needs to be created.
+ */
 async function checkTableMigrations(connection) {
     try {
         await connection.promise().query("SELECT `id` FROM `migrations` LIMIT 1;");
@@ -7,7 +12,12 @@ async function checkTableMigrations(connection) {
         throw error;
     }
 }
-//---------------------------------------
+
+/**
+ * Create the migrations table.
+ * @param {import('mysql2').Connection} connection - Active MySQL connection.
+ * @returns {Promise<boolean>} Resolves true when the table has been created.
+ */
 async function createTableMigrations(connection) {
     const query =
         "CREATE TABLE `migrations` (\
@@ -19,7 +29,13 @@ async function createTableMigrations(connection) {
     await connection.promise().query(query);
     return true;
 }
-//---------------------------------------
+
+/**
+ * Retrieve migrations optionally filtered by batch.
+ * @param {import('mysql2').Connection} connection - Active MySQL connection.
+ * @param {number|null} batch - Minimum batch number (exclusive) to filter results.
+ * @returns {Promise<Array<{migration: string}>>} List of migrations.
+ */
 async function getAllMigrations(connection, batch = null) {
     let query = "SELECT `migration` FROM `migrations`";
     const params = [];
@@ -30,31 +46,98 @@ async function getAllMigrations(connection, batch = null) {
     const [results] = await connection.promise().query(`${query};`, params);
     return Array.isArray(results) ? results : [];
 }
-//---------------------------------------
+
+/**
+ * Get the latest batch number applied to the database.
+ * @param {import('mysql2').Connection} connection - Active MySQL connection.
+ * @returns {Promise<number>} Highest batch number or 0 if none exist.
+ */
 async function getCurrentBatch(connection) {
     const [results] = await connection
         .promise()
         .query("SELECT `batch` FROM `migrations` ORDER BY `batch` DESC LIMIT 1;");
     return Array.isArray(results) && results.length > 0 ? results[0].batch : 0;
 }
-//---------------------------------------
+
+/**
+ * Record a migration as executed.
+ * @param {import('mysql2').Connection} connection - Active MySQL connection.
+ * @param {string} migration - Migration identifier.
+ * @param {number} batch - Batch number the migration belongs to.
+ * @returns {Promise<boolean>} Resolves true after insertion.
+ */
 async function insertMigration(connection, migration, batch) {
     const query = "INSERT INTO `migrations` (`migration`, `batch`) VALUES (?, ?);";
     await connection.promise().query(query, [migration, batch]);
     return true;
 }
-//---------------------------------------
+
+/**
+ * Remove a migration entry above the provided batch.
+ * @param {import('mysql2').Connection} connection - Active MySQL connection.
+ * @param {string} migration - Migration identifier to delete.
+ * @param {number} batch - Batch threshold; deletes records with batch greater than this value.
+ * @returns {Promise<boolean>} Resolves true after deletion.
+ */
 async function deleteMigration(connection, migration, batch) {
     const query = "DELETE FROM `migrations` WHERE `migration` = ? AND `batch` > ?;";
     await connection.promise().query(query, [migration, batch]);
     return true;
 }
-//---------------------------------------
+
+/**
+ * Retrieve all stored batches with their migrations.
+ * @param {import('mysql2').Connection} connection - Active MySQL connection.
+ * @returns {Promise<Array<{batch: number, migration: string}>>} List of batches and their migrations.
+ */
 async function getAllBatches(connection) {
     const [results] = await connection.promise().query("SELECT `batch`, `migration` FROM `migrations`;");
     return Array.isArray(results) ? results : [];
 }
-//---------------------------------------
+
+/**
+ * Begin a transaction
+ * @param {import('mysql2').Connection} connection
+ */
+async function beginTransaction(connection) {
+    await connection.promise().query("START TRANSACTION");
+}
+
+/**
+ * Commit a transaction
+ * @param {import('mysql2').Connection} connection
+ */
+async function commitTransaction(connection) {
+    await connection.promise().query("COMMIT");
+}
+
+/**
+ * Rollback a transaction
+ * @param {import('mysql2').Connection} connection
+ */
+async function rollbackTransaction(connection) {
+    await connection.promise().query("ROLLBACK");
+}
+
+/**
+ * Execute a callback within a transaction
+ * @template T
+ * @param {import('mysql2').Connection} connection
+ * @param {(connection: import('mysql2').Connection) => Promise<T>} callback
+ * @returns {Promise<T>}
+ */
+async function withTransaction(connection, callback) {
+    await beginTransaction(connection);
+    try {
+        const result = await callback(connection);
+        await commitTransaction(connection);
+        return result;
+    } catch (error) {
+        await rollbackTransaction(connection);
+        throw error;
+    }
+}
+
 module.exports = {
     checkTableMigrations,
     createTableMigrations,
@@ -63,4 +146,8 @@ module.exports = {
     insertMigration,
     deleteMigration,
     getAllBatches,
+    beginTransaction,
+    commitTransaction,
+    rollbackTransaction,
+    withTransaction,
 };

package/src/utils/moduleLoader.js

@@ -1,4 +1,3 @@
-const path = require("path");
 const { pathToFileURL } = require("url");
 
 /**

package/.prettierrc.json

@@ -1,10 +0,0 @@
-{
-    "semi": true,
-    "singleQuote": false,
-    "tabWidth": 4,
-    "useTabs": false,
-    "trailingComma": "es5",
-    "printWidth": 120,
-    "arrowParens": "always",
-    "endOfLine": "lf"
-}