@blazedpath/commons 0.3.1 → 0.4.0

package/blz-rds-mysqlx/connection-manager.js

@@ -0,0 +1,141 @@
+"use strict";
+const mysqlx = require('@mysql/xdevapi');
+const BlzBase = require("./base");
+const _ = require("underscore");
+
+//https://dev.mysql.com/doc/dev/connector-nodejs/8.0/tutorial-Connecting_to_a_Server.html
+//https://dev.mysql.com/doc/connector-j/8.0/en/connector-j-reference-jdbc-url-format.html
+//https://dev.mysql.com/doc/refman/8.0/en/connecting-using-uri-or-key-value-pairs.html
+
+let poolsByName = new Map();
+
+function getParameters(config = {}) {
+    let properties = _.reduce(config.properties, (memo, value) => {
+        return memo + "," + value.key + "=" + value.value;
+    }, '');
+    return properties.slice("1");
+}
+
+function getObjectConfig(config = {}) {
+    if(!config.name) {
+        throw BlzBase.error('RdsMySqlException', { name: config.name });
+    }
+    let url = '';
+    if(config.customUrl) {
+        url = getCustomURL(config);
+    } else {
+        url = getURL(config);
+    }
+    let parameters = getParameters(config);
+    if(!_.isEmpty(parameters)) {
+        parameters = `?${parameters}`
+    }
+    return `${url}${parameters}`
+}
+
+function getURL(config = {}) {
+    return `mysqlx://${config.user}:${config.password}@${config.host}:${config.port || 33060}/${config.database}`
+}
+
+function getCustomURL(config = {}) {
+    return `${config.protocol}://${config.url}`
+}
+
+function getPoolConfig(config = {}) {
+    let poolConfig = _.pick(config, "maxSize", "maxIdleTime", "queueTimeout");
+    return _.defaults(poolConfig, {
+        enabled: true,
+        maxSize: 25,
+        maxIdleTime: 0,
+        queueTimeout: 0
+    });
+}
+
+async function getPool(config = {}) {    
+    let key = config.name;
+    let pool = poolsByName.get(key);
+    if(pool) {
+        return pool;
+    }
+    let uri = getObjectConfig(config);
+    try {
+        pool = await mysqlx.getClient(uri, { pooling: getPoolConfig(config) });
+    } catch(error)  {
+        throw BlzBase.error('RdsMysqlCannotCreatePool', { config, uri }, error);
+    }    
+    pool.name = config.name;
+    poolsByName.set(key, pool);
+    return pool;
+}
+
+async function getConnection(pool) {    
+    let session;
+    try {
+        session = await pool.getSession();
+    } catch(error) {        
+        throw BlzBase.error('RdsMysqlCannotConnectToDatabase', { name: pool.name }, error);
+    }
+    session.name = pool.name;
+    return session;
+}
+
+async function terminate() {
+    let reject = [];
+    for (const [, pool] of poolsByName) {
+        try {
+            await pool.close();
+        } catch(error) {
+            reject.push(error);
+        }        
+    }
+    poolsByName.clear();
+    if(_.isEmpty(reject)) {
+        return true;
+    }
+    throw new Error(reject);
+}
+
+const createConnection = async (config) => await getConnection(await getPool(config));
+
+
+const beginTransaction = async function(connection) {            
+    try {
+        await connection.startTransaction();
+    } catch(error) {
+        throw BlzBase.error('RdsMySqlBeginTransactionError', { name: connection.name }, error);
+    }
+};
+
+const commitTransaction = async function(connection) {
+    try {
+        await connection.commit();
+    } catch(error) {
+        throw BlzBase.error('RdsMySqlCommitTransactionError', { name: connection.name }, error);
+    }
+};
+
+const rollbackTransaction = async function(connection) {
+    try {
+        await connection.rollback();
+    } catch(error) {
+        throw BlzBase.error('RdsMySqlRollbackTransactionError', { name: connection.name }, error);
+    }
+};
+
+const close = async function(connection) {
+    try {
+        await connection.close();
+    } catch(error) {
+        throw BlzBase.error('RdsMySqlCloseError', { name: connection.name }, error);
+    }
+}
+
+
+module.exports = {
+    beginTransaction,
+    close,
+    commitTransaction,
+    createConnection,    
+    rollbackTransaction,
+    terminate
+}

package/blz-rds-mysqlx/execute-bulk-insert.js

