@blazedpath/commons 0.3.1 → 0.4.0

package/blz-rds-oracle/index.js

@@ -0,0 +1,539 @@
+const oracledb = require("oracledb");
+const _ = require("underscore");
+const { h3lp } = require('h3lp');
+// check blzBase location
+const Path = require('path');
+const Fs = require('fs-extra');
+const blzBaseSuite = Path.resolve(__dirname, '../blz-core/sources-dual/index.js');
+let BlzBase = null;
+if (Fs.existsSync(blzBaseSuite)) {
+    BlzBase = require('../../blz-core/sources-dual/index.js');
+} else {
+    BlzBase = require('../blz-core/index.js');
+}
+oracledb.fetchAsBuffer = [oracledb.BLOB];
+oracledb.fetchAsString = [oracledb.CLOB, oracledb.DATE, oracledb.NUMBER];
+
+let poolsByName = Object.create(null);
+
+const getPool = async function (connection) {
+    try {
+        if (!connection.name) {
+            throw new Error('You must provide a connnection name');
+        }
+        let key = connection.name;
+        let pool = poolsByName[key];
+        if (pool) {
+            return pool;
+        }
+
+        connection.connectString = connection.dataSource;
+        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} );
+        }
+        pool = await oracledb.createPool(connection);
+        pool.connectionName = connection.name;
+        poolsByName[key] = pool;
+        return pool;
+    }
+    catch (err) {
+        throw new Error('Oracle cannot create pool for ' + connection.name + ': ' + err.message);
+    }
+};
+
+const makeInitSessionCallback = ({ schema } = {}) => (oraConnection, requestedTag, callbackFn) => {
+    const sessionSets = [
+        ['NLS_DATE_FORMAT', `'YYYY-MM-DD"T"hh24:mi:ss'`],
+        schema ? ['CURRENT_SCHEMA', `${schema}`] : undefined
+    ]
+
+    const sessionSetsString = sessionSets
+        .filter(Boolean)
+        .map(([key, value]) => `${key}=${value}`)
+        .join(' ')
+
+    oraConnection.execute(`ALTER SESSION SET ${sessionSetsString}`, callbackFn)
+}
+
+const tryDatetime = function (value) {
+    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) {
+            const probableDate = new Date(value);
+            if (probableDate.toString() !== 'Invalid Date') {
+                return probableDate;  
+            }
+        }
+    }
+    return null;
+};
+const 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;
+};
+
+const convertResultSetToArray = function (resultSet, results) {
+    return resultSet.getRow()
+        .then((row) => {
+            if (row) {
+                results.push(row);
+                return convertResultSetToArray(resultSet, results);
+            }
+            else
+                return resultSet.close()
+                    .then(() => {
+                        return results;
+                    });
+        })
+        .catch((err) => {
+            resultSet.close();
+            throw BlzBase.error('ErrorFetchingRowsForConnection', {}, err);
+        });
+}
+
+const getParameterType = function (type) {
+    switch (type) {
+        case 'string':
+            return oracledb.STRING
+        case 'integer':
+        case 'decimal':
+        case 'boolean':
+            return oracledb.NUMBER
+        case 'datetime':
+        case 'date':
+        case 'time':
+            return oracledb.DATE
+        case 'binary':
+            return oracledb.BUFFER
+        case 'CLOB':
+            return oracledb.CLOB;
+        case 'BLOB':
+            return oracledb.CLOB;
+        case 'VARCHAR':
+        case 'VARCHAR2':
+            return oracledb.STRING;
+        default:
+            return oracledb.STRING    
+    }
+}
+
+const getOraParameters = function (parameters,options) {
+    let oraParameters = {};
+    if (parameters)
+        for (let i = 0; i < parameters.length; 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') {
+                if (parameter.value === undefined || parameter.value === null)
+                    oraParameter.val = null;
+                else if (parameter.value === true)
+                    oraParameter.val = 1;
+                else if (parameter.value === false)
+                    oraParameter.val = 0;
+                else {
+                    if (parameter.columnInfo && parameter.columnInfo.type === 'string') {
+                        oraParameter.val = parameter.value
+                    } else {
+                        let datetime = tryDatetime(parameter.value);
+                        if (datetime) {
+                            oraParameter.val = datetime;
+                            // Old Date management                                              
+                            // let tmp = datetime.toJSON();
+                            // if (tmp.length === 24)
+                            //     tmp = tmp.substring(0, 19);
+                            // oraParameter.val = tmp;
+                        }
+                        else {
+                            oraParameter.val = parameter.value;
+                        }
+                    }
+                }
+            }
+            // binds de in out
+            if (parameter.direction === 'in')
+                oraParameter.dir = oracledb.BIND_IN;
+            else if (parameter.direction === 'in/out')
+                oraParameter.dir = oracledb.BIND_INOUT;
+            else if (parameter.direction === 'out')
+                oraParameter.dir = oracledb.BIND_OUT;
+            // selects the parameter type
+            if (parameter.isResultSet)
+                oraParameter.type = oracledb.CURSOR;
+            else {
+                if (parameter.dbTypes){
+                    const oracleEntry = parameter.dbTypes.find(entry => entry.providerName === 'Oracle');
+                    parameter.dbType = getParameterType(oracleEntry.dbType);
+                } else if (parameter.type) {
+                    parameter.dbType = getParameterType(parameter.type);
+                }
+                else {
+                    parameter.dbType = inferDbTypeFromValue(parameter.value);
+                }
+                oraParameter.type = parameter.dbType;
+            }
+            oraParameters[parameter.name] = oraParameter;
+        }
+    if (options && options.autoincrementalData)
+        oraParameters['ScalarOutput'] = { val: null, dir: oracledb.BIND_OUT, type: oracledb.NUMBER };
+    return oraParameters
+}
+
+const getOraOptions = function (options , bindDefs) {
+    let oraOptions = { autoCommit: !options.isTransactionRequest };
+    if (options && (options.query || options.queryOne)) {
+        oraOptions.resultSet = true;
+    }
+    if (bindDefs) {
+        oraOptions.bindDefs = bindDefs
+    }
+    return oraOptions;
+}
+
+const convertValueFromType = async function (value, type) {
+    switch (type) {
+        case 'string': {
+            return BlzBase.convertToString(value);
+        }
+        case 'integer': {
+            return  BlzBase.convertToInteger(value);
+        }
+        case 'decimal': {
+            return  BlzBase.convertToDecimal(value);
+        }
+        case 'boolean': {
+            return  BlzBase.convertToBoolean(value);
+        }
+        case 'datetime': {
+            return  BlzBase.convertToDatetime(value);
+        }
+        case 'date': {
+            return  BlzBase.convertToDate(value);
+        }
+        case 'time': {
+            return  BlzBase.convertToTime(value);
+        }
+        case 'binary': {
+            return  BlzBase.convertToBinary(value);
+        }
+        default:{
+            // If i have a clob, or special type, the case might not be straightforward
+            if (value._type.name === 'DB_TYPE_CLOB' ) {
+                return await oraResult.outBinds[parameter.name].getData();
+            }
+        }
+    }
+}
+
+const getResult = async function (parameters, oraResult, options) {
+    let result = {};
+    result.rowsAffected = oraResult.rowsAffected;
+    result.outParameters = {};
+    if (parameters)
+        for (let i = 0; i < parameters.length; i++) {
+            let parameter = parameters[i];
+            if (parameter.direction === 'out' || parameter.direction === 'in/out') {
+                let value = oraResult.outBinds[parameter.name];
+                if (parameter.isResultSet)
+                    value = await convertResultSetToArray(value, []);
+                else {
+                    if (value && typeof value.type === 'string') {
+                        value = await convertValueFromType(value, value.type);
+                    } else if (value && value._type && typeof value._type.name === 'string' && value._type.name === 'DB_TYPE_CLOB') {
+                        value = await oraResult.outBinds[parameter.name].getData();
+                    } else if (parameter && typeof parameter.type === 'string') {
+                        value = await convertValueFromType(value, parameter.type);
+                    } else {
+                        console.warn('Could not resolve out parameter type');
+                    }
+                }
+                result.outParameters[parameter.name] = value;
+            }
+        }
+    if (options && options.autoincrementalData) {
+        result.id = null;
+        if (oraResult.outBinds && oraResult.outBinds.ScalarOutput) {
+            result.id = oraResult.outBinds.ScalarOutput;
+            if (Array.isArray(result.id))
+                result.id = result.id[0];
+        }
+    }
+    if (options && (options.query || options.queryOne))
+        result.resultSet = oraResult.resultSet;
+    return result;
+}
+
+process.on('exit', async function () {
+    let promises = [];
+    for (let poolName in poolsByName) {
+        let pool = poolsByName[poolName];
+        promises.push(pool.close());
+    }
+    poolsByName = null;
+    await Promise.all(promises);
+});
+
+const getValue = function (source, type) {
+    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
+		}
+}
+
+/**
+ * Infers the Oracle DB type from a JavaScript value.
+ * @param {*} value - The value to infer the DB type for.
+ * @returns {number} oracledb type constant.
+ */
+const inferDbTypeFromValue = function (value) {
+    if (value === null || value === undefined) {
+        return oracledb.STRING; // default to STRING for nulls
+    }
+
+    if (Buffer.isBuffer(value)) {
+        return getParameterType('binary');
+    }
+
+    const jsType = typeof value;
+
+    switch (jsType) {
+        case 'string':
+            return getParameterType('string');
+        case 'number':
+            // Decide between integer and decimal if needed
+            return Number.isInteger(value) ? getParameterType('integer') : getParameterType('decimal');
+        case 'boolean':
+            return getParameterType('boolean');
+        case 'object':
+            if (value instanceof Date) {
+                return getParameterType('datetime');
+            }
+            return getParameterType('string'); // fallback for objects
+        default:
+            return getParameterType('string');
+    }
+}
+
+
+const rowsToArray = function (columns, rows) {
+    const array = []
+    const columnsCount = columns.length
+    for (const row of rows) {
+        const item = {}
+        for(let i=0 ; i < columnsCount ; i++) {
+            const column = columns[i]            
+            const value = row[i]
+            item[column.name] = getValue(value,column.type)
+        }
+        array.push(item)
+    }
+    return array
+}
+
+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)           
+            }
+        }
+        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
+		}
+        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])
+                }
+                return { rowsAffected: result.rowsAffected, ids }
+            } else {
+                return { rowsAffected: result.rowsAffected }
+            }
+        } 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)
+            }
+            _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
+            }
+        }
+        _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)           
+            }
+        }
+        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();
+    }
+};