mysql-memory-server 1.4.1 → 1.4.3

package/README.md

@@ -13,15 +13,20 @@ Download with your package manager of choice. The package name is `mysql-memory-
 - Node.js 16.6.0 and newer
 - macOS 13+, Windows, or Linux (This package is only tested on Ubuntu 20.04, 22.04, 24.04, and Fedora 40. Other Linux distributions may or may not work at this time.)
 
-Windows only requirements:
+#### Requirements for downloaded MySQL versions
+
+The following requirements only apply if you intend to have `mysql-memory-server` download a version of MySQL to use instead of using an already installed version of MySQL on the system:
+
+Requirements for Windows:
 - `Microsoft Visual C++ 2019 Redistributable Package` needs to be installed
 
-Linux only requirements:
+Requirements for Linux:
 - The `libaio1` or `libaio1t64` package needs to be installed
 - If `libaio1` is not available but `libaio1t64` is, the `ldconfig` command needs to be available to run
-- The `tar` package needs to be installed if you want to use MySQL versions that aren't system installed
+- The `tar` package needs to be installed
+
+#### Currently supported MySQL versions
 
-Currently supported MySQL versions:
 - If using the system installed MySQL server: 8.0.20 and newer
 - If not using the system installed MySQL server: 8.0.39, 8.1.0, 8.2.0, 8.3.0, 8.4.2, 9.0.1
 
@@ -31,15 +36,26 @@ Currently supported MySQL versions:
 import { createDB } from 'mysql-memory-server';
 import sql from 'mysql2/promise'
 
-// Create a new database
+// Create a new database with default options
 const db = await createDB()
 
+//OR
+
+//Create a new database with custom options set
+const db = await createDB({
+        // see Options for the options you can use in this object and their default values
+        // for example:
+        version: '8.4.x'
+})
+
 // Connect to the new database with the port provided
+// The database is initialized with an empty password so use an empty string for the password
 const connection = await sql.createConnection({
         host: '127.0.0.1',
         user: db.username,
         port: db.port,
-        database: db.dbName
+        database: db.dbName,
+        password: ''
 })
 
 // Run your queries here
@@ -52,6 +68,9 @@ await connection.end()
 await db.stop()
 ```
 
+MySQL database initialization can take some time. If you run into a "Timeout exceeded" error with your tests, the timeout should be extended.
+If using Jest, information about how to do this can be found here: https://jestjs.io/docs/jest-object#jestsettimeouttimeout
+
 ## Documentation
 
 ##### `createDB(options: ServerOptions): Promise<MySQLDB>`
@@ -167,22 +186,31 @@ Default: false
 
 Description: This option only applies if the system-installed MySQL version is lower than the oldest supported MySQL version for this package (8.0.20) and the `version` option is not defined. If set to `true`, this package will use the latest version of MySQL instead of the system-installed version. If `false`, the package will throw an error.
 
+***
+### :warning: Internal Options :warning:
+
+The following options are only meant for internal debugging use. Their behaviour may change or they may get removed between major/minor/patch versions and they are not to be considered stable. The options below will not follow Semantic Versioning so it is advised to not use them.
+
 - `deleteDBAfterStopped: boolean`
 
 Required: No
 
 Default: true
 
-Gotchas: This option is intended to be for internal debugging purposes only and not meant for people to use. As such, this option will not follow Semantic Versioning.
-
 Description: Changes whether or not the database will be deleted after it has been stopped. If set to `true`, the database WILL be deleted after it has been stopped.
 
 - `dataPath: string`
 
 Required: No
 
-Default: `TMPDIR/mysqlmsn/dbs/UUID` (replacing TMPDIR with the OS temp directory and UUID with a UUIDv4 without seperating dashes)
-
-Gotchas: This option is intended to be for internal debugging purposes only and not meant for people to use. As such, this option will not follow Semantic Versioning.
+Default: `TMPDIR/mysqlmsn/dbs/UUID` (replacing TMPDIR with the OS temp directory and UUID with a UUIDv4 without seperating dashes).
 
 Description: The folder to store database-related data in
