mysql-memory-server 1.4.2 → 1.5.0

package/README.md

@@ -10,7 +10,7 @@ Download with your package manager of choice. The package name is `mysql-memory-
 
 #### Requirements
 
-- Node.js 16.6.0 and newer
+- Node.js >=16.6.0 or Bun >= 1.0.0
 - 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.)
 
 #### Requirements for downloaded MySQL versions
@@ -54,7 +54,7 @@ const connection = await sql.createConnection({
         host: '127.0.0.1',
         user: db.username,
         port: db.port,
-        database: db.dbName
+        database: db.dbName,
         password: ''
 })
 
@@ -186,22 +186,39 @@ 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.
 
+- `downloadRetries: number`
+
+Required: No
+
+Default: 3
+
+Description: The number of times to try to download a MySQL binary before giving up and rejecting the `createDB()` promise.
+
+***
+### :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,9 @@ 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`,
+        downloadRetries: 10
     };
     const options = { ...defaultOptions, ...opts };
     const logger = new Logger_1.default(options.logLevel);
@@ -73,7 +75,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);
             }
@@ -76,39 +75,71 @@ function downloadVersions() {
     });
 }
 function downloadFromCDN(url, downloadLocation, logger) {
-    return new Promise((resolve, reject) => {
+    return new Promise(async (resolve, reject) => {
+        if (fs.existsSync(downloadLocation)) {
+            logger.warn('Removing item at downloadLocation:', downloadLocation, 'so the MySQL binary archive can be stored there. This is probably because a previous download/extraction failed.');
+            await fsPromises.rm(downloadLocation, { recursive: true, force: true });
+        }
         const fileStream = fs.createWriteStream(downloadLocation);
         let error;
         fileStream.on('open', () => {
             const request = https.get(url, (response) => {
-                response.pipe(fileStream);
+                if (response.statusCode !== 200) {
+                    fileStream.close((err) => {
+                        if (err) {
+                            logger.error('An error occurred while closing the fileStream for non-200 status code. The error was:', err);
+                        }
+                        fs.unlink(downloadLocation, (unlinkErr) => {
+                            if (unlinkErr) {
+                                logger.error('An error occurred while deleting downloadLocation after non-200 status code download attempt. The error was:', err);
+                            }
+                            logger.error('Received status code:', response.statusCode, 'while downloading MySQL binary.');
+                            reject(`Received status code ${response.statusCode} while downloading MySQL binary.`);
+                        });
+                    });
+                }
+                else {
+                    response.pipe(fileStream);
+                    fileStream.on('finish', () => {
+                        if (!error) {
+                            resolve();
+                        }
+                    });
+                }
             });
             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);
+                    });
                 });
             });
         });
-        fileStream.on('finish', () => {
-            if (!error) {
-                resolve();
-            }
-        });
         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);
+                });
             });
         });
     });
 }
 function extractBinary(url, archiveLocation, extractedLocation, logger) {
     return new Promise(async (resolve, reject) => {
+        if (fs.existsSync(extractedLocation)) {
+            logger.warn('Removing item at extractedLocation:', extractedLocation, 'so the MySQL binary can be stored there. This is probably because a previous download/extraction failed.');
+            await fsPromises.rm(extractedLocation, { recursive: true, force: true });
+        }
         const lastDashIndex = url.lastIndexOf('-');
         const fileExtension = url.slice(lastDashIndex).split('.').splice(1).join('.');
         await fsPromises.mkdir(extractedLocation, { recursive: true });
@@ -160,83 +191,125 @@ function extractBinary(url, archiveLocation, extractedLocation, logger) {
                 resolve(`${extractedLocation}/mysql/bin/mysqld`);
             }
         }).catch(error => {
-            reject(`An error occurred while extracting the tar file. Please make sure tar is installed and there is enough storage space for the extraction. The error was: ${error}`);
+            logger.error(`An error occurred while extracting the tar file. Please make sure tar is installed and there is enough storage space for the extraction. The error was: ${error}`);
+            reject(error);
         });
     });
 }
 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);
+                    releaseFunction = (0, proper_lockfile_1.lockSync)(extractedPath, { realpath: false });
+                    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);
             }
