@blazedpath/commons 0.2.2 → 0.3.1

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

@@ -1,141 +0,0 @@
-"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

@@ -1,35 +0,0 @@
-"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

@@ -1,45 +0,0 @@
-"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

@@ -1,29 +0,0 @@
-"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

@@ -1,39 +0,0 @@
-"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

@@ -1,41 +0,0 @@
-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

@@ -1,179 +0,0 @@
-"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;