add snowflake connection pool

Author: mlvogel1214

index.js

@@ -2,8 +2,7 @@
 /* eslint-disable no-restricted-syntax */
 /* eslint-disable no-await-in-loop */
 /* eslint-disable no-else-return */
-const mysql = require("mysql");
-const fs = require('fs');
+const snowflake = require("snowflake-sdk");
 
 let pools = {};
 let config = {};
@@ -13,73 +12,64 @@ exports.init = async (cfg) => {
   config = cfg;
 };
 
-exports.createPool = async (poolName) => {
+exports.createSnowPool = async (poolName) => {
   try {
     const srcCfg = config.DATASOURCES[poolName];
     if (srcCfg) {
       const options = {
-        connectionLimit: srcCfg.DB_CONNECTION_LIMIT || 5,
-        host: srcCfg.DB_HOST,
-        user: srcCfg.DB_USER,
+        account: srcCfg.DB_HOST,
+        username: srcCfg.DB_USER,
         password: srcCfg.DB_PASSWORD,
         database: srcCfg.DB_DATABASE,
         port: srcCfg.PORT,
-        multipleStatements: srcCfg.ALLOW_MULTI_STATEMENTS || false,
-        timezone: srcCfg.TIMEZONE || 'local',
-        typeCast: srcCfg.TYPE_CAST || true,
-        dateStrings: srcCfg.DATE_STRINGS || false
+        schema: srcCfg.SCHEMA
       };
 
-      if (srcCfg.SSL) {
-        const sslConfig = {};
-
-        if (srcCfg.SSL.CUSTOM_CERT) {
-          sslConfig.ca = srcCfg.SSL.CUSTOM_CERT;
-        } else {
-          sslConfig.rejectUnauthorized = srcCfg.SSL.hasOwnProperty('REJECT_UNAUTHORIZED') ? srcCfg.SSL.REJECT_UNAUTHORIZED : true;
-        }
-
-        options.ssl = sslConfig;
-      }
-
-      pools[poolName] = mysql.createPool(options);
-      console.debug(`MySQL Adapter: Pool ${poolName} created`);
+      pools[poolName] = snowflake.createPool(options, { max: 10, min: 0 });
+      console.debug(`Snowflake Adapter: Pool ${poolName} created`);
       return true;
     } else {
-      console.error(`MySQL Adapter: Missing configuration for ${poolName}`);
+      console.error(`Snowflake Adapter: Missing configuration for ${poolName}`);
       return false;
     }
   } catch (err) {
-    console.error("MySQL Adapter: Error while closing connection", err);
+    console.error("Snowflake Adapter: Error while closing connection", err);
     return false;
   }
 };
 
 exports.connect = async (poolName) => {
   try {
     if (!pools[poolName]) {
-      await this.createPool(poolName);
+      await this.createSnowPool(poolName);
     }
     return pools[poolName];
   } catch (err) {
-    console.error("MySQL Adapter: Error while retrieving a connection", err);
+    console.error("Snowflake Adapter: Error while retrieving a connection", err);
     throw new Error(err.message);
   }
 };
 
 this.query = async (conn, query, params) => {
   return new Promise((resolve, reject) => {
     try {
-      conn.query(query, params, (error, results) => {
-        if (error) {
-          console.error("MySQL Adapter:  Failure in query: ", error);    
-          this.handleError(reject, error);
-        } else {
-          resolve(results);
-        }
+      conn.use( async (clientConnection) => {
+        await clientConnection.execute({
+          sqlText: query,
+          binds: params ? params : [],
+          complete: async (err, stmt, rows) => {
+            if (err) {
+              console.error("Failed to execute statement due to the following error: " + err.message);
+              reject();
+            } else {
+              console.log("Successfully executed statement: " + stmt.getSqlText());
+              resolve(rows);
+            }
+          }
+        })
       });
     } catch (err) {
-      console.error("MySQL Adapter:  Failure in query: ", err);
+      console.error("Snowflake Adapter:  Failure in query: ", err);
       this.handleError(reject, err);
     }
   });
@@ -101,21 +91,21 @@ exports.execute = async (srcName, query, params = {}) => {
     const conn = await this.connect(srcName);
 
     console.debug(
-      `MySQL Adapter: Connection secured: ${process.hrtime(start)[0]}s ${
+      `Snowflake Adapter: Connection secured: ${process.hrtime(start)[0]}s ${
         process.hrtime(start)[1] / 1000000
       }ms`
     );
     const results = await this.query(conn, query, params);
 
     console.debug(
-      `MySQL Adapter: Query executed: ${process.hrtime(start)[0]}s ${
+      `Snowflake Adapter: Query executed: ${process.hrtime(start)[0]}s ${
         process.hrtime(start)[1] / 1000000
       }ms`
     );
 
     return results;
   } catch (err) {
-    console.error("MySQL Adapter: Error while executing query", err);
+    console.error("Snowflake Adapter: Error while executing query", err);
     throw new Error(err.message);
   }
 };
@@ -125,11 +115,11 @@ exports.closeAllPools = async () => {
     for (const poolAlias of Object.keys(pools)) {
       await this.closePool(poolAlias);
       delete pools[poolAlias];
-      console.debug(`MySQL Adapter: Pool ${poolAlias} closed`);
+      console.debug(`Snowflake Adapter: Pool ${poolAlias} closed`);
     }
     return true;
   } catch (err) {
-    console.error("MySQL Adapter: Error while closing connection", err);
+    console.error("Snowflake Adapter: Error while closing connection", err);
     return false;
   }
 };
@@ -152,7 +142,7 @@ exports.closePool = async (poolAlias) => {
       return true;
     }
   } catch (err) {
-    console.error("MySQL Adapter: Error while closing connection", err);
+    console.error("Snowflake Adapter: Error while closing connection", err);
     return false;
   }
 };