-            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);
+            //The code below only runs if the lock has been acquired by us
+            let downloadTries = 0;
+            do {
+                try {
+                    downloadTries++;
+                    await downloadFromCDN(url, archivePath, logger);
+                    await extractBinary(url, archivePath, extractedPath, logger);
+                    break;
                 }
-                if (lockedByUs) {
+                catch (e) {
+                    //Delete generated files since either download or extraction failed
                     try {
                         await Promise.all([
                             fsPromises.rm(extractedPath, { force: true, recursive: true }),
                             fsPromises.rm(archivePath, { force: true, recursive: true })
                         ]);
                     }
-                    finally {
+                    catch (e) {
+                        logger.error('An error occurred while deleting extractedPath and/or archivePath:', e);
+                    }
+                    if (downloadTries >= options.downloadRetries) {
+                        //Only reject if we have met the downloadRetries limit
                         try {
-                            (0, proper_lockfile_1.unlockSync)(extractedPath, { realpath: false });
+                            releaseFunction();
                         }
                         catch (e) {
-                            logger.error('An error occurred while unlocking path:', e);
+                            logger.error('An error occurred while releasing lock after downloadRetries exhaustion. The error was:', e);
                         }
+                        logger.error('downloadRetries have been exceeded. Aborting download.');
+                        return reject(e);
+                    }
+                    else {
+                        console.warn(`An error was encountered during the binary download process. Retrying for retry ${downloadTries}/${options.downloadRetries}. The error was:`, e);
                     }
                 }
-                return reject(e);
+            } while (downloadTries < options.downloadRetries);
+            try {
+                releaseFunction();
             }
+            catch (e) {
+                logger.error('An error occurred while releasing lock after successful binary download. The error was:', e);
+            }
+            return resolve(binaryPath);
         }
-        const uuid = (0, crypto_1.randomUUID)();
-        const zipFilepath = `${dirpath}/${uuid}.${fileExtension}`;
-        logger.log('Binary filepath:', zipFilepath);
-        const extractedPath = `${dirpath}/${uuid}`;
-        try {
-            await downloadFromCDN(url, zipFilepath, logger);
-        }
-        catch (e) {
-            reject(e);
-        }
-        try {
-            const binaryPath = await extractBinary(url, zipFilepath, extractedPath, logger);
-            resolve(binaryPath);
-        }
-        catch (e) {
-            reject(e);
+        else {
+            let downloadTries = 0;
+            do {
+                const uuid = (0, crypto_1.randomUUID)();
+                const zipFilepath = `${dirpath}/${uuid}.${fileExtension}`;
+                logger.log('Binary filepath:', zipFilepath);
+                const extractedPath = `${dirpath}/${uuid}`;
+                try {
+                    downloadTries++;
+                    await downloadFromCDN(url, zipFilepath, logger);
+                    const binaryPath = await extractBinary(url, zipFilepath, extractedPath, logger);
+                    return resolve(binaryPath);
+                }
+                catch (e) {
+                    //Delete generated files since either download or extraction failed
+                    try {
+                        await Promise.all([
+                            fsPromises.rm(extractedPath, { force: true, recursive: true }),
+                            fsPromises.rm(zipFilepath, { force: true, recursive: true })
+                        ]);
+                    }
+                    catch (e) {
+                        logger.error('An error occurred while deleting extractedPath and/or archivePath:', e);
+                    }
+                    if (downloadTries >= options.downloadRetries) {
+                        //Only reject if we have met the downloadRetries limit
+                        return reject(e);
+                    }
+                    else {
+                        console.warn(`An error was encountered during the binary download process. Retrying for retry ${downloadTries}/${options.downloadRetries}. The error was:`, e);
+                    }
+                }
+            } while (downloadTries < options.downloadRetries);
         }
     });
 }

package/dist/src/libraries/Executor.d.ts

@@ -4,7 +4,6 @@ declare class Executor {
     #private;
     logger: Logger;
     constructor(logger: Logger);
-    deleteDatabaseDirectory(path: string): Promise<void>;
     getMySQLVersion(preferredVersion?: string): Promise<InstalledMySQLVersion | null>;
     startMySQL(options: InternalServerOptions, binaryFilepath: string): Promise<MySQLDB>;
 }

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_deleteDatabaseDirectory, _Executor_startMySQLProcess, _Executor_setupDataDirectories;
 Object.defineProperty(exports, "__esModule", { value: true });
 const child_process_1 = require("child_process");
 const semver_1 = require("semver");
@@ -47,29 +47,6 @@ class Executor {
         _Executor_instances.add(this);
         this.logger = logger;
     }
