bonsaif 1.10.3

package/lib/execute.js

@@ -0,0 +1,389 @@
+/**
+ * ::: B[]NSAIF() ::: => 2022
+ */
+
+'use strict';
+
+
+const utl           = require('./utl');
+let debug = false;
+let tag = ` ::: B[]NSAIF() ::: => `;
+
+/**
+ * 
+ * @param {object} o Objeto con optiones y configuracion para bonsaif api
+ * @returns {data} informacion con estructura similar a un resulset 
+ */
+const query = async (o)=>{
+    const {endpoint=''} = o;
+    if (endpoint==''){
+        utl.log(tag+'debe ingresar configuracion de endpoint');
+        return;
+    }
+
+    const {options=''} = o;
+    if (options==''){
+        utl.log(tag+'debe ingresar opciones de configuracion');
+        return;
+    }
+
+    const {uri='', user = '', password='',  debug=false , client=''} = endpoint;
+    //let requerido = ['uri','user','password','client'];
+    let requerido = ['uri','client'];
+    let aviso = '';
+    this.debug = debug ? true : false;
+    o.endpoint.client = client.toLowerCase();
+
+    for (let x of requerido){
+        eval(` if (${x}=='') { aviso = aviso + '${x}. ' }  `)
+    }
+    if (aviso!=''){
+        utl.log(tag+'Required: '+aviso);
+        return;
+    }
+    let rs;
+    switch(o.endpoint.client){
+        case 'mariadb':     rs = await mariadb(o); break;
+        case 'mongodb':     rs = await mongodb(o); break;
+        case 'redis':       rs = await redis(o); break;
+        case 'api':         rs = await api(o); break;
+        case 'postgres':    rs = await postgres(o); break;        
+        default:            rs = tag+' No Client: '+client;
+    }
+
+    return new Promise((resolve, reject)=>{
+        resolve( rs );
+        //2023/08/18 VRSZ push Webhook 
+        try{
+            if (o.webhook){
+                webhook(o, rs);
+            }
+        }catch(e){
+        }        
+    });
+}
+
+/**
+ * 
+ * @param {object} o  Configuracion de  mariadb
+ * @returns 
+ */
+const mariadb= async(o)=>{
+    const { user, client, local=false } = o.endpoint;
+    const { dml='query', db = '',  callback='', resultFormat=true} = o.options;
+    const { tag='', query = ''} = o;
+
+    if (local){
+        let mariadb = require("../lib/hookup/mariadb");
+        //const api=(options,db,query,dml,ip,tag,callback)=>{ 
+        let r=  await mariadb.api(o,db, query, dml, 'local', tag, callback );
+        try{ r.query = o.query }catch(e){}
+        return resultFormat ? resultSet(r) : r ;
+    }else{
+        o.body={
+            "tag":tag,
+            "dml":dml,
+            "client":client,
+            "query":o.query,
+            "db": db,
+            "traceId":utl.traceId(user)
+        }
+        return new Promise((resolve, reject)=>{
+            backend(o)
+            .then(r=>{
+                try{ r.query = o.query }catch(e){}
+                resolve(resultFormat ? resultSet(r) : r );
+            });
+        });
+    }
+}
+
+  /**
+ * 
+ * @param {object} o  Configuracion de  mongodb
+ * @returns 
+ */
+   const mongodb= async(o)=>{
+    const { local=false } = o.endpoint;
+    const { db = '', resultFormat=true} = o.options;
+    o.options.dml = 'api';
+    o.body = o.query;
+
+    if (local){
+        let mongodb = require("../lib/hookup/mongodb");
+        let r=  await mongodb.api(o,db,o.body);
+        try{ r.query = o.query }catch(e){}
+        return resultFormat ? resultSet(r) : r ;
+    }else{
+        return new Promise((resolve, reject)=>{
+            backend(o)
+            .then(r=>{
+                try{ r.query = o.query }catch(e){}
+                resolve(resultFormat ? resultSet(r) : r);
+            });
+        });
+    }
+}
+
+  /**
+ * 
+ * @param {object} o  Configuracion de  redis
+ * @returns 
+ */
+   const redis= async(o)=>{
+    const { local=false } = o.endpoint;
+    const { db = ''} = o.options;
+    o.options.dml = 'api';
+    o.body = o.query;
+
+    if (local){
+        let redis = require("../lib/hookup/redis");
+        let r=  await redis.api(o,db,o.body);
+        try{ r.query = o.query }catch(e){}
+        return r;
+    }else{
+        return new Promise((resolve, reject)=>{
+            backend(o)
+            .then(r=>{
+                try{ r.query = o.query }catch(e){}
+                resolve(r);
+            });
+        });
+    }
+}
+
+/**
+ * 
+ * @param {Object} o  Conexion api
+ * @returns 
+ */
+const backend=(o)=>{
+    const qs            = require('qs');
+    const {uri, user, password} = o.endpoint;  
+    // 2024/09/05 VRSZ retries y timeout 2 min
+    const {sys, retries=3, timeout=120000} = o;  
+    let authorization = 'Basic ' + Buffer.from(user + ':' + password).toString('base64');
+
+    let url_ = sys=='opti'? uri.replace('/rbe','') : uri;
+    
+    url_ = url_+'?'+qs.stringify(o.options)+"&rd="+utl.random({string:true, length:8});
+    
+    const options = {
+        url: url_,
+        timeout,
+        headers: {
+            'Content-Type': 'application/json',
+            'authorization': authorization
+        },
+        body: JSON.stringify(o.body)
+    };
+    
+
+    return new Promise(async (resolve, reject)=>{
+        // 2024/07/24 VRSZ Se cambia el metodo apix para aplicar reintentos
+        let r = await utl.apix({method:'post', options, time:2, retries, async:true, status_ok:[200,401]});
+        let {err} = r ? r : {};
+        let {code:statusCode=0, errno:reason=''} = err ? err : {};
+        try{
+            if (r.statusCode==200) {
+                resolve(JSON.parse(r.body));
+            }else{
+                utl.log(`${tag} [${url_}] statusCode: ${statusCode} reason: ${reason} body: ${r.body}`, o.body);
+                resolve({err, code:statusCode, reason});
+            }
+        }catch(e){
+            resolve({err, code:0, reason});
+        }
+    });
+}
+/**
+ * 
+ * @param {json} data Objeto json con 2 arreglos
+ * @returns  Regresa la estructura similar a resulset
+ */
+//2022/06/12 VRSZ Se obtine reason 
+const resultSet = (data)=>{
+    data=!null?data:data={};
+    if (data.result==null){data.result = {};}
+    if (data.data==null){data.data = {};}
+
+    //2023/08/17 VRSZ Se parse error
+    if (data.err!=null){
+        const {errno='500', code='ups. error de conexion'} = data.err;
+        data.result.error = 1;
+        data.result.headers =  'mensaje';
+        data.result.code =  errno;
+        data.result.msg =  code;
+        data.data=[{mensaje:code}];
+    }    
+
+    const {results=''} = data;
+    let {dml='',headers='',columns=0, time=0, code=200, error=0, msg=''} = data.result;
+    const rows = data.data;
+    const irows = rows.length?rows.length:0;
+    try{delete rows.meta;}catch(e){}
+    let ltheaders = headers.split('|');
+    columns = columns==0 ? ltheaders.length : columns;
+    //2023/08/23 VRSZ Info extra en la respuesta del servicio
+    let extra = {};
+    try {
+        extra = { ...data };
+        try{delete extra.result;}catch(e){}
+        try{delete extra.data;}catch(e){}
+        try{delete extra.results;}catch(e){}
+    }catch(e){
+    }    
+    return {
+        dml,
+        time,
+        headers,
+        ltheaders,
+        columns, 
+        rows,
+        irows,
+        nextIndex : 0,
+        row:{},
+        next:function(){
+            if (this.nextIndex < this.rows.length){
+                this.row = this.rows[this.nextIndex++];
+                return true;
+            }else{
+                return false;
+            }
+        },
+        get:function(x){
+            if (!isNaN(x)){
+                x = this.ltheaders[x];
+            }
+            return this.row[x]!=null?this.row[x]:'';
+        },
+        reset:function(){
+            this.nextIndex = 0;
+        },
+        results,
+        code,
+        error,
+        msg,
+        extra
+    }
+  }
+
+  /**
+ * 
+ * @param {Object} o  Conexion api
+ * @returns 
+ */
+const api=async(o)=>{
+    const { db = '', resultFormat=true} = o.options;
+    return new Promise((resolve, reject)=>{
+        service(o)
+        .then(r=>{
+            resolve(resultFormat ? resultSet(r) : r);
+        });
+    });
+}
+
+const service=(o)=>{
+    const qs            = require('qs');
+    const {uri, user, password, resultFormat=true} = o.endpoint;
+    const {sys, ...body } = o.options;
+    let authorization = 'Basic ' + Buffer.from(user + ':' + password).toString('base64');
+    let url_ =  uri;
+    url_= url_+'?sys='+sys+'&'+qs.stringify(o.params?o.params:'')+"&rd="+utl.random({string:true, length:8});
+    o.body = {...body};
+    const options = {
+        url: url_,
+        headers: {
+            'Content-Type': 'application/json',
+            'authorization': authorization
+        },
+        body: JSON.stringify(o.body)
+    };
+
+    return new Promise(async (resolve, reject)=>{
+        // 2024/07/24 VRSZ Se cambia el metodo apix para aplicar reintentos
+        let r = await utl.apix({method:'post', options, time:2, async:true, status_ok:[200,401]});
+        let {err} = r ? r : {};
+        let {code:statusCode=0, errno:reason=''} = err ? err : {};
+        try{
+            if (r.statusCode==200) {
+                resolve(JSON.parse(r.body));
+            }else{
+                utl.log(`${tag} [${url_}] statusCode: ${statusCode} reason: ${reason} body: ${r.body}`, o.body);
+                resolve({err, code:statusCode, reason});
+            }
+        }catch(e){
+            resolve({err, code:0, reason});
+        }
+    });
+}
+
+const webhook=(o, rs)=>{
+    try{
+        let {webhook} = o ? o : {};
+        let {result} = rs ? rs : {};
+        let {uri='', data={}} = webhook ? webhook : {};
+        try{delete result.headers} catch(e){}
+        let out  = {};
+        out.result  = result;
+        out.data  = data;
+        if (uri!=''){
+            const options = {
+                url: uri,
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(out)
+            };
+            const request  = require('request');
+            request.post(options, (err, r, body) => {
+                if (err){
+                    utl.log('webhook.post.err ',err);   
+                }
+            });
+        }
+    }catch(e){
+        utl.log('webhook.err',e);
+    }
+}
+
+
+/**
+ * 
+ * @param {object} o  Configuracion de  postgres
+ * @returns 
+ */
+const postgres= async(o)=>{
+    const { user, client, local=false } = o.endpoint;
+    const { dml='query', db = '',  callback='', resultFormat=true} = o.options;
+    const { tag='', query = ''} = o;
+
+    if (local){
+        let postgres = require("../lib/hookup/postgres");
+        let r=  await postgres.api(o, db, query, dml, 'local', tag, callback );
+        try{ r.query = o.query }catch(e){}
+        return resultFormat ? resultSet(r) : r ;
+    }else{
+        o.body={
+            "tag":tag,
+            "dml":dml,
+            "client":client,
+            "query":o.query,
+            "db": db,
+            "traceId":utl.traceId(user)
+        }
+        return new Promise((resolve, reject)=>{
+            backend(o)
+            .then(r=>{
+                try{ r.query = o.query }catch(e){}
+                resolve(resultFormat ? resultSet(r) : r );
+            });
+        });
+    }
+}
+
+module.exports={
+    query,
+    backend,
+    api
+}

