eip-cloud-services 1.1.12 → 1.1.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eip-cloud-services",
-  "version": "1.1.12",
+  "version": "1.1.14",
   "description": "Houses a collection of helpers for connecting with Cloud services.",
   "main": "index.js",
   "scripts": {

package/src/mysql.js

@@ -6,21 +6,33 @@ if ( fs.existsSync ( configDirPath ) && fs.statSync ( configDirPath ).isDirector
     config = require ( 'config' ); // require the config directory if it exists
 }
 
-let pool = null;
+// Replace single pool with pools object to store multiple connection pools
+const pools = {};
 
-function getPool () {
-    if ( !pool ) {
-        pool = mysql.createPool ( {
-            connectionLimit: config.mysql.connectionLimit,
-            host: config.mysql.host,
-            user: config.mysql.user,
-            password: config.mysql.password,
-            database: config.mysql.database || undefined,
-            multipleStatements: config.mysql.multipleStatements || true
-        } );
+/**
+ * Creates or retrieves a MySQL connection pool based on a given pool identifier.
+ * If the pool does not exist, it creates a new one with the configuration settings.
+ *
+ * @param {string} [poolId='main'] - The identifier for the MySQL connection pool. Defaults to 'main'.
+ * @returns {Object} The MySQL connection pool.
+ */
+function getPool (poolId = 'main') {
+    console.log(`Getting MySQL connection pool for poolId: ${poolId}`);
+    if (!pools[poolId]) {
+        // Support custom config per poolId if available
+        const poolConfig = config.mysql[poolId] || config.mysql;
+        
+        pools[poolId] = mysql.createPool({
+            connectionLimit: poolConfig.connectionLimit,
+            host: poolConfig.host,
+            user: poolConfig.user,
+            password: poolConfig.password,
+            database: poolConfig.database || undefined,
+            multipleStatements: poolConfig.multipleStatements || true
+        });
     }
     
-    return pool;
+    return pools[poolId];
 }
 
 const newQuery = ( connection, query ) => new Promise ( ( resolve, reject ) => {
@@ -44,29 +56,71 @@ const newQuery = ( connection, query ) => new Promise ( ( resolve, reject ) => {
     } );
 } );
 
+/**
+ * Deletes a MySQL connection pool.
+ * @param {string} poolId - The identifier of the pool to delete.
+ * @returns {Promise<void>} - A promise that resolves once the pool is closed and deleted.
+ */
+exports.deletePool = (poolId) => new Promise((resolve) => {
+    if (pools[poolId]) {
+        pools[poolId].end(() => {
+            delete pools[poolId];
+            resolve();
+        });
+    } else {
+        resolve();
+    }
+});
+
 exports.getPool = getPool;
-exports.getConnection = () => new Promise ( ( resolve, reject ) => {
-    getPool ().getConnection ( ( error, connection ) => {
-        if ( error ) {
-            console.log ( error );
-            console.error ( 'There was a problem getting a new database connection.' );
-            reject ( 'There was a problem getting a new database connection.' );
-        }
-        else {
-            resolve ( connection );
+
+/**
+ * Gets a MySQL connection from a specified pool.
+ * @param {string} [poolId='main'] - The identifier for the MySQL connection pool.
+ * @returns {Promise<Object>} - A promise that resolves with a MySQL connection.
+ */
+exports.getConnection = (poolId = 'main') => new Promise((resolve, reject) => {
+    getPool(poolId).getConnection((error, connection) => {
+        if (error) {
+            console.log(error);
+            console.error('There was a problem getting a new database connection.');
+            reject('There was a problem getting a new database connection.');
+        } else {
+            resolve(connection);
         }
-    } );
-} );
+    });
+});
 
-exports.query = queryString => new Promise ( ( resolve, reject ) => {
-    if ( !queryString.endsWith ( ';' ) ){
+/**
+ * Executes a query using a connection from a specified pool.
+ * @param {string} queryString - The SQL query to execute.
+ * @param {string} [poolId='main'] - The identifier for the MySQL connection pool.
+ * @returns {Promise<Object>} - A promise that resolves with the query results.
+ */
+exports.query = (queryString, poolId = 'main') => new Promise((resolve, reject) => {
+    if (!queryString.endsWith(';')) {
         queryString += ';';
     }
-    this.getConnection ().then ( connection => newQuery ( connection, queryString ) ).then ( resolve ).catch ( reject );
-} );
+    
+    this.getConnection(poolId)
+        .then(connection => newQuery(connection, queryString))
+        .then(resolve)
+        .catch(reject);
+});
 
-exports.kill = () => new Promise ( resolve => {
-    pool.end ( () => {
-        resolve ();
-    } );
-} );
+/**
+ * Gracefully closes all MySQL connection pools.
+ * @returns {Promise<void>} - A promise that resolves once all pools are closed.
+ */
+exports.kill = () => new Promise(resolve => {
+    const closePromises = Object.keys(pools).map(poolId => 
+        new Promise(poolResolve => {
+            pools[poolId].end(() => {
+                delete pools[poolId];
+                poolResolve();
+            });
+        })
+    );
+    
+    Promise.all(closePromises).then(() => resolve());
+});

package/src/redis.js

@@ -248,26 +248,32 @@ exports.multiGet = async ( keys ) => {
  * @param {*} value - The value to set for the key.
  * @param {string} [ex] - Optional EX parameter to set expiration in seconds.
  * @param {number} [px] - Optional PX parameter to set expiration in milliseconds.
+ * @param {boolean}[nx]  – NX  flag → “only set if key does not exist”
  * @returns {Promise} - A promise that resolves with the result of the SET command.
  *
  * @description This method sets the value for the specified key in Redis.
  * If the value is an object or array, it will be automatically converted to a JSON string before storing.
  * Optionally, you can set an expiration time for the key using the `ex` parameter in seconds or the `px` parameter in milliseconds.
  */
-exports.set = async ( key, value, ex, px ) => {
+exports.set = async ( key, value, ex, px, nx ) => {
     try {
-        if ( typeof key === 'string' ) {
-            const client = await getClient ();
-
-            // Automatically convert objects or arrays to JSON strings
-            const serializedValue = ( typeof value === 'object' && value !== null ) ? JSON.stringify ( value ) : value;
-            const fullKey = ( !config?.redis?.prefix || key.startsWith ( config?.redis?.prefix ) ) ? key : config?.redis?.prefix + key;
-
-            // Use the set method directly with optional EX and PX parameters
-            return await client.set ( fullKey, serializedValue, ...( ex ? [ 'EX', ex ] : [] ), ...( px ? [ 'PX', px ] : [] ) );
-        }
-
-        throw new Error ( `redis.set expects a string key, instead the type provided was: ${typeof key}` );
+        if (typeof key !== 'string')
+            throw new Error(`redis.set expects a string key, got ${typeof key}`);
+      
+          const client = await getClient();
+
+
+          const fullKey = (!config?.redis?.prefix || key.startsWith(config.redis.prefix)) ? key : config.redis.prefix + key;
+          const serialised = (typeof value === 'object' && value !== null) ? JSON.stringify(value) : value;
+      
+          const args = [];
+          if (nx)        args.push('NX');
+          if (ex !== undefined && px !== undefined)
+            throw new Error('redis.set: cannot specify both EX and PX');
+          if (ex !== undefined) args.push('EX', ex);
+          if (px !== undefined) args.push('PX', px);
+      
+          return await client.set(fullKey, serialised, ...args);
     }
     catch ( error ) {
         console.log ( 'REDIS LIB ERROR [set]', error );