-    async deleteDatabaseDirectory(path) {
-        let retries = 0;
-        //Maximum wait of 10 seconds | 500ms * 20 retries = 10,000ms = 10 seconds
-        const waitTime = 500;
-        const maxRetries = 20;
-        //Since the database processes are killed instantly (SIGKILL) sometimes the database file handles may still be open
-        //This would cause an EBUSY error. Retrying the deletions for 10 seconds should give the OS enough time to close
-        //the file handles.
-        while (retries <= maxRetries) {
-            try {
-                await fsPromises.rm(path, { recursive: true, force: true });
-                return;
-            }
-            catch (e) {
-                if (retries === maxRetries) {
-                    throw e;
-                }
-                await new Promise(resolve => setTimeout(resolve, waitTime));
-                retries++;
-                this.logger.log('DB data directory deletion failed. Now on retry', retries);
-            }
-        }
-    }
     getMySQLVersion(preferredVersion) {
         return new Promise(async (resolve, reject) => {
             if (process.platform === 'win32') {
@@ -83,7 +60,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 +87,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 +138,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;
         }
@@ -188,6 +159,28 @@ _Executor_instances = new WeakSet(), _Executor_execute = function _Executor_exec
         killed = process.kill();
     }
     return killed;
+}, _Executor_deleteDatabaseDirectory = async function _Executor_deleteDatabaseDirectory(path) {
+    let retries = 0;
+    //Maximum wait of 10 seconds | 500ms * 20 retries = 10,000ms = 10 seconds
+    const waitTime = 500;
+    const maxRetries = 20;
+    //Since the database processes are killed instantly (SIGKILL) sometimes the database file handles may still be open
+    //This would cause an EBUSY error. Retrying the deletions for 10 seconds should give the OS enough time to close
+    //the file handles.
+    while (retries <= maxRetries) {
+        try {
+            await fsPromises.rm(path, { recursive: true, force: true });
+            return;
+        }
+        catch (e) {
+            if (retries === maxRetries) {
+                throw e;
+            }
+            await new Promise(resolve => setTimeout(resolve, waitTime));
+            retries++;
+            this.logger.log('DB data directory deletion failed. Now on retry', retries);
+        }
+    }
 }, _Executor_startMySQLProcess = function _Executor_startMySQLProcess(options, port, mySQLXPort, datadir, dbPath, binaryFilepath) {
     const errors = [];
     const logFile = `${dbPath}/log.log`;
@@ -213,7 +206,7 @@ _Executor_instances = new WeakSet(), _Executor_execute = function _Executor_exec
             if (portIssue || xPortIssue) {
                 this.logger.log('Error log when exiting for port in use error:', errorLog);
                 try {
-                    await this.deleteDatabaseDirectory(options.dbPath);
+                    await __classPrivateFieldGet(this, _Executor_instances, "m", _Executor_deleteDatabaseDirectory).call(this, options.dbPath);
                 }
                 catch (e) {
                     this.logger.error(e);
@@ -223,7 +216,7 @@ _Executor_instances = new WeakSet(), _Executor_execute = function _Executor_exec
             }
             try {
                 if (options.deleteDBAfterStopped) {
-                    await this.deleteDatabaseDirectory(dbPath);
+                    await __classPrivateFieldGet(this, _Executor_instances, "m", _Executor_deleteDatabaseDirectory).call(this, dbPath);
                 }
             }
             catch (e) {
@@ -310,7 +303,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 +313,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 +335,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 +351,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 +396,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);
@@ -387,20 +406,11 @@ _Executor_instances = new WeakSet(), _Executor_execute = function _Executor_exec
                         }
                         //Retry setting up directory now that libaio has been copied
                         this.logger.log('Retrying directory setup');
-                        await this.deleteDatabaseDirectory(datadir);
+                        await __classPrivateFieldGet(this, _Executor_instances, "m", _Executor_deleteDatabaseDirectory).call(this, datadir);
                         await __classPrivateFieldGet(this, _Executor_instances, "m", _Executor_setupDataDirectories).call(this, options, binaryFilepath, datadir, false);
                         return;
                     }
                 }
-                catch (error) {
-                    if (String(error).includes('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,8 @@ export type ServerOptions = {
     ignoreUnsupportedSystemVersion?: boolean;
     port?: number;
     xPort?: number;
+    binaryDirectoryPath?: string;
+    downloadRetries?: number;
 };
 export type InternalServerOptions = {
     version?: string;
@@ -29,12 +31,14 @@ export type InternalServerOptions = {
     ignoreUnsupportedSystemVersion: boolean;
     port: number;
     xPort: number;
+    binaryDirectoryPath: string;
+    downloadRetries: number;
 };
 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.2",
+  "version": "1.5.0",
   "description": "Spin up an ephemeral MySQL database from your JavaScript code",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -20,20 +20,24 @@
     "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",
+    "bun": ">=1.0.0"
+  },
   "author": "Sebastian-Webster",
   "license": "MIT",
   "devDependencies": {
-    "@babel/core": "^7.24.9",
-    "@babel/preset-env": "^7.25.4",
-    "@babel/preset-typescript": "^7.24.7",
+    "@babel/core": "^7.25.8",
+    "@babel/preset-env": "^7.25.8",
+    "@babel/preset-typescript": "^7.25.7",
     "@types/adm-zip": "^0.5.5",
-    "@types/node": "^22.5.4",
+    "@types/node": "^22.7.5",
     "@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.3",
+    "typescript": "^5.6.3"
   },
   "dependencies": {
     "adm-zip": "^0.5.16",