package/lib/hookup/exec.js

@@ -0,0 +1,93 @@
+/**
+ * ::: B[]NSAIF() ::: => 2022
+ */
+
+ 'use strict';
+
+ const utl          = require('../utl');
+ let debug = false;
+ let tag = ` ::: B[]NSAIF() ::: => exec.js `;
+ 
+module.exports = {
+	redisConn: async function (o){
+        
+        let dbRedis;
+		try{
+            const {port='', uri = '', debug=false } = o.endpoint;
+            this.debug  = debug;
+			let redis   = require('redis');
+			    dbRedis = redis.createClient({url: uri});
+			    dbRedis.on("error", function (err) {
+                utl.log(`${tag} [Redis] error encountered`, err);
+                dbRedis.quit();
+			  });
+			    dbRedis.on('connect', function() {                 
+                    debug ?  utl.log(`${tag} [Redis] connection is online Port[${port}] uri[${uri}]`):'';
+			  });
+			
+		}catch(e){
+            utl.log(`${tag} [Redis] err.exec.redisConn`,e);
+	    }
+		return dbRedis;
+	},
+	
+	redisClose: async function (bd){
+		this.debug ? utl.log(`${tag} [Redis] closing connection`) : '';
+		bd.quit();
+	},
+
+    mongoConn: async function(o){
+        try{
+            let mongo     = require('mongodb');
+            let MongoClient  = mongo.MongoClient;
+            const {port='', uri = '', password = '', poolSize= 8, debug=false } = o.endpoint;
+            this.debug  = debug;
+            let mongoclient =  await MongoClient.connect(uri, { useNewUrlParser: true, poolSize: poolSize, serverSelectionTimeoutMS:15000, useUnifiedTopology: true } );
+            debug ?  utl.log(`${tag} [Mongo] connection is online ${uri} poolSize[${poolSize}] mongoclient: [${mongoclient}]`) : '';
+            return mongoclient;
+        }catch(e){
+             utl.log(`${tag} [Mongo] err.exec.mongoConn`,e);
+             return null;
+        }
+    },
+    
+    mongoClose: async function (mongoclient){
+        try{
+            mongoclient.then(function(mongoclient){mongoclient.close();});
+            this.debug ? utl.log(`${tag} [Mongo] closing connection`) : '';
+        }catch(e){
+             utl.log(`${tag} [Mongo] err.exec.mongoClose`,e);
+        }
+    },
+
+    mariadbConn: async function(o){
+        return new Promise( (resolve, reject) => {
+            const {port='', uri = '', user='', password='', debug=false } = o.endpoint;
+            const {db=''} = o.options;
+            this.debug  = debug;
+            const mysql   = require('mysql');
+            const conn  = mysql.createConnection({
+                host:uri, user, port , password, database :db
+            });
+            conn.connect(function(e){
+                if(e){
+                utl.log(`${tag} [mariaDB] is OFFline`,e);
+                reject(e);
+                }else{
+                debug ? utl.log(`${tag} [mariaDB] connection is online `,conn.threadId):'';
+                resolve(conn);
+                }
+            });
+
+        });
+    },
+
+    mariadbClose: async function(conn){
+        try{
+            this.debug ? utl.log(`${tag} [mariaDB] closing connection`) : '';
+            conn.end();
+        }catch(e){
+            utl.log(`${tag} [mariaDB] err.exec.mongoClose`,e);
+        }
+    }
+}

