mysql-memory-server 1.6.0 → 1.7.0

package/README.md

@@ -1,6 +1,6 @@
 # MySQL Memory Server
 
-This package allows you to create ephemeral MySQL databases from JavaScript and/or TypeScript code, great for testing. When creating a new database, if the version selected is not installed on the system, the binary is downloaded from MySQL's CDN (cdn.mysql.com)
+This package allows you to create ephemeral MySQL databases from JavaScript and/or TypeScript code and also the CLI, great for testing, CI, and learning MySQL. When creating a new database, if the version selected is not installed on the system, the binary is downloaded from MySQL's CDN (cdn.mysql.com)
 
 You can run multiple MySQL databases with this package at the same time. Each database will use a random free port. The databases will automatically shutdown when the JS runtime process exits. A `stop()` method is also provided to stop each database instance.
 
@@ -30,7 +30,7 @@ Requirements for Linux:
 - If using the system installed MySQL server: 8.0.20 and newer
 - If not using the system installed MySQL server: 8.0.39, 8.0.40, 8.1.0, 8.2.0, 8.3.0, 8.4.2, 8.4.3, 9.0.1, 9.1.0
 
-## Usage
+## Example Usage - Application Code
 
 This package supports both ESM and CJS so you can use import or require.
 
@@ -45,7 +45,7 @@ const db = await createDB()
 
 //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
+        // see Options below for the options you can use in this object and their default values
         // for example:
         version: '8.4.x'
 })
@@ -73,6 +73,14 @@ 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
 
+## Example Usage - CLI
+
+```sh
+# Options are added by doing --{optionName} {optionValue}
+# See Options below for the options you can use with this package
+npx mysql-memory-server --version 8.4.x
+```
+
 ## Documentation
 
 ##### `createDB(options: ServerOptions): Promise<MySQLDB>`
@@ -86,10 +94,14 @@ The port that MySQLX is listening on
 The database that was created on database initialization
 - `username: string`
 The name of the user to use to login to the database
+- `socket: string`
+If on Windows, this is the name of the named pipe that MySQL is listening on. If not on Windows, this is the path to the socket that MySQL is listening on.
+- `xSocket: string`
+If on Windows, this is the name of the named pipe that the MySQL X Plugin is listening on. If not on Windows, this is the path that the MySQL X Plugin is listening on.
 - `stop: () => Promise<void>`
 The method to stop the database. The returned promise resolves when the database has successfully stopped.
 
-###### Options:
+#### Options:
 - `version: string`
 
 Required: No
@@ -104,7 +116,7 @@ If left undefined:
 
 If defined:
 - If the version is 8.0.19 or older, an error will be thrown as this package does not currently support those versions of MySQL.
-- If MySQL is installed on the system, the installed version will be used. Otherwise the selected version will be downloaded from the MySQL CDN as long as it can be found in the `versions.json` file. If it cannot be found in that file, an error will be thrown.
+- If the desired version of MySQL is installed on the system, the installed version will be used. Otherwise the selected version will be downloaded from the MySQL CDN as long as it can be found in the `versions.json` file. If it cannot be found in that file, an error will be thrown.
 
 - `dbName: string`
 
@@ -209,28 +221,38 @@ The internal queries that are ran before the queries in ```initSQLString``` are
 ***
 ### :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.
+The following options are only meant for internal use (such as CI or the internals for running this package via the CLI). 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
+- `_DO_NOT_USE_deleteDBAfterStopped: boolean`
 
 Default: true
 
 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
+- `_DO_NOT_USE_dbPath: string`
 
 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
+- `_DO_NOT_USE_binaryDirectoryPath: string`
 
 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.
+
+- `_DO_NOT_USE_beforeSignalCleanupMessage: string`
+
+Required: No
+
+Default: undefined
+
+Description: The message to get displayed in the console before the cleanup that happens when the Node.js process is stopped without the ```stop()``` method being called first.
+
+- `_DO_NOT_USE_afterSignalCleanupMessage: string`
+
+Required: No
+
+Default: undefined
+
+Description: The message to get displayed in the console after the cleanup that happens when the Node.js process is stopped without the ```stop()``` method being called first.

package/dist/src/cli.d.ts

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

