eip-cloud-services 1.1.14 → 1.2.0

package/index.js

@@ -3,4 +3,5 @@ exports.redis = require ( './src/redis' );
 exports.s3 = require ( './src/s3' );
 exports.cdn = require ( './src/cdn' );
 exports.lambda = require ( './src/lambda' );
-exports.mysql = require ( './src/mysql' );
+exports.mysql = require ( './src/mysql' );
+exports.mysql8 = require ( './src/mysql8' );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eip-cloud-services",
-  "version": "1.1.14",
+  "version": "1.2.0",
   "description": "Houses a collection of helpers for connecting with Cloud services.",
   "main": "index.js",
   "scripts": {
@@ -22,6 +22,7 @@
     "google-auth-library": "^8.8.0",
     "ioredis": "^5.3.2",
     "mysql": "^2.18.1",
+    "mysql2": "^3.14.4",
     "redis": "^4.6.7"
   }
 }

package/src/mysql8.js

@@ -0,0 +1,141 @@
+// eip-cloud-services/mysql8.js
+'use strict';
+
+const fs = require('fs');
+const mysql = require('mysql2/promise');   // Promise API (app code)
+const mysqlCb = require('mysql2');         // Callback API (for migrations)
+
+// Load config only if ./config exists
+let config = {};
+const configDirPath = `${process.cwd()}/config`;
+if (fs.existsSync(configDirPath) && fs.statSync(configDirPath).isDirectory()) {
+  // eslint-disable-next-line global-require
+  config = require('config');
+}
+
+// Promise pools (existing)
+const pools = {};
+// NEW: Callback pools
+const callbackPools = {};
+
+/** Get promise pool (existing) */
+function getPool(poolId = 'main') {
+  const poolConfig = (config.mysql && (config.mysql[poolId] || config.mysql)) || {};
+
+  if (!pools[poolId]) {
+    pools[poolId] = mysql.createPool({
+      host: poolConfig.host,
+      user: poolConfig.user,
+      password: poolConfig.password,
+      database: poolConfig.database || undefined,
+      connectionLimit: poolConfig.connectionLimit || 10,
+      multipleStatements: poolConfig.multipleStatements !== false,
+      waitForConnections: true,
+      queueLimit: 0,
+      // Works fine with MySQL 8's caching_sha2_password; add TLS in prod as needed
+      // ssl: { minVersion: 'TLSv1.2', rejectUnauthorized: false },
+      // allowPublicKeyRetrieval: true, // only needed for sha256_password without SSL
+    });
+  }
+  return pools[poolId];
+}
+
+/** NEW: Get callback-style pool (for tools like mysql-migrations) */
+function getCallbackPool(poolId = 'main') {
+  const poolConfig = (config.mysql && (config.mysql[poolId] || config.mysql)) || {};
+
+  if (!callbackPools[poolId]) {
+    callbackPools[poolId] = mysqlCb.createPool({
+      host: poolConfig.host,
+      user: poolConfig.user,
+      password: poolConfig.password,
+      database: poolConfig.database || undefined,
+      connectionLimit: poolConfig.connectionLimit || 10,
+      multipleStatements: poolConfig.multipleStatements !== false,
+      waitForConnections: true,
+      queueLimit: 0,
+      // Same note re: TLS / allowPublicKeyRetrieval as above.
+      // ssl: { minVersion: 'TLSv1.2', rejectUnauthorized: false },
+      // allowPublicKeyRetrieval: true,
+    });
+  }
+  return callbackPools[poolId];
+}
+
+// ----- promise query helpers (existing) -----
+async function runQuery(connection, query) {
+  try {
+    const [rows] = await connection.query(query);
+    return rows;
+  } catch (error) {
+    const MAX_ERROR_LENGTH = 500;
+    const MAX_QUERY_LENGTH = 300;
+    const raw = error && (error.stack || error.message || String(error));
+    const shortError = String(raw).slice(0, MAX_ERROR_LENGTH);
+    const shortQuery = String(query).slice(0, MAX_QUERY_LENGTH);
+    console.error('Query Error:', shortError);
+    console.error('Truncated Query:', shortQuery);
+    throw new Error(`There was a problem with query: ${shortError}`);
+  } finally {
+    try { if (connection?.release) connection.release(); } catch {}
+  }
+}
+
+exports.getPool = getPool;
+exports.getCallbackPool = getCallbackPool;           // <-- NEW EXPORT
+
+exports.getConnection = async (poolId = 'main') => {
+  try {
+    const pool = getPool(poolId);
+    const connection = await pool.getConnection();
+    return connection;
+  } catch (error) {
+    console.error(error);
+    console.error('There was a problem getting a new database connection.');
+    throw new Error('There was a problem getting a new database connection.');
+  }
+};
+
+exports.query = async (queryString, poolId = 'main') => {
+  let sql = String(queryString || '');
+  if (!sql.endsWith(';')) sql += ';';
+  const connection = await exports.getConnection(poolId);
+  return runQuery(connection, sql);
+};
+
+/** Delete a promise pool */
+exports.deletePool = async (poolId) => {
+  const pool = pools[poolId];
+  if (!pool) return;
+  await pool.end().catch(() => {});
+  delete pools[poolId];
+};
+
+/** NEW: Delete a callback pool */
+exports.deleteCallbackPool = async (poolId) => {
+  const pool = callbackPools[poolId];
+  if (!pool) return;
+  await new Promise((res) => pool.end(res));
+  delete callbackPools[poolId];
+};
+
+/** Close all pools (promise + callback) */
+exports.kill = async () => {
+  const p1 = Promise.all(
+    Object.keys(pools).map(async (id) => {
+      try { await pools[id].end(); } catch {}
+      delete pools[id];
+    })
+  );
+  const p2 = Promise.all(
+    Object.keys(callbackPools).map(
+      (id) =>
+        new Promise((res) => {
+          try { callbackPools[id].end(() => res()); }
+          catch { res(); }
+          finally { delete callbackPools[id]; }
+        })
+    )
+  );
+  await Promise.all([p1, p2]);
+};

package/src/s3.js

@@ -134,6 +134,10 @@ exports.get = async ( key, bucket = config?.s3?.Bucket, options = {} ) => {
                 data = zlib.unzipSync ( data );
             }
 
+            if ( response.ContentType.includes('image') ) {
+                return data;
+            }
+
             if ( response.ContentType !== 'application/json' && !response.Metadata[ 'tmg-json' ] ) {
                 if ( config?.s3?.logs === 'output' )
                     log ( `S3 [GET]: Returned ${response.ContentType} from ${bucket}/${key}.` );