package/lib/hookup/mariadb.js

@@ -0,0 +1,106 @@
+/**
+ * ::: B[]NSAIF() ::: => 2022
+ */
+
+ 'use strict';
+
+ const utl          = require('../utl');
+ let debug = false;
+ let tag = ` ::: B[]NSAIF() ::: => mariadb.js `;
+
+ const qson = async (alias, conn, query,dml,ip)=>{
+    
+    const exec   = require("./exec");
+    let data;
+    let obj_json ={};
+    let headers = '';
+    const start = Date.now();
+    return new Promise(function(resolve, reject) {
+      //2022/08/27 VRSZ Se cambia el la utileria para consumirmo por mysql ya que mariadb no regresa los campos de las columnas
+      conn.query(query, function (err, rows, fields) {
+        const end = Date.now();
+        const time = end - start;
+        // cerrar conexion 
+        try{
+          exec.mariadbClose(conn);
+        }catch(e){
+            utl.log('err.qson close '+e);
+        }
+        try{
+          if (err){
+            resolve({"result":{dml, headers,  time:utl.milisegundosASegundos(time), code:err.errno, error:1, msg:err.sqlMessage}, results:err});
+          }else{
+            let tipo = 'query';
+            if (fields){
+              if (fields[0][0]){
+                tipo = 'store';
+                obj_json= fields[0];
+              }else{
+                obj_json= fields;
+              }
+              obj_json.forEach(x => {
+                if (x){
+                  if (headers.length>0){
+                    headers = headers +'|';
+                  }
+                  headers = headers + x.name;
+                }
+              });
+            }else{
+              tipo = 'insert';
+              headers =  'insert_id|changed_rows';
+            }
+            //Remove  RowDataPacket {}  Object.values(JSON.parse(JSON.stringify(rows)))
+            switch(tipo){
+              case 'store':  data = Object.values(JSON.parse(JSON.stringify(rows[0]))); break;
+              case 'insert': data =[{"insert_id":rows.insertId, "changed_rows":rows.changedRows}]; break;
+              default:       data = Object.values(JSON.parse(JSON.stringify(rows)));  
+            }
+            resolve({"result":{dml, headers,  time:utl.milisegundosASegundos(time), code:200, error:0}, data});
+          }
+        }catch(e){
+          console.log(e);
+        }
+      });
+    });
+  }
+
+const api=async (options,db,query,dml,ip,tag,callback)=>{ 
+  //Inicializar conexiones a bases
+  tag = tag == null ? '': tag; 
+  const exec   = require("./exec");
+
+  let r ={result:{"alias":"", dml:"", headers:"" },error: 1, code:404,  msg:'', };
+  let con;
+  try{
+   con = await exec.mariadbConn(options);
+   r = await qson(db,con,query,dml,ip);
+  }catch(e){
+    r.result.headers = 'err';
+    r.data=[{'err':e}];
+  }finally {
+    try{
+      let code = r.result.code;
+      let msg  = r.result.msg;
+        if (code!=200){
+            let qErr = "insert into aw_log (Sentencia, ErrorCode,Error, Fecha, id_pw, IP, alias) values (\""+query.replace(/\"/g,"\"\"")+"\",\""+code+"\",\""+msg.replace(/\"/g,"\"\"")+"\", NOW(), \""+tag+"\", \""+ip+"\", \""+db+"\" );";
+            const execErr   = require("./exec");
+            let connErr = await execErr.mariadbConn(options);
+            try{
+                let rerr = await qson(db,connErr,qErr,dml,ip);
+            }catch(e){
+            }
+        }
+    }catch(e){
+        utl.log('api.finally err '+e);
+    }
+  }
+  return new Promise((resolve, reject)=>{
+    resolve (r);
+  });
+}
+
+module.exports ={
+    api,
+    qson
+}