@blazedpath/commons 0.0.4

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;

package/blz-rds-mysqlx/syntaxis.json

@@ -0,0 +1,105 @@
+{
+    "selectWithPaging1": "SELECT %1$s LIMIT %4$s",
+    "selectWithPagingN": "SELECT %1$s LIMIT %2$s,%4$s",
+    "insertAutoIncremental": "INSERT INTO %1$s (%4$s) VALUES (%5$s)",
+    "insertConditionalAuto": "INSERT INTO %1$s (%4$s) SELECT %5$s FROM DUAL WHERE NOT EXISTS (SELECT 1 FROM %1$s WHERE %6$s)", 
+    "insertConditionalAutoIncremental": "INSERT INTO %1$s (%4$s) SELECT %5$s FROM DUAL WHERE NOT EXISTS (SELECT 1 FROM %1$s WHERE %6$s)", 
+    "selectExists": "SELECT IF(%1$s, 1, 0)",
+    "executeStoredProcedure": "call %1$s(%2$s)",
+    "procedureResultSet": "implicit",
+    "core" : {
+        "asc": "%1$s ASC",
+        "avg": "ROUND(AVG(%1$s), 8)",
+        "count": "COUNT(%1$s)",
+        "countDistinct": "COUNT(DISTINCT %1$s)",
+        "desc": "%1$s DESC",
+        "divide" : "(%1$s / %2$s)",
+        "distinct": "DISTINCT %1$s",
+        "false" : "0",
+        "isNotNull": "(%1$s IS NOT NULL)",
+        "isNull": "(%1$s IS NULL)",
+        "like": "(%1$s LIKE %2$s)",
+        "max": "MAX(%1$s)",
+        "min": "MIN(%1$s)",
+        "nvl": "IFNULL(%1$s, %2$s)",
+        "parameter": ":%1$s",
+        "remainder": "MOD(%1$s,%2$s)",
+        "sum": "SUM(%1$s)",
+        "true" : "1"
+    },
+    "datetimes" : {
+        "addDays": "DATE_ADD(%1$s, INTERVAL %2$s DAY)",
+        "addHours": "DATE_ADD(%1$s, INTERVAL %2$s HOUR)",
+        "addMilliseconds": "DATE_ADD(%1$s, INTERVAL (%2$s*1000) MICROSECOND)",
+        "addMinutes": "DATE_ADD(%1$s, INTERVAL %2$s MINUTE)",
+        "addSeconds": "DATE_ADD(%1$s, INTERVAL %2$s SECOND)",
+        "date": "STR_TO_DATE('%1$s-%2$s-%3$s 0:0:0', '%Y-%m-%d %H:%i:%S')",
+        "dateDiff": "DATEDIFF(%1$s,%2$s)",
+        "datetime": "STR_TO_DATE('%1$s-%2$s-%3$s %4$s:%5$s:%6$s', '%Y-%m-%d %H:%i:%S')",
+        "datetimeDiff": "TRUNCATE(TIMESTAMPDIFF(MICROSECOND,%2$s,%1$s)/1000,0)",
+        "day": "DAY(%1$s)",
+        "hour": "HOUR(%1$s)",
+        "millisecond": "TRUNCATE(MICROSECOND(%1$s)/1000,0)",
+        "minute": "MINUTE((%1$s))",
+        "month": "MONTH(%1$s)",
+        "monthText": "MONTHNAME(%1$s)",
+        "now": "UTC_TIMESTAMP",
+        "second": "SECOND(%1$s)",
+        "today": "CURDATE()",            
+        "time": "TIME(STR_TO_DATE('2018-1-1 %1$s:%2$s:%3$s', '%Y-%m-%d %H:%i:%S'))",
+        "timeDiff": "TIME_TO_SEC(TIMEDIFF(%1$s,%2$s)) * 1000",
+        "week": "WEEK(%1$s) + 1",
+        "weekDay": "WEEKDAY(%1$s) + 1",
+        "weekDayText": "DATE_FORMAT(%1$s,'%W')",
+        "year": "YEAR(%1$s)"
+    },
+    "math" : {
+        "abs": "ABS(%1$s)",
+        "acos": "ACOS(%1$s)",
+        "asin": "ASIN(%1$s)",
+        "atan": "ATAN(%1$s)",
+        "atan2": "ATAN2(%2$s,%1$s)",
+        "ceil": "CEIL(%1$s)",
+        "cos": "COS(%1$s)",
+        "cosh": "((EXP(%1$s) + EXP(%1$s*-1))/2)",
+        "exp": "EXP(%1$s)",
+        "floor": "FLOOR(%1$s)",
+        "logBase": "LOG(%2$s,%1$s)",
+        "log": "LOG(EXP(1),%1$s)",
+        "log10": "LOG10(%1$s)",
+        "pow": "POW(%1$s,%2$s)",
+        "remainder": "MOD(%1$s,%2$s)",
+        "round": "ROUND(%1$s,0)",
+        "roundWithDecimals": "ROUND(%1$s,%2$s)",
+        "sign": "SIGN(%1$s)",
+        "sin": "SIN(%1$s)",
+        "sinh": "((EXP(%1$s) - EXP(%1$s*-1))/2)",
+        "sqrt": "SQRT(%1$s)",
+        "tan": "TAN(%1$s)",
+        "tanh": "(EXP(%1$s) - EXP(%1$s*-1))/(EXP(%1$s) + EXP(%1$s*-1))",
+        "trunc": "TRUNCATE(%1$s,0)",
+        "truncWithDecimals": "TRUNCATE(%1$s,%2$s)"
+    },
+    "strings": {
+        "concat": "CONCAT_WS('',{[,]})",
+        "contains": "(INSTR(%1$s,%2$s)>0)",
+        "endsWith": "(%1$s LIKE CONCAT('%%',%2$s))",
+        "indexOf": "INSTR(IFNULL(%1$s,''),%2$s)-1",
+        "isNullOrEmpty": "(BINARY COALESCE(%1$s, '')='')",
+        "isNullOrWhiteSpace": "(COALESCE(%1$s, '')='')",
+        "lastIndexOf": "IF(INSTR(COALESCE(REVERSE(%1$s),''),REVERSE(%2$s))=0,-1,INSTR(REVERSE(%1$s),REVERSE(%2$s))-1+LENGTH(%1$s)-LENGTH(%2$s))",
+        "length": "IFNULL(LENGTH(%1$s),0)",
+        "padLeft": "LPAD(%1$s,%2$s,' ')",
+        "padLeftPattern": "LPAD(%1$s,%2$s,%3$s)",
+        "padRight": "RPAD(%1$s,%2$s,' ')",
+        "padRightPattern": "RPAD(%1$s,%2$s,%3$s)",
+        "replace": "REPLACE(%1$s,%2$s,%3$s)",
+        "startsWith": "(%1$s LIKE CONCAT(%2$s,'%%'))",
+        "substring": "SUBSTR(%1$s,%2$s+1,%3$s)",
+        "toLower": "LOWER(%1$s)",
+        "toUpper": "UPPER(%1$s)",
+        "trim": "TRIM(%1$s)",
+        "trimEnd": "RTRIM(%1$s)",
+        "trimStart": "LTRIM(%1$s)"
+    }
+}