package/dist/src/cli.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+const constants_1 = require("./constants");
+async function main() {
+    const definedOptions = process.argv.filter((option) => option.startsWith('--'));
+    const options = {
+        _DO_NOT_USE_beforeSignalCleanupMessage: '\nShutting down the epehemeral MySQL database and cleaning all related files...',
+        _DO_NOT_USE_afterSignalCleanupMessage: 'Shutdown and cleanup is complete.'
+    };
+    for (const opt of definedOptions) {
+        const index = process.argv.indexOf(opt);
+        const optionValue = process.argv[index + 1];
+        if (optionValue === undefined) {
+            throw `Option ${opt} must have a value.`;
+        }
+        const optionName = opt.slice(2);
+        const optionType = constants_1.OPTION_TYPE_CHECKS[optionName].definedType;
+        //Try to convert the options to their correct types.
+        //We do not need to do any proper type validation here as the library will make sure everything is correct.
+        //Like for example, if a string is passed to a number option, it'll be converted to NaN here, but the library
+        //will throw an error for it not being an actual number.
+        if (optionType === 'boolean') {
+            if (optionValue === 'true') {
+                options[optionName] = true;
+            }
+            else if (optionValue === 'false') {
+                options[optionName] = false;
+            }
+            else {
+                options[optionName] = optionValue;
+            }
+        }
+        else if (optionType === 'number') {
+            options[optionName] = parseInt(optionValue);
+        }
+        else {
+            options[opt.slice(2)] = optionValue;
+        }
+    }
+    console.log('Creating ephemeral MySQL database...');
+    const db = await (0, index_1.createDB)(options);
+    console.log(`A MySQL databases has been successfully created with the following parameters:\n\nUsername: ${db.username} \nDatabase Name: ${db.dbName} \nPort: ${db.port} \nX Plugin Port: ${db.xPort} \nSocket: ${db.socket} \nX Plugin Socket: ${db.xSocket}\n`);
+    if (process.platform === 'win32') {
+        //The connection information logs will be different for Windows compared to other platforms.
+        //Windows uses mysqlsh instead of mysql to invoke the client shell, needs a --sql flag to be put into SQL mode, and also does not have a protocol flag.
+        //Also according to https://bugs.mysql.com/bug.php?id=106852, you cannot log into a MySQL database with a named pipe for the first connection so a socket connection suggestion
+        //should only be displayed for non-Windows platforms.
+        console.log(`If you want to use the MySQL CLI client to connect to the database, you can use the following command: \nmysqlsh --sql -u ${db.username} -P ${db.port}\nIf prompted for a password, leave the password field blank. The database does not have a password set.`);
+    }
+    else {
+        console.log(`If you want to use the MySQL CLI client to connect to the database, you can use either commands: \nmysql -u ${db.username} -P ${db.port} --protocol tcp \nOR\nmysql -u ${db.username} --socket ${db.socket}\nIf prompted for a password, leave the password field blank. The database does not have a password set.`);
+    }
+}
+main();

package/dist/src/constants.d.ts

