@blazedpath/commons 0.2.2 → 0.3.1

package/blz-rds-oracle/index.js

@@ -1,539 +0,0 @@
-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();
-    }
-};