mysql-memory-server 1.2.0 → 1.4.0

package/README.md

@@ -10,15 +10,20 @@ Download with your package manager of choice. The package name is `mysql-memory-
 
 #### Requirements
 
-- Node.js 16+
-- macOS 13+, Windows, or Linux (Only Ubuntu has been tested. Other Linux distributions may or may not work at this time. Ubuntu 24.04 and newer is not fully supported at this time - go to the bottom of this file to learn more)
+- 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:
 - `Microsoft Visual C++ 2019 Redistributable Package` needs to be installed
 
 Linux only requirements:
-- The `libaio1` package needs to be installed
-- The `tar` package needs to be installed
+- 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
+
+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
 
 ## Usage
 
@@ -72,7 +77,13 @@ Default: undefined
 
 Description: Version of MySQL to use for the database. Uses semver for getting the version, so valid semver versions are allowed. For example, `8.x` is a valid version and will use the latest 8.x MySQL version. 
 
-If left undefined and the system has MySQL already installed, the system installed version of MySQL will be used. If left undefined and the system does not have MySQL installed, the latest version of MySQL in the `versions.json` file in this package will be downloaded. If defined and the system has that version of MySQL installed, the system installed version will be used. If defined and the system does not have that version of MySQL installed, that version will be downloaded as long as it is found in the `versions.json` file in this package.
+If left undefined:
+- If the system has MySQL installed, the system-installed version will be used. If the installed version is not supported by this package (currently <8.0.20), an error will be thrown unless `ignoreUnsupportedSystemVersion` is set to `true`.
+- If the system does not have MySQL installed, the latest version of MySQL in the `versions.json` file in this package will be downloaded.
+
+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.
 
 - `dbName: string`
 
@@ -132,6 +143,30 @@ Default: root
 
 Description: The username of the user that is used to login to the database.
 
+- `port: number`
+
+Required: No
+
+Default: 0
+
+Description: The port that the database will listen on. If set to 0, a randomly generated port is used.
+
+- `xPort: number`
+
+Required: No
+
+Default: 0
+
+Description: The port that the MySQL X Plugin will listen on. If set to 0, a randomly generated port is used.
+
+- `ignoreUnsupportedSystemVersion: boolean`
+
+Required: No
+
+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.
+
 - `deleteDBAfterStopped: boolean`
 
 Required: No
@@ -151,7 +186,3 @@ Default: `TMPDIR/mysqlmsn/dbs/UUID` (replacing TMPDIR with the OS temp directory
 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: The folder to store database-related data in
-
-## If using Ubuntu 24.04 and newer
-
-Selecting what MySQL version to use is not currently supported on Ubuntu 24.04 and newer. To use this package on Ubuntu 24.04 and newer you must have the `mysql-server` package installed on your system and `ServerOptions.version` must either be the version that is installed on the system or undefined.

package/dist/src/constants.d.ts

@@ -0,0 +1,4 @@
+declare const CONSTANTS: {
+    MIN_SUPPORTED_MYSQL: string;
+};
+export default CONSTANTS;

package/dist/src/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const CONSTANTS = {
+    MIN_SUPPORTED_MYSQL: '8.0.20'
+};
+exports.default = CONSTANTS;

package/dist/src/index.js

@@ -37,6 +37,7 @@ 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"));
 process.on('exit', () => {
     AbortSignal_1.default.abort('Process is exiting');
 });
@@ -51,14 +52,27 @@ async function createDB(opts) {
         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, '')}`)
+        dbPath: (0, path_1.normalize)(`${os.tmpdir()}/mysqlmsn/dbs/${(0, crypto_1.randomUUID)().replace(/-/g, '')}`),
+        ignoreUnsupportedSystemVersion: false,
+        port: 0,
+        xPort: 0
     };
     const options = { ...defaultOptions, ...opts };
     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 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)) {
+        //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.`;
+    }
     logger.log('Version currently installed:', version);
