@blazedpath/commons 0.0.8 → 0.0.9

package/blz-rds-mysqlx/index.js

@@ -18,24 +18,26 @@ process.on('exit', async function () {
 });
 
 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,
+    Backend: {
+        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-oracle/index.js

@@ -31,8 +31,8 @@ const getPool = async function (connection) {
         connection = _.omit(connection, "dataSource", "providerName");
         connection.sessionCallback = makeInitSessionCallback({ schema: connection.schema })
         // Enable instant client mode in Node.js
-        if (process.env.LD_LIBRARY_PATH){
-            oracledb.initOracleClient( { libDir: process.env.LD_LIBRARY_PATH, configDir: '', thin: false} );
+        if (process.env.LD_LIBRARY_PATH) {
+            oracledb.initOracleClient({ libDir: process.env.LD_LIBRARY_PATH, configDir: '', thin: false });
         }
         pool = await oracledb.createPool(connection);
         pool.connectionName = connection.name;
@@ -68,13 +68,13 @@ const tryDatetime = function (value) {
         if (match) {
             const probableDate = new Date(value);
             if (probableDate.toString() !== 'Invalid Date') {
-                return probableDate;  
+                return probableDate;
             }
         }
     }
     return null;
 };
-const convertMilliseconds = function(strMilliseconds) {
+const convertMilliseconds = function (strMilliseconds) {
     if (strMilliseconds) {
         if (strMilliseconds.length < 3)
             strMilliseconds = strMilliseconds.padEnd(3, '0');
@@ -127,15 +127,15 @@ const getParameterType = function (type) {
         case 'VARCHAR2':
             return oracledb.STRING;
         default:
-            return oracledb.STRING    
+            return oracledb.STRING
     }
 }
 
-const getOraParameters = function (parameters,options) {
+const getOraParameters = function (parameters, options) {
     let oraParameters = {};
     if (parameters)
         for (let i = 0; i < parameters.length; i++) {
-            let parameter = parameters[i];            
+            let parameter = parameters[i];
             let oraParameter = {};
             // checks if i need to convert nodejs to oracle representation (bool -> 0,1) etcs
             if (parameter.direction === 'in' || parameter.direction === 'in/out') {
@@ -175,7 +175,7 @@ const getOraParameters = function (parameters,options) {
             if (parameter.isResultSet)
                 oraParameter.type = oracledb.CURSOR;
             else {
-                if (parameter.dbTypes){
+                if (parameter.dbTypes) {
                     const oracleEntry = parameter.dbTypes.find(entry => entry.providerName === 'Oracle');
                     parameter.dbType = getParameterType(oracleEntry.dbType);
                 } else if (parameter.type) {
@@ -193,7 +193,7 @@ const getOraParameters = function (parameters,options) {
     return oraParameters
 }
 
-const getOraOptions = function (options , bindDefs) {
+const getOraOptions = function (options, bindDefs) {
     let oraOptions = { autoCommit: !options.isTransactionRequest };
     if (options && (options.query || options.queryOne)) {
         oraOptions.resultSet = true;
@@ -210,29 +210,29 @@ const convertValueFromType = async function (value, type) {
             return BlzBase.convertToString(value);
         }
         case 'integer': {
-            return  BlzBase.convertToInteger(value);
+            return BlzBase.convertToInteger(value);
         }
         case 'decimal': {
-            return  BlzBase.convertToDecimal(value);
+            return BlzBase.convertToDecimal(value);
         }
         case 'boolean': {
-            return  BlzBase.convertToBoolean(value);
+            return BlzBase.convertToBoolean(value);
         }
         case 'datetime': {
-            return  BlzBase.convertToDatetime(value);
+            return BlzBase.convertToDatetime(value);
         }
         case 'date': {
-            return  BlzBase.convertToDate(value);
+            return BlzBase.convertToDate(value);
         }
         case 'time': {
-            return  BlzBase.convertToTime(value);
+            return BlzBase.convertToTime(value);
         }
         case 'binary': {
-            return  BlzBase.convertToBinary(value);
+            return BlzBase.convertToBinary(value);
         }
-        default:{
+        default: {
             // If i have a clob, or special type, the case might not be straightforward
-            if (value._type.name === 'DB_TYPE_CLOB' ) {
+            if (value._type.name === 'DB_TYPE_CLOB') {
                 return await oraResult.outBinds[parameter.name].getData();
             }
         }
@@ -288,19 +288,19 @@ process.on('exit', async function () {
 });
 
 const getValue = function (source, type) {
-    const _type =  type ? type.toLowerCase() : typeof source   
+    const _type = type ? type.toLowerCase() : typeof source
     switch (_type.toLowerCase()) {
-		case 'boolean':
-			return source ? 1 : 0
-		case 'string':
-			return typeof source === 'string' || source === null || source === undefined ? source : source.toString()
-		case 'datetime':
-		case 'date':
-		case 'time':
-			return source ? new Date(source) : null
-		default:
-			return source
-		}
+        case 'boolean':
+            return source ? 1 : 0
+        case 'string':
+            return typeof source === 'string' || source === null || source === undefined ? source : source.toString()
+        case 'datetime':
+        case 'date':
+        case 'time':
+            return source ? new Date(source) : null
+        default:
+            return source
+    }
 }
 
 /**
@@ -343,10 +343,10 @@ const rowsToArray = function (columns, rows) {
     const columnsCount = columns.length
     for (const row of rows) {
         const item = {}
-        for(let i=0 ; i < columnsCount ; i++) {
-            const column = columns[i]            
+        for (let i = 0; i < columnsCount; i++) {
+            const column = columns[i]
             const value = row[i]
-            item[column.name] = getValue(value,column.type)
+            item[column.name] = getValue(value, column.type)
         }
         array.push(item)
     }
@@ -354,186 +354,191 @@ const rowsToArray = function (columns, rows) {
 }
 
 module.exports = {
-    syntaxis: require('./syntaxis.json'),
-    createRdsConnection: async function (connection) {
-        try {
-            let oraPool = await getPool(connection);
-            let oraConnection = await oraPool.getConnection();            
-            return oraConnection;
-        }
-        catch (err) {
-            throw err;
-        }
-    },
-    executeSql: async function (connection, sql, parameters, options) {
-        if(_.has(options, "bulkInsert")) {
-            return await this._executeBulkInsert(connection, sql, parameters, options);    
-        } else if(_.has(options, "bulkMerge")) {
-            return await this._executeBulkMerge(connection, sql, parameters, options);    
-        } else {
-            return await this._executeSql(connection, sql, parameters, options);
-        }
-    },
-    _executeSql: async function (connection, sql, parameters, options) {
-        try{
-            let oraParameters = getOraParameters(parameters,options);
-            let oraOptions = getOraOptions(options)
-            let oraResult = await connection.execute(sql, oraParameters, oraOptions);
-            const result = await getResult(parameters, oraResult, options);
-            return result;
-        } catch (err) {
-            throw err
-        }
-    },
-    _executeBulkInsert: async function (connection, sql, rows, options) {
-        let autoincremental = null
-        if (options.autoincrementalData && options.autoincrementalData.pkColumnName) { 
-            autoincremental = { name: options.autoincrementalData.pkColumnName ,
-                         alias: options.autoincrementalData.pkColumnAlias,
-                         sequence: options.autoincrementalData.sequenceName,
-                         type: options.autoincrementalData.pkColumnType
-                        }
-        }
-        const _sql = autoincremental ? 
-                    'INSERT INTO ' + options.rdsTable.tableName + 
-                    ' (' + autoincremental.name + ',' + options.setsFields.join(', ') + 
-                    ') VALUES ( ' + autoincremental.sequence + '.NEXTVAL, ' + options.setsFields.map((field) => ':' + field).join(', ') + ' ) ' +
-                    ' RETURNING ' + autoincremental.name + ' INTO :' + autoincremental.name  
-                : sql + '(' +options.setsFields.map((field) => ':' + field).join(', ') + ' ) ' 
-        
-        // solve max size for string fields
-        const columnsCount = options.columns.length        
-		for(let i=0 ; i < columnsCount ; i++) {
-            const column = options.columns[i]
-            if (column.type === 'string') {
-                column.size =  rows.reduce((max, row) => { return !row[i]?0:row[i].length > max ? row[i].length : max }, 0)           
+    Backend: {
+        syntaxis: require('./syntaxis.json'),
+        createRdsConnection: async function (connection) {
+            try {
+                let oraPool = await getPool(connection);
+                let oraConnection = await oraPool.getConnection();
+                return oraConnection;
             }
-        }
-        const bindDefs = {}
-		for (const column of options.columns) {
-            const bindDef = { type:getDbType(column.type) }
-            if (column.type === 'string') {
-                bindDef.maxSize = column.size
+            catch (err) {
+                throw err;
+            }
+        },
+        executeSql: async function (connection, sql, parameters, options) {
+            if (_.has(options, "bulkInsert")) {
+                return await this._executeBulkInsert(connection, sql, parameters, options);
+            } else if (_.has(options, "bulkMerge")) {
+                return await this._executeBulkMerge(connection, sql, parameters, options);
+            } else {
+                return await this._executeSql(connection, sql, parameters, options);
+            }
+        },
+        _executeSql: async function (connection, sql, parameters, options) {
+            try {
+                let oraParameters = getOraParameters(parameters, options);
+                let oraOptions = getOraOptions(options)
+                let oraResult = await connection.execute(sql, oraParameters, oraOptions);
+                const result = await getResult(parameters, oraResult, options);
+                return result;
+            } catch (err) {
+                throw err
+            }
+        },
+        _executeBulkInsert: async function (connection, sql, rows, options) {
+            let autoincremental = null
+            if (options.autoincrementalData && options.autoincrementalData.pkColumnName) {
+                autoincremental = {
+                    name: options.autoincrementalData.pkColumnName,
+                    alias: options.autoincrementalData.pkColumnAlias,
+                    sequence: options.autoincrementalData.sequenceName,
+                    type: options.autoincrementalData.pkColumnType
+                }
+            }
+            const _sql = autoincremental ?
+                'INSERT INTO ' + options.rdsTable.tableName +
+                ' (' + autoincremental.name + ',' + options.setsFields.join(', ') +
+                ') VALUES ( ' + autoincremental.sequence + '.NEXTVAL, ' + options.setsFields.map((field) => ':' + field).join(', ') + ' ) ' +
+                ' RETURNING ' + autoincremental.name + ' INTO :' + autoincremental.name
+                : sql + '(' + options.setsFields.map((field) => ':' + field).join(', ') + ' ) '
+
+            // solve max size for string fields
+            const columnsCount = options.columns.length
+            for (let i = 0; i < columnsCount; i++) {
+                const column = options.columns[i]
+                if (column.type === 'string') {
+                    column.size = rows.reduce((max, row) => { return !row[i] ? 0 : row[i].length > max ? row[i].length : max }, 0)
+                }
+            }
+            const bindDefs = {}
+            for (const column of options.columns) {
+                const bindDef = { type: getDbType(column.type) }
+                if (column.type === 'string') {
+                    bindDef.maxSize = column.size
+                }
+                bindDefs[column.name] = bindDef
             }
-			bindDefs[column.name] = bindDef
-		}
-        if (autoincremental) {
-			bindDefs[autoincremental.name] = { type: getDbType(autoincremental.type), dir: oracledb.BIND_OUT}
-		}
-        const oraOptions = getOraOptions(options,bindDefs)
-        const data = rowsToArray(options.columns,rows)
-        try {   
-            const result = await connection.executeMany(_sql, data, oraOptions)
             if (autoincremental) {
-                const ids = []
-                for (const i in result.outBinds) {
-                    ids.push(result.outBinds[i][autoincremental.name][0])
+                bindDefs[autoincremental.name] = { type: getDbType(autoincremental.type), dir: oracledb.BIND_OUT }
+            }
+            const oraOptions = getOraOptions(options, bindDefs)
+            const data = rowsToArray(options.columns, rows)
+            try {
+                const result = await connection.executeMany(_sql, data, oraOptions)
+                if (autoincremental) {
+                    const ids = []
+                    for (const i in result.outBinds) {
+                        ids.push(result.outBinds[i][autoincremental.name][0])
+                    }
+                    return { rowsAffected: result.rowsAffected, ids }
+                } else {
+                    return { rowsAffected: result.rowsAffected }
                 }
-                return { rowsAffected: result.rowsAffected, ids }
-            } else {
-                return { rowsAffected: result.rowsAffected }
+            } catch (err) {
+                console.log(err)
+                throw err
             }
-        } catch (err) {
-            console.log(err)
-            throw err
-        }       
-    },
-    _executeBulkMerge: async function (connection, sql, rows, options) {
-        // example: https://stackoverflow.com/questions/67881781/how-to-execute-multiple-merge-into-query-on-oracle-db-from-node-js
-        let autoincremental = null
-        if (options.autoincrementalData && options.autoincrementalData.pkColumnName) { 
-            autoincremental = { name: options.autoincrementalData.pkColumnName ,
-                         alias: options.autoincrementalData.pkColumnAlias,
-                         sequence: options.autoincrementalData.sequenceName,
-                         type: options.autoincrementalData.pkColumnType
-                        }
-        }
-        const _sql = []
-        _sql.push('MERGE INTO ' + options.rdsTable.tableName + ' t USING (')        
-        _sql.push('SELECT ')
-        let first = true
-        for (const column of options.columns) {
-            _sql.push((first?'': ', ') + ':' + column.name + ' AS ' + column.name)
-            first = false
-        }
-        _sql.push('FROM DUAL')
-        _sql.push(') s ON (')
-        first = true        
-        for(const field of options.mergeFields) {
-            _sql.push((first?'': ' AND ') + 't.' + field + ' = s.' + field )
-            first = false
-        }
-        _sql.push(')')
-        _sql.push('WHEN MATCHED THEN UPDATE SET ')
-        first = true
-        for(const column of options.columns) {
-            if(options.mergeFields.includes(column.name)) continue
-            _sql.push((first?'': ',') + 't.' + column.name + ' = s.' + column.name)
-            first = false
-        }
-        _sql.push('WHEN NOT MATCHED THEN INSERT (')
-        if(autoincremental) {
-            _sql.push(autoincremental.name)
-            for(const column of options.columns) {
-                _sql.push(',' + column.name)
+        },
+        _executeBulkMerge: async function (connection, sql, rows, options) {
+            // example: https://stackoverflow.com/questions/67881781/how-to-execute-multiple-merge-into-query-on-oracle-db-from-node-js
+            let autoincremental = null
+            if (options.autoincrementalData && options.autoincrementalData.pkColumnName) {
+                autoincremental = {
+                    name: options.autoincrementalData.pkColumnName,
+                    alias: options.autoincrementalData.pkColumnAlias,
+                    sequence: options.autoincrementalData.sequenceName,
+                    type: options.autoincrementalData.pkColumnType
+                }
             }
-            _sql.push(') VALUES (')
-            _sql.push(autoincremental.sequence + '.NEXTVAL')
-            for(const column of options.columns) {
-                _sql.push(',s.' + column.name)
+            const _sql = []
+            _sql.push('MERGE INTO ' + options.rdsTable.tableName + ' t USING (')
+            _sql.push('SELECT ')
+            let first = true
+            for (const column of options.columns) {
+                _sql.push((first ? '' : ', ') + ':' + column.name + ' AS ' + column.name)
+                first = false
             }
-        } else {
+            _sql.push('FROM DUAL')
+            _sql.push(') s ON (')
             first = true
-            for(const column of options.columns) {
-                _sql.push((first?'': ',') + column.name)
+            for (const field of options.mergeFields) {
+                _sql.push((first ? '' : ' AND ') + 't.' + field + ' = s.' + field)
                 first = false
             }
-            _sql.push(') VALUES (')
+            _sql.push(')')
+            _sql.push('WHEN MATCHED THEN UPDATE SET ')
             first = true
-            for(const column of options.columns) {
-                _sql.push((first?'': ',') + 's.' + column.name)
+            for (const column of options.columns) {
+                if (options.mergeFields.includes(column.name)) continue
+                _sql.push((first ? '' : ',') + 't.' + column.name + ' = s.' + column.name)
                 first = false
             }
-        }
-        _sql.push(')')
-        const mergeSql = _sql.join(' ')
-        
-        // solve max size for string fields
-        const columnsCount = options.columns.length        
-		for(let i=0 ; i < columnsCount ; i++) {
-            const column = options.columns[i]
-            if (column.type === 'string') {
-                column.size =  rows.reduce((max, row) => { return !row[i]?0:row[i].length > max ? row[i].length : max }, 0)           
+            _sql.push('WHEN NOT MATCHED THEN INSERT (')
+            if (autoincremental) {
+                _sql.push(autoincremental.name)
+                for (const column of options.columns) {
+                    _sql.push(',' + column.name)
+                }
+                _sql.push(') VALUES (')
+                _sql.push(autoincremental.sequence + '.NEXTVAL')
+                for (const column of options.columns) {
+                    _sql.push(',s.' + column.name)
+                }
+            } else {
+                first = true
+                for (const column of options.columns) {
+                    _sql.push((first ? '' : ',') + column.name)
+                    first = false
+                }
+                _sql.push(') VALUES (')
+                first = true
+                for (const column of options.columns) {
+                    _sql.push((first ? '' : ',') + 's.' + column.name)
+                    first = false
+                }
             }
-        }
-        const bindDefs = {}
-		for (const column of options.columns) {
-            const bindDef = { type:getDbType(column.type) }
-            if (column.type === 'string') {
-                bindDef.maxSize = column.size
+            _sql.push(')')
+            const mergeSql = _sql.join(' ')
+
+            // solve max size for string fields
+            const columnsCount = options.columns.length
+            for (let i = 0; i < columnsCount; i++) {
+                const column = options.columns[i]
+                if (column.type === 'string') {
+                    column.size = rows.reduce((max, row) => { return !row[i] ? 0 : row[i].length > max ? row[i].length : max }, 0)
+                }
             }
-			bindDefs[column.name] = bindDef
-		}
-        const oraOptions = getOraOptions(options,bindDefs)
-        const data = rowsToArray(options.columns,rows)
-        try {   
-            const result = await connection.executeMany(mergeSql, data, oraOptions)
-            return { rowsAffected: result.rowsAffected }
-        } catch (err) {
-            console.log(err)
-            throw err
-        }       
-    },
-    close(nativeConnection) {
-        return nativeConnection.close();
-    },
-    beginTransaction(nativeConnection) {
-        //se utiliza la variable isTransactionRequest
-    },
-    commitTransaction(nativeConnection) {
-        return nativeConnection.commit();
-    },
-    rollbackTransaction(nativeConnection) {
-        return nativeConnection.rollback();
+            const bindDefs = {}
+            for (const column of options.columns) {
+                const bindDef = { type: getDbType(column.type) }
+                if (column.type === 'string') {
+                    bindDef.maxSize = column.size
+                }
+                bindDefs[column.name] = bindDef
+            }
+            const oraOptions = getOraOptions(options, bindDefs)
+            const data = rowsToArray(options.columns, rows)
+            try {
+                const result = await connection.executeMany(mergeSql, data, oraOptions)
+                return { rowsAffected: result.rowsAffected }
+            } catch (err) {
+                console.log(err)
+                throw err
+            }
+        },
+        close(nativeConnection) {
+            return nativeConnection.close();
+        },
+        beginTransaction(nativeConnection) {
+            //se utiliza la variable isTransactionRequest
+        },
+        commitTransaction(nativeConnection) {
+            return nativeConnection.commit();
+        },
+        rollbackTransaction(nativeConnection) {
+            return nativeConnection.rollback();
+        }
     }
+
 };

package/blz-rds-postgres/index.js

@@ -18,24 +18,26 @@ process.on('exit', async function () {
 });
 
 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,
+    Backend: {
+        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
+    }
 }