@@ -0,0 +1,35 @@
+"use strict";
+const {convertValueToDb } = require("./execute-non-query");
+const BlzBase = require("./base");
+
+async function executeBulkInsert(connection, sql, rows, options) {
+    const query = sql + ' ?'    
+    const list = []
+    for(let i = 0; i < rows.length; i++) {
+        const row = rows[i]
+        const values = []
+        for(let j = 0; j < row.length; j++) {
+            const value = convertValueToDb(row[j])
+            values.push(value)
+        }
+        list.push(values)
+    }
+    return new Promise(function(resolve, reject){
+        connection.query(query, [list], function(error, result, fields) {
+            if(error) {
+                reject(BlzBase.error('RdsMySqlExecuteError', { name: connection.name, query, rows }, error));
+                return;
+            }
+            if (options.autoincrementalData) { 
+                const start = result.insertId
+                const end = result.insertId + (result.affectedRows - 1)
+                const ids= []
+                for (let i = start; i <= end; i++)ids.push(i)
+                resolve({ ids, affectedRows: result.affectedRows });
+            } else {
+                resolve({affectedRows: result.affectedRows});
+            }            
+        })
+    })
+}
+module.exports = executeBulkInsert;

package/blz-rds-mysqlx/execute-bulk-merge.js

@@ -0,0 +1,45 @@
+"use strict";
+const {convertValueToDb } = require("./execute-non-query");
+const BlzBase = require("./base");
+const SqlString = require('sqlstring')
+
+async function executeBulkMerge(connection, sql, rows, options) {
+    const list = []
+    for(let i = 0; i < rows.length; i++) {
+        const row = rows[i]
+        const values = []          
+        for(let j = 0; j < row.length; j++) {
+            const column = options.columns[j]
+            let value = convertValueToDb(row[j])
+            if ( ['string','date','datetime','time'].includes(column.type)) {
+                value = SqlString.escape(value)
+            }
+            values.push(value)
+        }
+        list.push(`(${values.join(',')})`)
+    }
+    const _sql = []
+    _sql.push('INSERT INTO ' + options.rdsTable.tableName + ' (')
+    _sql.push(options.setsFields.map(p=> '`'+p+'`').join(', '))    
+    _sql.push(')\n\rVALUES\n\r')
+    _sql.push(list.join(','))
+    _sql.push('\n\rON DUPLICATE KEY UPDATE\n\r')
+    let first = true
+    for( const field of options.setsFields.map(p=> '`'+p+'`')) {
+        _sql.push((first? ' ': ',\n\r ') + field + ' = VALUES(' + field + ')')
+        first = false
+    }
+    _sql.push(';')
+    const query = _sql.join('')
+
+    return new Promise(function(resolve, reject){
+        connection.query(query, null, function(error, result, fields) {
+            if(error) {
+                reject(BlzBase.error('RdsMySqlExecuteError', { name: connection.name, query, rows }, error));
+                return;
+            }
+            resolve({affectedRows: result.affectedRows});
+        })
+    })
+}
+module.exports = executeBulkMerge;

package/blz-rds-mysqlx/execute-non-query.js

@@ -0,0 +1,29 @@
+"use strict";
+const _ = require('underscore');
+const toUnnamed = require('named-placeholders')();
+const BlzBase = require("./base");
+
+async function executeNonQuery(connection, sql, rdsParameters, withGeneratedKey) {
+    let query = sql, parameters = [], rs = null;
+    try {
+        if(!_.isEmpty(rdsParameters)) {
+            [query, parameters] = toUnnamed(sql, BlzBase.reduceParameters(rdsParameters));
+        }
+    } catch(error) {
+        throw BlzBase.error('RdsMySqlExecuteError', { name: connection.name, sql, parameters }, error);
+    }
+    try {
+        rs = await connection
+            .sql(query)
+            .bind(parameters)
+            .execute();
+    } catch(error) {
+        throw BlzBase.error('RdsMySqlExecuteError', { name: connection.name, sql, parameters }, error);
+    }
+    return {
+        rowsAffected: rs.getAffectedItemsCount(),
+        id: rs.getAutoIncrementValue()
+    }
+}
+
+module.exports = { executeNonQuery }

package/blz-rds-mysqlx/execute-query.js