@@ -1,4 +1,11 @@
-declare const CONSTANTS: {
-    MIN_SUPPORTED_MYSQL: string;
+import { InternalServerOptions, OptionTypeChecks } from "../types";
+export declare const MIN_SUPPORTED_MYSQL = "8.0.20";
+export declare const DEFAULT_OPTIONS_GENERATOR: () => InternalServerOptions;
+export declare const DEFAULT_OPTIONS_KEYS: readonly string[];
+export declare const LOG_LEVELS: {
+    readonly LOG: 0;
+    readonly WARN: 1;
+    readonly ERROR: 2;
 };
-export default CONSTANTS;
+export declare const INTERNAL_OPTIONS: readonly ["_DO_NOT_USE_deleteDBAfterStopped", "_DO_NOT_USE_dbPath", "_DO_NOT_USE_binaryDirectoryPath", "_DO_NOT_USE_beforeSignalCleanup", "_DO_NOT_USE_afterSignalCleanup"];
+export declare const OPTION_TYPE_CHECKS: OptionTypeChecks;

package/dist/src/constants.js

@@ -1,6 +1,129 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const CONSTANTS = {
-    MIN_SUPPORTED_MYSQL: '8.0.20'
+exports.OPTION_TYPE_CHECKS = exports.INTERNAL_OPTIONS = exports.LOG_LEVELS = exports.DEFAULT_OPTIONS_KEYS = exports.DEFAULT_OPTIONS_GENERATOR = exports.MIN_SUPPORTED_MYSQL = void 0;
+const crypto_1 = require("crypto");
+const path_1 = require("path");
+const os_1 = require("os");
+const semver_1 = require("semver");
+exports.MIN_SUPPORTED_MYSQL = '8.0.20';
+const DEFAULT_OPTIONS_GENERATOR = () => ({
+    version: undefined,
+    dbName: 'dbdata',
+    logLevel: 'ERROR',
+    portRetries: 10,
+    downloadBinaryOnce: true,
+    lockRetries: 1000,
+    lockRetryWait: 1000,
+    username: 'root',
+    ignoreUnsupportedSystemVersion: false,
+    port: 0,
+    xPort: 0,
+    downloadRetries: 10,
+    initSQLString: '',
+    _DO_NOT_USE_deleteDBAfterStopped: true,
+    //mysqlmsn = MySQL Memory Server Node.js
+    _DO_NOT_USE_dbPath: (0, path_1.normalize)(`${(0, os_1.tmpdir)()}/mysqlmsn/dbs/${(0, crypto_1.randomUUID)().replace(/-/g, '')}`),
+    _DO_NOT_USE_binaryDirectoryPath: `${(0, os_1.tmpdir)()}/mysqlmsn/binaries`,
+    _DO_NOT_USE_beforeSignalCleanupMessage: '',
+    _DO_NOT_USE_afterSignalCleanupMessage: ''
+});
+exports.DEFAULT_OPTIONS_GENERATOR = DEFAULT_OPTIONS_GENERATOR;
+exports.DEFAULT_OPTIONS_KEYS = Object.freeze(Object.keys((0, exports.DEFAULT_OPTIONS_GENERATOR)()));
+exports.LOG_LEVELS = {
+    'LOG': 0,
+    'WARN': 1,
+    'ERROR': 2
+};
+exports.INTERNAL_OPTIONS = ['_DO_NOT_USE_deleteDBAfterStopped', '_DO_NOT_USE_dbPath', '_DO_NOT_USE_binaryDirectoryPath', '_DO_NOT_USE_beforeSignalCleanup', '_DO_NOT_USE_afterSignalCleanup'];
+exports.OPTION_TYPE_CHECKS = {
+    version: {
+        check: (opt) => opt === undefined || typeof opt === 'string' && (0, semver_1.valid)(opt) !== null,
+        errorMessage: 'Option version must be either undefined or a valid semver string.',
+        definedType: 'string'
+    },
+    dbName: {
+        check: (opt) => opt === undefined || typeof opt === 'string' && opt.length <= 64,
+        errorMessage: 'Option dbName must be either undefined or a string that is not longer than 64 characters.',
+        definedType: 'string'
+    },
+    logLevel: {
+        check: (opt) => opt === undefined || Object.keys(exports.LOG_LEVELS).includes(opt),
+        errorMessage: 'Option logLevel must be either undefined or "LOG", "WARN", or "ERROR".',
+        definedType: 'string'
+    },
+    portRetries: {
+        check: (opt) => opt === undefined || typeof opt === 'number' && opt >= 0,
+        errorMessage: 'Option portRetries must be either undefined, a positive number, or 0.',
+        definedType: 'number'
+    },
+    downloadBinaryOnce: {
+        check: (opt) => opt === undefined || typeof opt === 'boolean',
+        errorMessage: 'Option downloadBinaryOnce must be either undefined or a boolean.',
+        definedType: 'boolean'
+    },
+    lockRetries: {
+        check: (opt) => opt === undefined || typeof opt === 'number' && opt >= 0,
+        errorMessage: 'Option lockRetries must be either undefined, a positive number, or 0.',
+        definedType: 'number'
+    },
+    lockRetryWait: {
+        check: (opt) => opt === undefined || typeof opt === 'number' && opt >= 0,
+        errorMessage: 'Option lockRetryWait must be either undefined, a positive number, or 0.',
+        definedType: 'number'
+    },
+    username: {
+        check: (opt) => opt === undefined || typeof opt === 'string' && opt.length <= 32,
+        errorMessage: 'Option username must be either undefined or a string that is not longer than 32 characters.',
+        definedType: 'string'
+    },
+    ignoreUnsupportedSystemVersion: {
+        check: (opt) => opt === undefined || typeof opt === 'boolean',
+        errorMessage: 'Option ignoreUnsupportedSystemVersion must be either undefined or a boolean.',
+        definedType: 'boolean'
+    },
+    port: {
+        check: (opt) => opt === undefined || typeof opt === 'number' && opt >= 0 && opt <= 65535,
+        errorMessage: 'Option port must be either undefined or a number that is between 0 and 65535 inclusive.',
+        definedType: 'number'
+    },
+    xPort: {
+        check: (opt) => opt === undefined || typeof opt === 'number' && opt >= 0 && opt <= 65535,
+        errorMessage: 'Option xPort must be either undefined or a number that is between 0 and 65535 inclusive.',
+        definedType: 'number'
+    },
+    downloadRetries: {
+        check: (opt) => opt === undefined || typeof opt === 'number' && opt >= 0,
+        errorMessage: 'Option downloadRetries must be either undefined, a positive number, or 0.',
+        definedType: 'number'
+    },
+    initSQLString: {
+        check: (opt) => opt === undefined || typeof opt === 'string',
+        errorMessage: 'Option initSQLString must be either undefined or a string.',
+        definedType: 'string'
+    },
+    _DO_NOT_USE_deleteDBAfterStopped: {
+        check: (opt) => opt === undefined || typeof opt === 'boolean',
+        errorMessage: 'Option _DO_NOT_USE_deleteDBAfterStopped must be either undefined or a boolean.',
+        definedType: 'boolean'
+    },
+    _DO_NOT_USE_dbPath: {
+        check: (opt) => opt === undefined || typeof opt === 'string',
+        errorMessage: 'Option _DO_NOT_USE_dbPath must be either undefined or a string.',
+        definedType: 'string'
+    },
+    _DO_NOT_USE_binaryDirectoryPath: {
+        check: (opt) => opt === undefined || typeof opt === 'string',
+        errorMessage: 'Option _DO_NOT_USE_binaryDirectoryPath must be either undefined or a string.',
+        definedType: 'string'
+    },
+    _DO_NOT_USE_beforeSignalCleanupMessage: {
+        check: (opt) => opt === undefined || typeof opt === 'string',
+        errorMessage: 'Option _DO_NOT_USE_beforeSignalCleanup must be either undefined or a string.',
+        definedType: 'string'
+    },
+    _DO_NOT_USE_afterSignalCleanupMessage: {
+        check: (opt) => opt === undefined || typeof opt === 'string',
+        errorMessage: 'Option _DO_NOT_USE_afterSignalCleanup must be either undefined or a string.',
+        definedType: 'string'
+    }
 };
-exports.default = CONSTANTS;

package/dist/src/index.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -34,38 +44,37 @@ const semver_1 = require("semver");
 const Version_1 = __importDefault(require("./libraries/Version"));
 const versions_json_1 = __importDefault(require("./versions.json"));
 const Downloader_1 = require("./libraries/Downloader");
-const crypto_1 = require("crypto");
-const path_1 = require("path");
-const constants_1 = __importDefault(require("./constants"));
+const constants_1 = require("./constants");
 async function createDB(opts) {
-    const defaultOptions = {
-        dbName: 'dbdata',
-        logLevel: 'ERROR',
-        portRetries: 10,
-        downloadBinaryOnce: true,
-        lockRetries: 1000,
-        lockRetryWait: 1000,
-        username: 'root',
-        deleteDBAfterStopped: true,
-        //mysqlmsn = MySQL Memory Server Node.js
-        dbPath: (0, path_1.normalize)(`${os.tmpdir()}/mysqlmsn/dbs/${(0, crypto_1.randomUUID)().replace(/-/g, '')}`),
-        ignoreUnsupportedSystemVersion: false,
-        port: 0,
-        xPort: 0,
-        binaryDirectoryPath: `${os.tmpdir()}/mysqlmsn/binaries`,
-        downloadRetries: 10,
-        initSQLString: ''
-    };
-    const options = { ...defaultOptions, ...opts };
+    const suppliedOpts = opts || {};
+    const suppliedOptsKeys = Object.keys(suppliedOpts);
+    for (const opt of constants_1.INTERNAL_OPTIONS) {
+        if (suppliedOptsKeys.includes(opt)) {
+            console.warn(`[ mysql-memory-server - Options WARN ]: Creating MySQL database with option ${opt}. This is considered unstable and should not be used externally. Please consider removing this option.`);
+        }
+    }
+    const options = (0, constants_1.DEFAULT_OPTIONS_GENERATOR)();
+    for (const opt of suppliedOptsKeys) {
+        if (!constants_1.DEFAULT_OPTIONS_KEYS.includes(opt)) {
+            throw `Option ${opt} is not a valid option.`;
+        }
+        if (!constants_1.OPTION_TYPE_CHECKS[opt].check(suppliedOpts[opt])) {
+            //Supplied option failed the check
+            throw constants_1.OPTION_TYPE_CHECKS[opt].errorMessage;
+        }
+        if (suppliedOpts[opt] !== undefined) {
+            options[opt] = suppliedOpts[opt];
+        }
+    }
     const logger = new Logger_1.default(options.logLevel);
     const executor = new Executor_1.default(logger);
     const version = await executor.getMySQLVersion(options.version);
-    const unsupportedMySQLIsInstalled = version && (0, semver_1.lt)(version.version, constants_1.default.MIN_SUPPORTED_MYSQL);
+    const unsupportedMySQLIsInstalled = version && (0, semver_1.lt)(version.version, constants_1.MIN_SUPPORTED_MYSQL);
     const throwUnsupportedError = unsupportedMySQLIsInstalled && !options.ignoreUnsupportedSystemVersion && !options.version;
     if (throwUnsupportedError) {
         throw `A version of MySQL is installed on your system that is not supported by this package. If you want to download a MySQL binary instead of getting this error, please set the option "ignoreUnsupportedSystemVersion" to true.`;
     }
-    if (options.version && (0, semver_1.lt)(options.version, constants_1.default.MIN_SUPPORTED_MYSQL)) {
+    if (options.version && (0, semver_1.lt)(options.version, constants_1.MIN_SUPPORTED_MYSQL)) {
         //The difference between the throw here and the throw above is this throw is because the selected "version" is not supported.
         //The throw above is because the system-installed MySQL is out of date and "ignoreUnsupportedSystemVersion" is not set to true.
         throw `The selected version of MySQL (${options.version}) is not currently supported by this package. Please choose a different version to use.`;

package/dist/src/libraries/Downloader.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -35,7 +45,6 @@ const adm_zip_1 = __importDefault(require("adm-zip"));
 const path_1 = require("path");
 const crypto_1 = require("crypto");
 const child_process_1 = require("child_process");
-const proper_lockfile_1 = require("proper-lockfile");
 const FileLock_1 = require("./FileLock");
 function getZipData(entry) {
     return new Promise((resolve, reject) => {
@@ -199,7 +208,7 @@ function extractBinary(url, archiveLocation, extractedLocation, logger) {
 function downloadBinary(binaryInfo, options, logger) {
     return new Promise(async (resolve, reject) => {
         const { url, version } = binaryInfo;
-        const dirpath = options.binaryDirectoryPath;
+        const dirpath = options._DO_NOT_USE_binaryDirectoryPath;
         logger.log('Binary path:', dirpath);
         await fsPromises.mkdir(dirpath, { recursive: true });
         const lastDashIndex = url.lastIndexOf('-');
@@ -215,11 +224,11 @@ function downloadBinary(binaryInfo, options, logger) {
             let releaseFunction;
             while (true) {
                 try {
-                    releaseFunction = (0, proper_lockfile_1.lockSync)(extractedPath, { realpath: false });
+                    releaseFunction = await (0, FileLock_1.lockFile)(extractedPath);
                     break;
                 }
                 catch (e) {
-                    if (e.code === 'ELOCKED') {
+                    if (e === 'LOCKED') {
                         logger.log('Waiting for lock for MySQL version', version);
                         await (0, FileLock_1.waitForLock)(extractedPath, options);
                         logger.log('Lock is gone for version', version);
@@ -253,10 +262,10 @@ function downloadBinary(binaryInfo, options, logger) {
                     catch (e) {
                         logger.error('An error occurred while deleting extractedPath and/or archivePath:', e);
                     }
-                    if (downloadTries >= options.downloadRetries) {
+                    if (downloadTries > options.downloadRetries) {
                         //Only reject if we have met the downloadRetries limit
                         try {
-                            releaseFunction();
+                            await releaseFunction();
                         }
                         catch (e) {
                             logger.error('An error occurred while releasing lock after downloadRetries exhaustion. The error was:', e);
@@ -268,7 +277,7 @@ function downloadBinary(binaryInfo, options, logger) {
                         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);
+            } while (downloadTries <= options.downloadRetries);
             try {
                 releaseFunction();
             }
@@ -301,7 +310,7 @@ function downloadBinary(binaryInfo, options, logger) {
                     catch (e) {
                         logger.error('An error occurred while deleting extractedPath and/or archivePath:', e);
                     }
-                    if (downloadTries >= options.downloadRetries) {
+                    if (downloadTries > options.downloadRetries) {
                         //Only reject if we have met the downloadRetries limit
                         return reject(e);
                     }
@@ -309,7 +318,7 @@ function downloadBinary(binaryInfo, options, logger) {
                         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);
+            } while (downloadTries <= options.downloadRetries);
         }
     });
 }

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

@@ -3,6 +3,8 @@ import { InstalledMySQLVersion, InternalServerOptions, MySQLDB } from "../../typ
 declare class Executor {
     #private;
     logger: Logger;
+    DBDestroySignal: AbortController;
+    removeExitHandler: () => void;
     constructor(logger: Logger);
     getMySQLVersion(preferredVersion?: string): Promise<InstalledMySQLVersion | null>;
     startMySQL(options: InternalServerOptions, binaryFilepath: string): Promise<MySQLDB>;

package/dist/src/libraries/Executor.js

@@ -15,22 +15,29 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var _Executor_instances, _Executor_executeFile, _Executor_killProcess, _Executor_deleteDatabaseDirectory, _Executor_startMySQLProcess, _Executor_setupDataDirectories;
+var _Executor_instances, _Executor_executeFile, _Executor_killProcess, _Executor_deleteDatabaseDirectory, _Executor_returnBinaryPathToDelete, _Executor_startMySQLProcess, _Executor_setupDataDirectories;
 Object.defineProperty(exports, "__esModule", { value: true });
 const child_process_1 = require("child_process");
 const semver_1 = require("semver");
@@ -38,13 +45,13 @@ const os = __importStar(require("os"));
 const fsPromises = __importStar(require("fs/promises"));
 const fs = __importStar(require("fs"));
 const Port_1 = require("./Port");
-const AbortSignal_1 = __importDefault(require("./AbortSignal"));
 const path_1 = require("path");
-const proper_lockfile_1 = require("proper-lockfile");
 const FileLock_1 = require("./FileLock");
+const signal_exit_1 = require("signal-exit");
 class Executor {
     constructor(logger) {
         _Executor_instances.add(this);
+        this.DBDestroySignal = new AbortController();
         this.logger = logger;
     }
     getMySQLVersion(preferredVersion) {
@@ -107,8 +114,34 @@ class Executor {
         });
     }
     async startMySQL(options, binaryFilepath) {
+        this.removeExitHandler = (0, signal_exit_1.onExit)(() => {
+            if (options._DO_NOT_USE_beforeSignalCleanupMessage) {
+                console.log(options._DO_NOT_USE_beforeSignalCleanupMessage);
+            }
+            this.DBDestroySignal.abort();
+            if (options._DO_NOT_USE_deleteDBAfterStopped) {
+                try {
+                    fs.rmSync(options._DO_NOT_USE_dbPath, { recursive: true, maxRetries: 50, force: true });
+                }
+                catch (e) {
+                    this.logger.error('An error occurred while deleting database directory path:', e);
+                }
+            }
+            const binaryPathToDelete = __classPrivateFieldGet(this, _Executor_instances, "m", _Executor_returnBinaryPathToDelete).call(this, binaryFilepath, options);
+            if (binaryPathToDelete) {
+                try {
+                    fs.rmSync(binaryPathToDelete, { force: true, recursive: true, maxRetries: 50 });
+                }
+                catch (e) {
+                    this.logger.error('An error occurred while deleting database binary:', e);
+                }
+            }
+            if (options._DO_NOT_USE_afterSignalCleanupMessage) {
+                console.log(options._DO_NOT_USE_afterSignalCleanupMessage);
+            }
+        });
         let retries = 0;
-        const datadir = (0, path_1.normalize)(`${options.dbPath}/data`);
+        const datadir = (0, path_1.normalize)(`${options._DO_NOT_USE_dbPath}/data`);
         do {
             await __classPrivateFieldGet(this, _Executor_instances, "m", _Executor_setupDataDirectories).call(this, options, binaryFilepath, datadir, true);
             this.logger.log('Setting up directories was successful');
@@ -117,7 +150,7 @@ class Executor {
             this.logger.log('Using port:', port, 'and MySQLX port:', mySQLXPort, 'on retry:', retries);
             try {
                 this.logger.log('Starting MySQL process');
-                const resolved = await __classPrivateFieldGet(this, _Executor_instances, "m", _Executor_startMySQLProcess).call(this, options, port, mySQLXPort, datadir, options.dbPath, binaryFilepath);
+                const resolved = await __classPrivateFieldGet(this, _Executor_instances, "m", _Executor_startMySQLProcess).call(this, options, port, mySQLXPort, datadir, options._DO_NOT_USE_dbPath, binaryFilepath);
                 this.logger.log('Starting process was successful');
                 return resolved;
             }
@@ -140,7 +173,7 @@ class Executor {
 }
 _Executor_instances = new WeakSet(), _Executor_executeFile = function _Executor_executeFile(command, args) {
     return new Promise(resolve => {
-        (0, child_process_1.execFile)(command, args, { signal: AbortSignal_1.default.signal }, (error, stdout, stderr) => {
+        (0, child_process_1.execFile)(command, args, { signal: this.DBDestroySignal.signal }, (error, stdout, stderr) => {
             resolve({ error, stdout, stderr });
         });
     });
@@ -181,13 +214,24 @@ _Executor_instances = new WeakSet(), _Executor_executeFile = function _Executor_
             this.logger.log('DB data directory deletion failed. Now on retry', retries);
         }
     }
+}, _Executor_returnBinaryPathToDelete = function _Executor_returnBinaryPathToDelete(binaryFilepath, options) {
+    if (binaryFilepath.includes(os.tmpdir()) && !options.downloadBinaryOnce) {
+        const splitPath = binaryFilepath.split(os.platform() === 'win32' ? '\\' : '/');
+        const binariesIndex = splitPath.indexOf('binaries');
+        //The path will be the directory path for the binary download
+        splitPath.splice(binariesIndex + 2);
+        return splitPath.join('/');
+    }
+    return null;
 }, _Executor_startMySQLProcess = function _Executor_startMySQLProcess(options, port, mySQLXPort, datadir, dbPath, binaryFilepath) {
     const errors = [];
     const logFile = `${dbPath}/log.log`;
     const errorLogFile = `${datadir}/errorlog.err`;
     return new Promise(async (resolve, reject) => {
         await fsPromises.rm(logFile, { force: true });
-        const process = (0, child_process_1.spawn)(binaryFilepath, ['--no-defaults', `--port=${port}`, `--datadir=${datadir}`, `--mysqlx-port=${mySQLXPort}`, `--mysqlx-socket=${dbPath}/x.sock`, `--socket=${dbPath}/m.sock`, `--general-log-file=${logFile}`, '--general-log=1', `--init-file=${dbPath}/init.sql`, '--bind-address=127.0.0.1', '--innodb-doublewrite=OFF', '--mysqlx=FORCE', `--log-error=${errorLogFile}`, `--user=${os.userInfo().username}`], { signal: AbortSignal_1.default.signal, killSignal: 'SIGKILL' });
+        const socket = os.platform() === 'win32' ? `MySQL-${crypto.randomUUID()}` : `${dbPath}/m.sock`;
+        const xSocket = os.platform() === 'win32' ? `MySQLX-${crypto.randomUUID()}` : `${dbPath}/x.sock`;
+        const process = (0, child_process_1.spawn)(binaryFilepath, ['--no-defaults', `--port=${port}`, `--datadir=${datadir}`, `--mysqlx-port=${mySQLXPort}`, `--mysqlx-socket=${xSocket}`, `--socket=${socket}`, `--general-log-file=${logFile}`, '--general-log=1', `--init-file=${dbPath}/init.sql`, '--bind-address=127.0.0.1', '--innodb-doublewrite=OFF', '--mysqlx=FORCE', `--log-error=${errorLogFile}`, `--user=${os.userInfo().username}`], { signal: this.DBDestroySignal.signal, killSignal: 'SIGKILL' });
         //resolveFunction is the function that will be called to resolve the promise that stops the database.
         //If resolveFunction is not undefined, the database has received a kill signal and data cleanup procedures should run.
         //Once ran, resolveFunction will be called.
@@ -206,7 +250,7 @@ _Executor_instances = new WeakSet(), _Executor_executeFile = function _Executor_
             if (portIssue || xPortIssue) {
                 this.logger.log('Error log when exiting for port in use error:', errorLog);
                 try {
-                    await __classPrivateFieldGet(this, _Executor_instances, "m", _Executor_deleteDatabaseDirectory).call(this, options.dbPath);
+                    await __classPrivateFieldGet(this, _Executor_instances, "m", _Executor_deleteDatabaseDirectory).call(this, options._DO_NOT_USE_dbPath);
                 }
                 catch (e) {
                     this.logger.error(e);
@@ -215,22 +259,18 @@ _Executor_instances = new WeakSet(), _Executor_executeFile = function _Executor_
                 return reject('Port is already in use');
             }
             try {
-                if (options.deleteDBAfterStopped) {
+                if (options._DO_NOT_USE_deleteDBAfterStopped) {
                     await __classPrivateFieldGet(this, _Executor_instances, "m", _Executor_deleteDatabaseDirectory).call(this, dbPath);
                 }
             }
             catch (e) {
-                this.logger.error('An erorr occurred while deleting database directory at path:', dbPath, '| The error was:', e);
+                this.logger.error('An error occurred while deleting database directory at path:', dbPath, '| The error was:', e);
             }
             finally {
                 try {
-                    if (binaryFilepath.includes(os.tmpdir()) && !options.downloadBinaryOnce) {
-                        const splitPath = binaryFilepath.split(os.platform() === 'win32' ? '\\' : '/');
-                        const binariesIndex = splitPath.indexOf('binaries');
-                        //The path will be the directory path for the binary download
-                        splitPath.splice(binariesIndex + 2);
-                        //Delete the binary folder
-                        await fsPromises.rm(splitPath.join('/'), { force: true, recursive: true });
+                    const binaryPathToDelete = __classPrivateFieldGet(this, _Executor_instances, "m", _Executor_returnBinaryPathToDelete).call(this, binaryFilepath, options);
+                    if (binaryPathToDelete) {
+                        await fsPromises.rm(binaryPathToDelete, { force: true, recursive: true, maxRetries: 50 });
                     }
                 }
                 catch (e) {
@@ -282,11 +322,14 @@ _Executor_instances = new WeakSet(), _Executor_executeFile = function _Executor_
                     resolve({
                         port,
                         xPort: mySQLXPort,
+                        socket,
+                        xSocket,
                         dbName: options.dbName,
                         username: options.username,
                         stop: () => {
                             return new Promise(async (resolve, reject) => {
                                 resolveFunction = resolve;
+                                this.removeExitHandler();
                                 const killed = await __classPrivateFieldGet(this, _Executor_instances, "m", _Executor_killProcess).call(this, process);
                                 if (!killed) {
                                     reject();
@@ -354,11 +397,11 @@ _Executor_instances = new WeakSet(), _Executor_executeFile = function _Executor_
                 let lockRelease;
                 while (true) {
                     try {
-                        lockRelease = (0, proper_lockfile_1.lockSync)(copyPath, { realpath: false });
+                        lockRelease = await (0, FileLock_1.lockFile)(copyPath);
                         break;
                     }
                     catch (e) {
-                        if (e.code === 'ELOCKED') {
+                        if (e === 'LOCKED') {
                             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');
@@ -396,7 +439,7 @@ _Executor_instances = new WeakSet(), _Executor_executeFile = function _Executor_
                     }
                     finally {
                         try {
-                            lockRelease();
+                            await lockRelease();
                         }
                         catch (e) {
                             this.logger.error('Error unlocking libaio file:', e);
@@ -427,7 +470,7 @@ _Executor_instances = new WeakSet(), _Executor_executeFile = function _Executor_
         initText += `\n${options.initSQLString}`;
     }
     this.logger.log('Writing init file');
-    await fsPromises.writeFile(`${options.dbPath}/init.sql`, initText, { encoding: 'utf8' });
+    await fsPromises.writeFile(`${options._DO_NOT_USE_dbPath}/init.sql`, initText, { encoding: 'utf8' });
     this.logger.log('Finished writing init file');
 };
 exports.default = Executor;

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

@@ -1,2 +1,3 @@
 import { InternalServerOptions } from "../../types";
 export declare function waitForLock(path: string, options: InternalServerOptions): Promise<void>;
+export declare function lockFile(path: string): Promise<() => Promise<void>>;

package/dist/src/libraries/FileLock.js

@@ -1,25 +1,81 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.waitForLock = waitForLock;
-const proper_lockfile_1 = require("proper-lockfile");
-function waitForLock(path, options) {
-    return new Promise(async (resolve, reject) => {
-        let retries = 0;
-        while (retries <= options.lockRetries) {
-            retries++;
+exports.lockFile = lockFile;
+const promises_1 = __importDefault(require("fs/promises"));
+const mtimeUpdateIntervalTime = 2000;
+const mtimeLimit = 10000;
+async function waitForLock(path, options) {
+    const lockPath = `${path}.lock`;
+    let retries = 0;
+    do {
+        retries++;
+        try {
+            const stat = await promises_1.default.stat(lockPath);
+            if (Date.now() - stat.mtime.getTime() > mtimeLimit) {
+                return;
+            }
+            else {
+                await new Promise(resolve => setTimeout(resolve, options.lockRetryWait));
+            }
+        }
+        catch (e) {
+            if (e.code === 'ENOENT') {
+                return;
+            }
+            else {
+                throw e;
+            }
+        }
+    } while (retries <= options.lockRetries);
+    throw `lockRetries has been exceeded. Lock had not been released after ${options.lockRetryWait} * ${options.lockRetries} (${options.lockRetryWait * options.lockRetries}) milliseconds.`;
+}
+function setupMTimeEditor(lockPath) {
+    const interval = setInterval(async () => {
+        try {
+            const time = new Date();
+            await promises_1.default.utimes(lockPath, time, time);
+        }
+        catch { }
+    }, mtimeUpdateIntervalTime);
+    return async () => {
+        clearInterval(interval);
+        await promises_1.default.rmdir(lockPath);
+    };
+}
+async function lockFile(path) {
+    const lockPath = `${path}.lock`;
+    try {
+        await promises_1.default.mkdir(lockPath);
+        return setupMTimeEditor(lockPath);
+    }
+    catch (e) {
+        if (e.code === 'EEXIST') {
             try {
-                const locked = (0, proper_lockfile_1.checkSync)(path, { realpath: false });
-                if (!locked) {
-                    return resolve();
+                const stat = await promises_1.default.stat(lockPath);
+                if (Date.now() - stat.mtime.getTime() > mtimeLimit) {
+                    return setupMTimeEditor(lockPath);
                 }
                 else {
-                    await new Promise(resolve => setTimeout(resolve, options.lockRetryWait));
+                    throw 'LOCKED';
                 }
             }
             catch (e) {
-                return reject(e);
+                if (e.code === 'ENOENT') {
+                    //This will run if the lock gets released after the EEXIST error is thrown but before the stat is checked.
+                    //If this is the case, the lock acquisition should be retried.
+                    return await lockFile(path);
+                }
+                else {
+                    throw e;
+                }
             }
         }
-        reject(`lockRetries has been exceeded. Lock had not been released after ${options.lockRetryWait} * ${options.lockRetries} milliseconds.`);
-    });
+        else {
+            throw e;
+        }
+    }
 }

package/dist/src/libraries/Logger.js

@@ -1,13 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const LOG_LEVELS = {
-    'LOG': 0,
-    'WARN': 1,
-    'ERROR': 2
-};
+const constants_1 = require("../constants");
 class Logger {
     constructor(level) {
-        this.LOG_LEVEL = LOG_LEVELS[level];
+        this.LOG_LEVEL = constants_1.LOG_LEVELS[level];
     }
     log(...args) {
         if (this.LOG_LEVEL === 0) {

package/dist/src/libraries/Version.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = getBinaryURL;
 const os = __importStar(require("os"));

package/dist/types/index.d.ts

@@ -9,14 +9,16 @@ export type ServerOptions = {
     lockRetries?: number | undefined;
     lockRetryWait?: number | undefined;
     username?: string | undefined;
-    deleteDBAfterStopped?: boolean | undefined;
-    dbPath?: string | undefined;
     ignoreUnsupportedSystemVersion?: boolean | undefined;
     port?: number | undefined;
     xPort?: number | undefined;
-    binaryDirectoryPath?: string | undefined;
     downloadRetries?: number | undefined;
     initSQLString?: string | undefined;
+    _DO_NOT_USE_deleteDBAfterStopped?: boolean | undefined;
+    _DO_NOT_USE_dbPath?: string | undefined;
+    _DO_NOT_USE_binaryDirectoryPath?: string | undefined;
+    _DO_NOT_USE_beforeSignalCleanupMessage?: string | undefined;
+    _DO_NOT_USE_afterSignalCleanupMessage?: string | undefined;
 };
 export type InternalServerOptions = {
     version?: string | undefined;
@@ -27,14 +29,16 @@ export type InternalServerOptions = {
     lockRetries: number;
     lockRetryWait: number;
     username: string;
-    deleteDBAfterStopped: boolean;
-    dbPath: string;
     ignoreUnsupportedSystemVersion: boolean;
     port: number;
     xPort: number;
-    binaryDirectoryPath: string;
     downloadRetries: number;
     initSQLString: string;
+    _DO_NOT_USE_deleteDBAfterStopped: boolean;
+    _DO_NOT_USE_dbPath: string;
+    _DO_NOT_USE_binaryDirectoryPath: string;
+    _DO_NOT_USE_beforeSignalCleanupMessage: string;
+    _DO_NOT_USE_afterSignalCleanupMessage: string;
 };
 export type ExecutorOptions = {
     logLevel: LOG_LEVEL;
@@ -47,6 +51,8 @@ export type ExecuteFileReturn = {
 export type MySQLDB = {
     port: number;
     xPort: number;
+    socket: string;
+    xSocket: string;
     dbName: string;
     username: string;
     stop: () => Promise<void>;
@@ -66,3 +72,10 @@ export type BinaryInfo = {
     url: string;
     version: string;
 };
+export type OptionTypeChecks = {
+    [key in keyof Required<ServerOptions>]: {
+        check: (opt: any) => boolean;
+        errorMessage: string;
+        definedType: "string" | "boolean" | "number";
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mysql-memory-server",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "Spin up an ephemeral MySQL database from your JavaScript code",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -31,18 +31,17 @@
     "@babel/preset-env": "^7.25.9",
     "@babel/preset-typescript": "^7.25.9",
     "@types/adm-zip": "^0.5.5",
-    "@types/node": "^22.7.9",
-    "@types/proper-lockfile": "^4.1.4",
+    "@types/node": "^22.9.3",
     "@types/semver": "^7.5.8",
     "babel-jest": "^29.7.0",
     "jest": "^29.7.0",
     "mysql2": "^3.11.3",
-    "typescript": "^5.6.3"
+    "typescript": "^5.7.2"
   },
   "dependencies": {
     "adm-zip": "^0.5.16",
-    "proper-lockfile": "^4.1.2",
-    "semver": "^7.6.3"
+    "semver": "^7.6.3",
+    "signal-exit": "^4.1.0"
   },
   "repository": {
     "type": "git",
@@ -51,5 +50,6 @@
   "bugs": {
     "url": "https://github.com/Sebastian-Webster/mysql-memory-server-nodejs/issues"
   },
-  "homepage": "https://github.com/Sebastian-Webster/mysql-memory-server-nodejs"
+  "homepage": "https://github.com/Sebastian-Webster/mysql-memory-server-nodejs",
+  "bin": "dist/src/cli.js"
 }