-    if (version === null || (options.version && !(0, semver_1.satisfies)(version.version, options.version))) {
+    if (version === null || (options.version && !(0, semver_1.satisfies)(version.version, options.version)) || unsupportedMySQLIsInstalled) {
         let binaryInfo;
         let binaryFilepath;
         try {
@@ -76,7 +90,7 @@ async function createDB(opts) {
             binaryFilepath = await (0, Downloader_1.downloadBinary)(binaryInfo, options, logger);
         }
         catch (error) {
-            logger.error('Failed to download binary');
+            logger.error('Failed to download binary:', error);
             throw `Failed to download binary. The error was: "${error}"`;
         }
         logger.log('Running downloaded binary');

package/dist/src/libraries/Downloader.js

@@ -37,6 +37,7 @@ 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) => {
         entry.getDataAsync((data, err) => {
@@ -157,27 +158,6 @@ function extractBinary(url, archiveLocation, extractedLocation) {
         });
     });
 }
-function waitForLock(path, options) {
-    return new Promise(async (resolve, reject) => {
-        let retries = 0;
-        while (retries <= options.lockRetries) {
-            retries++;
-            try {
-                const locked = (0, proper_lockfile_1.checkSync)(path);
-                if (!locked) {
-                    return resolve();
-                }
-                else {
-                    await new Promise(resolve => setTimeout(resolve, options.lockRetryWait));
-                }
-            }
-            catch (e) {
-                return reject(e);
-            }
-        }
-        reject(`lockRetries has been exceeded. Lock had not been released after ${options.lockRetryWait} * ${options.lockRetries} milliseconds.`);
-    });
-}
 function downloadBinary(binaryInfo, options, logger) {
     return new Promise(async (resolve, reject) => {
         const { url, version } = binaryInfo;
@@ -190,13 +170,15 @@ function downloadBinary(binaryInfo, options, logger) {
             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);
-                const archivePath = `${dirpath}/${version}.${fileExtension}`;
+                lockedByUs = true;
                 await downloadFromCDN(url, archivePath, logger);
                 await extractBinary(url, archivePath, extractedPath);
                 try {
@@ -208,12 +190,28 @@ function downloadBinary(binaryInfo, options, logger) {
                 return resolve(binaryPath);
             }
             catch (e) {
-                if (String(e) === 'Error: Lock file is already being held') {
+                if (String(e).includes('Lock file is already being held')) {
                     logger.log('Waiting for lock for MySQL version', version);
-                    await waitForLock(extractedPath, options);
+                    await (0, FileLock_1.waitForLock)(extractedPath, options);
                     logger.log('Lock is gone for version', version);
                     return resolve(binaryPath);
                 }
+                if (lockedByUs) {
+                    try {
+                        await Promise.all([
+                            fsPromises.rm(extractedPath, { force: true, recursive: true }),
+                            fsPromises.rm(archivePath, { force: true, recursive: true })
+                        ]);
+                    }
+                    finally {
+                        try {
+                            (0, proper_lockfile_1.unlockSync)(extractedPath, { realpath: false });
+                        }
+                        catch (e) {
+                            logger.error('An error occurred while unlocking path:', e);
+                        }
+                    }
+                }
                 return reject(e);
             }
         }

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_killProcess, _Executor_startMySQLProcess, _Executor_setupDataDirectories;
+var _Executor_instances, _Executor_execute, _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");
@@ -40,6 +40,8 @@ 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");
 class Executor {
     constructor(logger) {
         _Executor_instances.add(this);
@@ -131,9 +133,10 @@ class Executor {
         let retries = 0;
         const datadir = (0, path_1.normalize)(`${options.dbPath}/data`);
         do {
-            await __classPrivateFieldGet(this, _Executor_instances, "m", _Executor_setupDataDirectories).call(this, options, binaryFilepath, datadir);
-            const port = (0, Port_1.GenerateRandomPort)();
-            const mySQLXPort = (0, Port_1.GenerateRandomPort)();
+            await __classPrivateFieldGet(this, _Executor_instances, "m", _Executor_setupDataDirectories).call(this, options, binaryFilepath, datadir, true);
+            this.logger.log('Setting up directories was successful');
+            const port = options.port || (0, Port_1.GenerateRandomPort)();
+            const mySQLXPort = options.xPort || (0, Port_1.GenerateRandomPort)();
             this.logger.log('Using port:', port, 'and MySQLX port:', mySQLXPort, 'on retry:', retries);
             try {
                 this.logger.log('Starting MySQL process');
@@ -164,6 +167,12 @@ _Executor_instances = new WeakSet(), _Executor_execute = function _Executor_exec
             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') {
@@ -185,7 +194,7 @@ _Executor_instances = new WeakSet(), _Executor_execute = function _Executor_exec
     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}`], { signal: AbortSignal_1.default.signal, killSignal: 'SIGKILL' });
+        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' });
         //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.
@@ -290,25 +299,116 @@ _Executor_instances = new WeakSet(), _Executor_execute = function _Executor_exec
             }
         });
     });
-}, _Executor_setupDataDirectories = async function _Executor_setupDataDirectories(options, binaryFilepath, datadir) {
+}, _Executor_setupDataDirectories = async function _Executor_setupDataDirectories(options, binaryFilepath, datadir, retry) {
     this.logger.log('Created data directory for database at:', datadir);
     await fsPromises.mkdir(datadir, { recursive: true });
-    const { error: err, stderr } = await __classPrivateFieldGet(this, _Executor_instances, "m", _Executor_execute).call(this, `"${binaryFilepath}" --no-defaults --datadir=${datadir} --initialize-insecure`);
-    if (err || (stderr && !stderr.includes('InnoDB initialization has ended'))) {
-        if (process.platform === 'win32' && ((err === null || err === void 0 ? void 0 : err.message.includes('Command failed')) || stderr.includes('Command failed'))) {
-            this.logger.error(err || stderr);
+    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`);
+        stderr = output;
+        if (error) {
+            this.logger.error('An error occurred while initializing database with system-installed MySQL:', error);
+            throw 'An error occurred while initializing database with system-installed MySQL. Please check the console for more information.';
+        }
+    }
+    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}/..`));
+        }
+        catch (e) {
+            this.logger.error('Error occurred from executeFile:', e);
+            throw e;
+        }
+        stderr = result === null || result === void 0 ? void 0 : result.stderr;
+    }
+    if (stderr && !stderr.includes('InnoDB initialization has ended')) {
+        if (process.platform === 'win32' && stderr.includes('Command failed')) {
+            this.logger.error(stderr);
             throw 'The mysqld command failed to run. A possible cause is that the Microsoft Visual C++ Redistributable Package is not installed. MySQL 5.7.40 and newer requires Microsoft Visual C++ Redistributable Package 2019 to be installed. Check the MySQL docs for Microsoft Visual C++ requirements for other MySQL versions. If you are sure you have this installed, check the error message in the console for more details.';
         }
-        if (process.platform === 'linux' && ((err === null || err === void 0 ? void 0 : err.message.includes('libaio.so')) || stderr.includes('libaio.so'))) {
-            this.logger.error(err || stderr);
-            throw 'The mysqld command failed to run. MySQL needs the libaio package installed on Linux systems to run. Do you have this installed? Learn more at https://dev.mysql.com/doc/refman/en/binary-installation.html';
+        if (process.platform === 'linux' && stderr.includes('libaio.so')) {
+            if (binaryFilepath === 'mysqld') {
+                throw 'libaio could not be found while running system-installed MySQL. libaio must be installed on this system for MySQL to run. To learn more, please check out https://dev.mysql.com/doc/refman/en/binary-installation.html';
+            }
+            if (retry === false) {
+                this.logger.error('An error occurred while initializing database:', stderr);
+                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');
+                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);
+                    throw 'The ldconfig command failed to run. This command was ran to find libaio because libaio could not be found on the system. libaio is needed for MySQL to run. Do you have ldconfig and libaio installed? Learn more about libaio at Learn more at https://dev.mysql.com/doc/refman/en/binary-installation.html';
+                }
+                const libaioFound = stdout.split('\n').filter(lib => lib.includes('libaio.so.1t64'));
+                if (!libaioFound.length) {
+                    this.logger.error('Error from launching MySQL:', stderr);
+                    throw 'An error occurred while launching MySQL. The most likely cause is that libaio1 and libaio1t64 could not be found. Either libaio1 or libaio1t64 must be installed on this system for MySQL to run. To learn more, please check out https://dev.mysql.com/doc/refman/en/binary-installation.html. Check error in console for more information.';
+                }
+                const libaioEntry = libaioFound[0];
+                const libaioPathIndex = libaioEntry.indexOf('=>');
+                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 });
+                    this.logger.log('libaio copy path:', copyPath, '| libaio symlink path:', libaioSymlinkPath, '| libaio actual path:', libaioPath);
+                    let copyError;
+                    try {
+                        await fsPromises.copyFile(libaioPath, copyPath);
+                    }
+                    catch (e) {
+                        copyError = e;
+                        this.logger.error('An error occurred while copying libaio1t64 to lib folder:', e);
+                        try {
+                            await fsPromises.rm(copyPath, { force: true });
+                        }
+                        catch (e) {
+                            this.logger.error('An error occurred while deleting libaio file:', e);
+                        }
+                    }
+                    finally {
+                        try {
+                            (0, proper_lockfile_1.unlockSync)(copyPath, { realpath: false });
+                        }
+                        catch (e) {
+                            this.logger.error('Error unlocking libaio file:', e);
+                        }
+                        if (copyError) {
+                            throw 'An error occurred while copying libaio1t64 to the MySQL lib folder. Please check the console for more details.';
+                        }
+                        //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_setupDataDirectories).call(this, options, binaryFilepath, datadir, false);
+                        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';
+            }
         }
-        throw err || stderr;
+        throw stderr;
     }
+    this.logger.log('Creating init text');
     let initText = `CREATE DATABASE ${options.dbName};`;
     if (options.username !== 'root') {
         initText += `\nRENAME USER 'root'@'localhost' TO '${options.username}'@'localhost';`;
     }
+    this.logger.log('Writing init file');
     await fsPromises.writeFile(`${options.dbPath}/init.sql`, initText, { encoding: 'utf8' });
+    this.logger.log('Finished writing init file');
 };
 exports.default = Executor;

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

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

package/dist/src/libraries/FileLock.js

@@ -0,0 +1,25 @@
+"use strict";
+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++;
+            try {
+                const locked = (0, proper_lockfile_1.checkSync)(path);
+                if (!locked) {
+                    return resolve();
+                }
+                else {
+                    await new Promise(resolve => setTimeout(resolve, options.lockRetryWait));
+                }
+            }
+            catch (e) {
+                return reject(e);
+            }
+        }
+        reject(`lockRetries has been exceeded. Lock had not been released after ${options.lockRetryWait} * ${options.lockRetries} milliseconds.`);
+    });
+}

package/dist/types/index.d.ts

@@ -11,6 +11,9 @@ export type ServerOptions = {
     username?: string;
     deleteDBAfterStopped?: boolean;
     dbPath?: string;
+    ignoreUnsupportedSystemVersion?: boolean;
+    port?: number;
+    xPort?: number;
 };
 export type InternalServerOptions = {
     version?: string;
@@ -23,6 +26,9 @@ export type InternalServerOptions = {
     username: string;
     deleteDBAfterStopped: boolean;
     dbPath: string;
+    ignoreUnsupportedSystemVersion: boolean;
+    port: number;
+    xPort: number;
 };
 export type ExecutorOptions = {
     logLevel: LOG_LEVEL;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mysql-memory-server",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "Spin up an ephemeral MySQL database from your JavaScript code",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -16,9 +16,9 @@
     "memory database"
   ],
   "scripts": {
-    "test": "jest --testPathIgnorePatterns=/stress-tests/",
-    "test:ci": "jest --testPathIgnorePatterns=/stress-tests/ --setupFilesAfterEnv ./ciSetup.js",
-    "stress": "jest --runTestsByPath stress-tests/stress.test.ts --setupFilesAfterEnv ./ciSetup.js"
+    "test": "jest --testPathIgnorePatterns=/stress-tests/ --verbose",
+    "test:ci": "jest --testPathIgnorePatterns=/stress-tests/ --setupFilesAfterEnv ./ciSetup.js --verbose",
+    "stress": "jest --runTestsByPath stress-tests/stress.test.ts --setupFilesAfterEnv ./ciSetup.js --verbose"
   },
   "author": "Sebastian-Webster",
   "license": "MIT",
@@ -27,7 +27,7 @@
     "@babel/preset-env": "^7.24.8",
     "@babel/preset-typescript": "^7.24.7",
     "@types/adm-zip": "^0.5.5",
-    "@types/node": "^22.1.0",
+    "@types/node": "^22.2.0",
     "@types/proper-lockfile": "^4.1.4",
     "@types/semver": "^7.5.8",
     "babel-jest": "^29.7.0",