@@ -0,0 +1,39 @@
+"use strict";
+const _ = require('underscore');
+const toUnnamed = require('named-placeholders')();
+const BlzBase = require("./base");
+
+async function executeQuery(connection, sql, rdsParameters = [], options = {}) {
+    let query = sql, parameters = [], resultSet;
+    try {
+        if(!_.isEmpty(rdsParameters)) {
+            [query, parameters] = toUnnamed(sql, BlzBase.reduceParameters(rdsParameters, options));
+        }
+    } catch(error) {
+        throw BlzBase.error('RdsMySqlExecuteError', { name: connection.name, sql, parameters }, error);
+    }    
+    try {        
+        resultSet = ResultSet(await connection
+            .sql(query)
+            .bind(parameters)
+            .execute());
+    } catch(error) {
+        throw BlzBase.error('RdsMySqlExecuteError', { name: connection.name, sql, parameters }, error);        
+    }
+    return {
+        resultSet
+    }
+}
+
+function ResultSet(rowResult) {
+    return {
+        getRow: async function() {
+            return rowResult.fetchOne();
+        },
+        close: async function() {
+            return true;
+        }
+    }
+}
+
+module.exports = executeQuery;

package/blz-rds-mysqlx/index.js

@@ -0,0 +1,41 @@
+const _ = require("underscore");
+const { executeNonQuery } = require("./execute-non-query");
+const executeQuery = require("./execute-query");
+const executeProcedure = require("./stored-procedure");
+const executeBulkInsert = require("./execute-bulk-insert");
+const executeBulkMerge = require("./execute-bulk-merge");
+const {
+    beginTransaction,
+    close,
+    commitTransaction,
+    createConnection: createRdsConnection,
+    rollbackTransaction,
+    terminate
+} = require("./connection-manager");
+
+process.on('exit', async function () {
+    await terminate();
+});
+
+module.exports = {
+    syntaxis: require("./syntaxis.json"),    
+    executeProcedure,    
+    executeSql: async function (connection, sql, parameters, options = {}) {
+        if(sql.indexOf("call") != -1 ) {
+            return await executeProcedure(connection, sql, parameters);
+        } else if(_.has(options, "bulkInsert")) {
+            return await executeBulkInsert(connection, sql, parameters, options); 
+        } else if(_.has(options, "bulkMerge")) {
+            return await executeBulkMerge(connection, sql, parameters, options);            
+        } else if(_.has(options, "queryOne") || _.has(options, "query")) {
+            return await executeQuery(connection, sql, parameters, options);
+        } else {
+            return await executeNonQuery(connection, sql, parameters, options);
+        }
+    },
+    beginTransaction,    
+    close,
+    createRdsConnection,
+    commitTransaction,
+    rollbackTransaction,
+}

package/blz-rds-mysqlx/stored-procedure.js