+
+- `binaryDirectoryPath: string`
+
+Required: No
+
+Default: `TMPDIR/mysqlmsn/binaries` (replacing TMPDIR with the OS temp directory)
+
+Description: The folder to store the MySQL binaries when they are downloaded from the CDN.

package/dist/src/index.js

@@ -51,7 +51,8 @@ async function createDB(opts) {
         dbPath: (0, path_1.normalize)(`${os.tmpdir()}/mysqlmsn/dbs/${(0, crypto_1.randomUUID)().replace(/-/g, '')}`),
         ignoreUnsupportedSystemVersion: false,
         port: 0,
-        xPort: 0
+        xPort: 0,
+        binaryDirectoryPath: `${os.tmpdir()}/mysqlmsn/binaries`
     };
     const options = { ...defaultOptions, ...opts };
     const logger = new Logger_1.default(options.logLevel);
@@ -73,7 +74,7 @@ async function createDB(opts) {
         let binaryFilepath;
         try {
             binaryInfo = (0, Version_1.default)(versions_json_1.default, options.version);
-            logger.log('Downloading binary:', binaryInfo.version, 'from URL:', binaryInfo.url);
+            logger.log('Using MySQL binary version:', binaryInfo.version, 'from URL:', binaryInfo.url);
         }
         catch (e) {
             logger.error(e);

package/dist/src/libraries/Downloader.js

@@ -31,7 +31,6 @@ exports.downloadBinary = downloadBinary;
 const https = __importStar(require("https"));
 const fs = __importStar(require("fs"));
 const fsPromises = __importStar(require("fs/promises"));
-const os = __importStar(require("os"));
 const adm_zip_1 = __importDefault(require("adm-zip"));
 const path_1 = require("path");
 const crypto_1 = require("crypto");
@@ -52,7 +51,7 @@ function getZipData(entry) {
 }
 function handleTarExtraction(filepath, extractedPath) {
     return new Promise((resolve, reject) => {
-        (0, child_process_1.exec)(`tar -xf ${filepath} -C ${extractedPath}`, (error, stdout, stderr) => {
+        (0, child_process_1.execFile)(`tar`, ['-xf', filepath, '-C', extractedPath], (error, stdout, stderr) => {
             if (error || stderr) {
                 return reject(error || stderr);
             }
@@ -86,9 +85,13 @@ function downloadFromCDN(url, downloadLocation, logger) {
             request.on('error', (err) => {
                 error = err;
                 logger.error(err);
-                fileStream.close();
-                fs.unlink(downloadLocation, () => {
-                    reject(err.message);
+                fileStream.end(() => {
+                    fs.unlink(downloadLocation, (unlinkError) => {
+                        if (unlinkError) {
+                            logger.error('An error occurred while deleting downloadLocation after an error occurred with the MySQL server binary download. The error was:', unlinkError);
+                        }
+                        reject(err.message);
+                    });
                 });
             });
         });
@@ -100,9 +103,13 @@ function downloadFromCDN(url, downloadLocation, logger) {
         fileStream.on('error', (err) => {
             error = err;
             logger.error(err);
-            fileStream.end();
-            fs.unlink(downloadLocation, () => {
-                reject(err.message);
+            fileStream.end(() => {
+                fs.unlink(downloadLocation, (unlinkError) => {
+                    if (unlinkError) {
+                        logger.error('An error occurred while deleting downloadLocation after an error occurred with the fileStream. The error was:', unlinkError);
+                    }
+                    reject(err.message);
+                });
             });
         });
     });
@@ -167,59 +174,73 @@ function extractBinary(url, archiveLocation, extractedLocation, logger) {
 function downloadBinary(binaryInfo, options, logger) {
     return new Promise(async (resolve, reject) => {
         const { url, version } = binaryInfo;
-        const dirpath = `${os.tmpdir()}/mysqlmsn/binaries`;
+        const dirpath = options.binaryDirectoryPath;
         logger.log('Binary path:', dirpath);
         await fsPromises.mkdir(dirpath, { recursive: true });
         const lastDashIndex = url.lastIndexOf('-');
         const fileExtension = url.slice(lastDashIndex).split('.').splice(1).join('.');
         if (options.downloadBinaryOnce) {
             const extractedPath = `${dirpath}/${version}`;
-            await fsPromises.mkdir(extractedPath, { recursive: true });
             const binaryPath = (0, path_1.normalize)(`${extractedPath}/mysql/bin/mysqld${process.platform === 'win32' ? '.exe' : ''}`);
             const archivePath = `${dirpath}/${version}.${fileExtension}`;
             const binaryExists = fs.existsSync(binaryPath);
             if (binaryExists) {
                 return resolve(binaryPath);
             }
-            let lockedByUs = false;
-            try {
-                (0, proper_lockfile_1.lockSync)(extractedPath);
-                lockedByUs = true;
-                await downloadFromCDN(url, archivePath, logger);
-                await extractBinary(url, archivePath, extractedPath, logger);
+            let releaseFunction;
+            while (true) {
                 try {
-                    (0, proper_lockfile_1.unlockSync)(extractedPath);
+                    await fsPromises.mkdir(extractedPath, { recursive: true });
+                    releaseFunction = (0, proper_lockfile_1.lockSync)(extractedPath);
+                    break;
                 }
                 catch (e) {
+                    if (e.code === 'ELOCKED') {
+                        logger.log('Waiting for lock for MySQL version', version);
+                        await (0, FileLock_1.waitForLock)(extractedPath, options);
+                        logger.log('Lock is gone for version', version);
+                        //If the binary does not exist after lock has been released (like if the download fails and the binary got deleted as a result)
+                        //then the lock acquisition process should start again
+                        const binaryExists = fs.existsSync(binaryPath);
+                        if (!binaryExists)
+                            continue;
+                        return resolve(binaryPath);
+                    }
                     return reject(e);
                 }
-                return resolve(binaryPath);
+            }
+            //The code below only runs if the lock has been acquired by us
+            try {
+                await downloadFromCDN(url, archivePath, logger);
+                await extractBinary(url, archivePath, extractedPath, logger);
             }
             catch (e) {
-                if (String(e).includes('Lock file is already being held')) {
-                    logger.log('Waiting for lock for MySQL version', version);
-                    await (0, FileLock_1.waitForLock)(extractedPath, options);
-                    logger.log('Lock is gone for version', version);
-                    return resolve(binaryPath);
+                try {
+                    await Promise.all([
+                        fsPromises.rm(extractedPath, { force: true, recursive: true }),
+                        fsPromises.rm(archivePath, { force: true, recursive: true })
+                    ]);
                 }
-                if (lockedByUs) {
+                catch (e) {
+                    logger.error('An error occurred while deleting extractedPath and/or archivePath:', e);
+                }
+                finally {
                     try {
-                        await Promise.all([
-                            fsPromises.rm(extractedPath, { force: true, recursive: true }),
-                            fsPromises.rm(archivePath, { force: true, recursive: true })
-                        ]);
+                        releaseFunction();
                     }
-                    finally {
-                        try {
-                            (0, proper_lockfile_1.unlockSync)(extractedPath, { realpath: false });
-                        }
-                        catch (e) {
-                            logger.error('An error occurred while unlocking path:', e);
-                        }
+                    catch (e) {
+                        logger.error('An error occurred while unlocking path:', e);
                     }
+                    return reject(e);
                 }
+            }
+            try {
+                releaseFunction();
+            }
+            catch (e) {
                 return reject(e);
             }
+            return resolve(binaryPath);
         }
         const uuid = (0, crypto_1.randomUUID)();
         const zipFilepath = `${dirpath}/${uuid}.${fileExtension}`;

package/dist/src/libraries/Executor.js

@@ -30,7 +30,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _Executor_instances, _Executor_execute, _Executor_executeFile, _Executor_killProcess, _Executor_startMySQLProcess, _Executor_setupDataDirectories;
+var _Executor_instances, _Executor_executeFile, _Executor_killProcess, _Executor_startMySQLProcess, _Executor_setupDataDirectories;
 Object.defineProperty(exports, "__esModule", { value: true });
 const child_process_1 = require("child_process");
 const semver_1 = require("semver");
@@ -83,7 +83,7 @@ class Executor {
                     const versions = [];
                     for (const dir of servers) {
                         const path = `${process.env.PROGRAMFILES}\\MySQL\\${dir}\\bin\\mysqld`;
-                        const { error, stdout, stderr } = await __classPrivateFieldGet(this, _Executor_instances, "m", _Executor_execute).call(this, `"${path}" --version`);
+                        const { error, stdout, stderr } = await __classPrivateFieldGet(this, _Executor_instances, "m", _Executor_executeFile).call(this, path, ['--version']);
                         if (error || stderr) {
                             return reject(error || stderr);
                         }
@@ -110,8 +110,8 @@ class Executor {
                 }
             }
             else {
-                const { error, stdout, stderr } = await __classPrivateFieldGet(this, _Executor_instances, "m", _Executor_execute).call(this, 'mysqld --version');
-                if (stderr && stderr.includes('not found')) {
+                const { error, stdout, stderr } = await __classPrivateFieldGet(this, _Executor_instances, "m", _Executor_executeFile).call(this, 'mysqld', ['--version']);
+                if (error && error.code === 'ENOENT') {
                     resolve(null);
                 }
                 else if (error || stderr) {
@@ -161,22 +161,16 @@ class Executor {
         } while (retries <= options.portRetries);
     }
 }
-_Executor_instances = new WeakSet(), _Executor_execute = function _Executor_execute(command) {
+_Executor_instances = new WeakSet(), _Executor_executeFile = function _Executor_executeFile(command, args) {
     return new Promise(resolve => {
-        (0, child_process_1.exec)(command, { signal: AbortSignal_1.default.signal }, (error, stdout, stderr) => {
+        (0, child_process_1.execFile)(command, args, { signal: AbortSignal_1.default.signal }, (error, stdout, stderr) => {
             resolve({ error, stdout, stderr });
         });
     });
-}, _Executor_executeFile = function _Executor_executeFile(command, args, cwd) {
-    return new Promise(resolve => {
-        (0, child_process_1.execFile)(command, args, { signal: AbortSignal_1.default.signal, cwd }, (error, stdout, stderr) => {
-            resolve({ stdout, stderr: (error === null || error === void 0 ? void 0 : error.message) || stderr });
-        });
-    });
 }, _Executor_killProcess = async function _Executor_killProcess(process) {
     let killed = false;
     if (os.platform() === 'win32') {
-        const { error, stderr } = await __classPrivateFieldGet(this, _Executor_instances, "m", _Executor_execute).call(this, `taskkill /pid ${process.pid} /t /f`);
+        const { error, stderr } = await __classPrivateFieldGet(this, _Executor_instances, "m", _Executor_executeFile).call(this, 'taskkill', ['/pid', String(process.pid), '/t', '/f']);
         if (!error && !stderr) {
             killed = true;
         }
@@ -310,7 +304,7 @@ _Executor_instances = new WeakSet(), _Executor_execute = function _Executor_exec
     await fsPromises.mkdir(datadir, { recursive: true });
     let stderr;
     if (binaryFilepath === 'mysqld') {
-        const { error, stderr: output } = await __classPrivateFieldGet(this, _Executor_instances, "m", _Executor_execute).call(this, `mysqld --no-defaults --datadir=${datadir} --initialize-insecure`);
+        const { error, stderr: output } = await __classPrivateFieldGet(this, _Executor_instances, "m", _Executor_executeFile).call(this, 'mysqld', ['--no-defaults', `--datadir=${datadir}`, '--initialize-insecure']);
         stderr = output;
         if (error) {
             this.logger.error('An error occurred while initializing database with system-installed MySQL:', error);
@@ -320,7 +314,7 @@ _Executor_instances = new WeakSet(), _Executor_execute = function _Executor_exec
     else {
         let result;
         try {
-            result = await __classPrivateFieldGet(this, _Executor_instances, "m", _Executor_executeFile).call(this, `${binaryFilepath}`, [`--no-defaults`, `--datadir=${datadir}`, `--initialize-insecure`], (0, path_1.resolve)(`${binaryFilepath}/..`));
+            result = await __classPrivateFieldGet(this, _Executor_instances, "m", _Executor_executeFile).call(this, `${binaryFilepath}`, [`--no-defaults`, `--datadir=${datadir}`, `--initialize-insecure`]);
         }
         catch (e) {
             this.logger.error('Error occurred from executeFile:', e);
@@ -342,7 +336,7 @@ _Executor_instances = new WeakSet(), _Executor_execute = function _Executor_exec
                 throw 'Tried to copy libaio into lib folder and MySQL is still failing to initialize. Please check the console for more information.';
             }
             if (binaryFilepath.slice(-16) === 'mysql/bin/mysqld') {
-                const { error: lderror, stdout, stderr: ldstderr } = await __classPrivateFieldGet(this, _Executor_instances, "m", _Executor_execute).call(this, 'ldconfig -p');
+                const { error: lderror, stdout, stderr: ldstderr } = await __classPrivateFieldGet(this, _Executor_instances, "m", _Executor_executeFile).call(this, 'ldconfig', ['-p']);
                 if (lderror || ldstderr) {
                     this.logger.error('The following libaio error occurred:', stderr);
                     this.logger.error('After the libaio error, an ldconfig error occurred:', lderror || ldstderr);
@@ -358,8 +352,34 @@ _Executor_instances = new WeakSet(), _Executor_execute = function _Executor_exec
                 const libaioSymlinkPath = libaioEntry.slice(libaioPathIndex + 3);
                 const libaioPath = await fsPromises.realpath(libaioSymlinkPath);
                 const copyPath = (0, path_1.resolve)(`${binaryFilepath}/../../lib/private/libaio.so.1`);
-                try {
-                    (0, proper_lockfile_1.lockSync)(copyPath, { realpath: false });
+                let lockRelease;
+                while (true) {
+                    try {
+                        lockRelease = (0, proper_lockfile_1.lockSync)(copyPath, { realpath: false });
+                        break;
+                    }
+                    catch (e) {
+                        if (e.code === 'ELOCKED') {
+                            this.logger.log('Waiting for lock for libaio copy');
+                            await (0, FileLock_1.waitForLock)(copyPath, options);
+                            this.logger.log('Lock is gone for libaio copy');
+                            //If libaio does not exist after the lock has been released (like if the copy fails)
+                            //then the lock acquisition process should start again
+                            const binaryExists = fs.existsSync(copyPath);
+                            if (!binaryExists)
+                                continue;
+                            break;
+                        }
+                        else {
+                            this.logger.error('An error occurred from locking libaio section:', e);
+                            throw e;
+                        }
+                    }
+                }
+                if (lockRelease) {
+                    //This code will only run if the lock has been acquired successfully.
+                    //If the lock was already acquired by some other process, this process would have already waited for the lock, so no copying needs to be done since it's already happened.
+                    //If the lock failed to acquire for some other reason, the error would've already been thrown.
                     this.logger.log('libaio copy path:', copyPath, '| libaio symlink path:', libaioSymlinkPath, '| libaio actual path:', libaioPath);
                     let copyError;
                     try {
@@ -377,7 +397,7 @@ _Executor_instances = new WeakSet(), _Executor_execute = function _Executor_exec
                     }
                     finally {
                         try {
-                            (0, proper_lockfile_1.unlockSync)(copyPath, { realpath: false });
+                            lockRelease();
                         }
                         catch (e) {
                             this.logger.error('Error unlocking libaio file:', e);
@@ -392,15 +412,6 @@ _Executor_instances = new WeakSet(), _Executor_execute = function _Executor_exec
                         return;
                     }
                 }
-                catch (error) {
-                    if (String(error) === 'Error: Lock file is already being held') {
-                        this.logger.log('Waiting for lock for libaio copy');
-                        await (0, FileLock_1.waitForLock)(copyPath, options);
-                        this.logger.log('Lock is gone for libaio copy');
-                    }
-                    this.logger.error('An error occurred from locking libaio section:', error);
-                    throw error;
-                }
             }
             else {
                 throw 'Cannot recognize file structure for the MySQL binary folder. This was caused by not being able to find libaio. Try installing libaio. Learn more at https://dev.mysql.com/doc/refman/en/binary-installation.html';

package/dist/src/libraries/FileLock.js

@@ -8,7 +8,7 @@ function waitForLock(path, options) {
         while (retries <= options.lockRetries) {
             retries++;
             try {
-                const locked = (0, proper_lockfile_1.checkSync)(path);
+                const locked = (0, proper_lockfile_1.checkSync)(path, { realpath: false });
                 if (!locked) {
                     return resolve();
                 }

package/dist/src/libraries/Logger.js

@@ -11,17 +11,17 @@ class Logger {
     }
     log(...args) {
         if (this.LOG_LEVEL === 0) {
-            console.log(...args);
+            console.log('[mysql-memory-server - LOG]:', ...args);
         }
     }
     warn(...args) {
         if (this.LOG_LEVEL <= 1) {
-            console.warn(...args);
+            console.warn('[mysql-memory-server - WARN]:', ...args);
         }
     }
     error(...args) {
         if (this.LOG_LEVEL <= 2) {
-            console.error(...args);
+            console.error('[mysql-memory-server - ERROR]:', ...args);
         }
     }
 }

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-import { ExecException } from "child_process";
+import { ExecFileException } from "child_process";
 export type LOG_LEVEL = 'LOG' | 'WARN' | 'ERROR';
 export type ServerOptions = {
     version?: string;
@@ -14,6 +14,7 @@ export type ServerOptions = {
     ignoreUnsupportedSystemVersion?: boolean;
     port?: number;
     xPort?: number;
+    binaryDirectoryPath?: string;
 };
 export type InternalServerOptions = {
     version?: string;
@@ -29,12 +30,13 @@ export type InternalServerOptions = {
     ignoreUnsupportedSystemVersion: boolean;
     port: number;
     xPort: number;
+    binaryDirectoryPath: string;
 };
 export type ExecutorOptions = {
     logLevel: LOG_LEVEL;
 };
-export type ExecuteReturn = {
-    error: ExecException | null;
+export type ExecuteFileReturn = {
+    error: ExecFileException | null;
     stdout: string;
     stderr: string;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mysql-memory-server",
-  "version": "1.4.1",
+  "version": "1.4.3",
   "description": "Spin up an ephemeral MySQL database from your JavaScript code",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -20,6 +20,9 @@
     "test:ci": "jest --testPathIgnorePatterns=/stress-tests/ --setupFilesAfterEnv ./ciSetup.js --verbose",
     "stress": "jest --runTestsByPath stress-tests/stress.test.ts --setupFilesAfterEnv ./ciSetup.js --verbose"
   },
+  "engines": {
+    "node": ">=16.6.0"
+  },
   "author": "Sebastian-Webster",
   "license": "MIT",
   "devDependencies": {
@@ -27,16 +30,16 @@
     "@babel/preset-env": "^7.25.4",
     "@babel/preset-typescript": "^7.24.7",
     "@types/adm-zip": "^0.5.5",
-    "@types/node": "^22.5.0",
+    "@types/node": "^22.5.4",
     "@types/proper-lockfile": "^4.1.4",
     "@types/semver": "^7.5.8",
     "babel-jest": "^29.7.0",
     "jest": "^29.7.0",
-    "mysql2": "^3.10.3",
-    "typescript": "^5.5.4"
+    "mysql2": "^3.11.2",
+    "typescript": "^5.6.2"
   },
   "dependencies": {
-    "adm-zip": "^0.5.15",
+    "adm-zip": "^0.5.16",
     "proper-lockfile": "^4.1.2",
     "semver": "^7.6.3"
   },