@@ -0,0 +1,179 @@
+"use strict";
+const mysqlx = require('@mysql/xdevapi');
+const _ = require('underscore');
+const BlzBase = require("./base");
+const toString = Object.prototype.toString;
+//https://dev.mysql.com/doc/dev/connector-nodejs/8.0/tutorial-Getting_Started.html
+//https://dev.mysql.com/doc/x-devapi-userguide/en/using-sql.html
+//https://dev.mysql.com/doc/refman/8.0/en/faqs-stored-procs.html#faq-mysql-can-pass-cursor-in
+
+function tryDatetime(value) {
+    let convertMilliseconds = function(strMilliseconds) {
+        if (strMilliseconds) {
+            if (strMilliseconds.length < 3)
+                strMilliseconds = strMilliseconds.padEnd(3, '0');
+            if (strMilliseconds.length > 3)
+                strMilliseconds = strMilliseconds.substr(0, 3);
+            return Number(strMilliseconds);
+        }
+        else
+            return 0;
+    };
+    let strType = toString.call(value);
+    if (strType === '[object Date]') {
+        return value;
+    }
+    else if (strType === '[object String]') {
+        let match = /^(\d{4})-(\d{1,2})-(\d{1,2})[T,\s](\d{1,2})\:(\d{1,2})\:(\d{1,2})\.?(\d+)?Z?$/.exec(value);
+        if (match)
+            return new Date(Date.UTC(Number(match[1]), Number(match[2]) - 1, Number(match[3]), Number(match[4]), Number(match[5]), Number(match[6] || 0), convertMilliseconds(match[7])));
+    }
+    return null;
+}
+
+function convertValueToDb (value) {
+    if (_.isUndefined(value)) {
+        return null;
+    }
+    if(_.isNull(value)) {
+        return null;
+    }
+    if (value === true) {
+        return 1;
+    }        
+    if (value === false) {
+        return 0;
+    }        
+    let datetime = tryDatetime(value);
+    if (datetime) {
+        let result = datetime.toJSON();
+        if (result.length === 24) {
+            result = result.substring(0, 19);
+        }            
+        return result;
+    }
+    return value;
+}
+/** 
+ * @typedef {Object} Parameter
+ * @property {boolean} isResultSet
+ * @property {string} name
+ * @property {*} value
+ * @property { 'in' | 'out' | 'in/out' } direction
+ * @property {'string' | 'integer' | 'decimal' | 'boolean' | 'datetime' | 'date' | 'time' | 'binary'} type
+ */
+
+ /**
+  * 
+  * @param {mysqlx.Session} session
+  * @param {Parameter} parameter
+  * @param {*} result 
+  */
+async function parseOutputParameters(session, parameter, result, time_stamp) {    
+    let resultSet = null, value = null;
+    try {
+        resultSet = await session.sql(`SELECT @${parameter.name}_${time_stamp};`).execute();     
+    } catch(error) {
+        throw BlzBase.error('RdsMysqlCannotConvertParameters', { parameter, result, time_stamp }, error);
+    }    
+    [ value ] = resultSet.fetchOne();
+    if(parameter.isResultSet) {
+        result[parameter.name] = JSON.parse(value);
+        return;
+    }    
+    switch (parameter.type) {
+        case 'string':
+            result[parameter.name] = BlzBase.convertToString(value);
+            break;
+        case 'integer':
+            result[parameter.name] = BlzBase.convertToInteger(value);
+            break;
+        case 'decimal':
+            result[parameter.name] = BlzBase.convertToDecimal(value);
+            break;
+        case 'boolean':
+            result[parameter.name] = BlzBase.convertToBoolean(value);
+            break;
+        case 'datetime':
+            result[parameter.name] = BlzBase.convertToDatetime(value);
+            break;
+        case 'date':
+            result[parameter.name] = BlzBase.convertToDate(value);
+            break;
+        case 'time':
+            result[parameter.name] = BlzBase.convertToTime(value);
+            break;
+        case 'binary':
+            result[parameter.name] = BlzBase.convertToBinary(value);
+            break;
+        default:
+            throw BlzBase.error('RdsMySqlUnexpectedType', { parameter, result, value });
+    }
+
+}
+/**
+ * @param {mysqlx.Session} session 
+ * @param {string} procedure 
+ * @param {[Parameter]} [parameters=[]]
+ * @param {number} time_stamp
+ * @returns {string}
+ */
+async function parseInputParameters(session, procedure, parameters, time_stamp) {
+    for(const parameter of parameters) {
+        switch(parameter.direction) {
+            case "in":
+            case "in/out":
+                try {
+                    await session
+                        .sql(`SET @${parameter.name}_${time_stamp} = ?;`)
+                        .bind(convertValueToDb(parameter.value))
+                        .execute();
+                } catch (error) {
+                    throw BlzBase.error('RdsMySqlInputParameterType', { parameters, time_stamp });
+                }
+                procedure = procedure
+                    .replace(`:${parameter.name}`, `@${parameter.name}_${time_stamp}`);
+                break;
+            case "out":
+                try {
+                    await session
+                        .sql(`SET @${parameter.name}_${time_stamp} = NULL;`)
+                        .execute();
+                } catch(error) {
+                    throw BlzBase.error('RdsMySqlInputParameterType', { parameters, time_stamp });
+                }
+                procedure = procedure
+                    .replace(`:${parameter.name}`, `@${parameter.name}_${time_stamp}`);
+                break;
+        }
+    }
+    return procedure;
+}
+/**
+ * @param {mysqlx.Session} session 
+ * @param {string} procedure 
+ * @param {[Parameter]} [parameters=[]]
+ */
+async function executeProcedure(session, procedure, parameters) {
+    const time_stamp = Date.now();    
+    if(_.isArray(parameters)) {
+        procedure = await parseInputParameters(session, procedure, parameters, time_stamp);
+    }
+    try {
+        await session
+            .sql(procedure)
+            .execute();
+    } catch (error) {
+        throw BlzBase.error('RdsMysqlCannotExecuteProcedure', { session, procedure, parameters }, error);
+    }
+    let outParameters = {};
+    for(const parameter of parameters) { 
+        if(parameter.direction == "in") {
+            continue;
+        }
+        await parseOutputParameters(session, parameter, outParameters, time_stamp);
+    }
+    return { outParameters };
+}
+
+module.exports = executeProcedure;