bonsaif 1.10.3

package/README.md

@@ -0,0 +1,201 @@
+Eliminar publicacion
+npm unpublish bonsaif@1.9.23
+
+
+# [bonsaif.js](http://git.develsuit.com:6000/bonsaif/bonsaif-npm.git)
+
+bonsaif t is a library to connect to bonsaif apis
+
+## Installation
+
+```bash
+npm install bonsaif
+```
+
+## Examples
+
+Here is the first one to get you started:
+
+```js
+
+const bonsaif  = require('bonsaif');
+// utl, 
+const {utl}    = require('bonsaif');
+
+//ec
+const {ec}     = require('bonsaif');
+const tag      = "test";
+
+// ./cnf/endpoint.js
+const endpointMariaDB= {
+  uri: '',
+  user: '',
+  password: '',
+  client:'mariadb'
+};
+
+const localMariaDB= {
+  uri:'', 
+  port: '', 
+  user:'', 
+  password:'', 
+  local:true, 
+  debug:false,
+  client:'mariadb'
+};
+
+// Execute query 
+  const run =async()=>{
+    //localhost
+    let rs =  await bonsaif.query({endpoint:localMariaDB, options:{db:'', sys:''}, query:'select * from table', tag});
+    //endpoint
+    let rs =  await bonsaif.query({endpoint:endpointMariaDB, options:{db:'', sys:''}, query:'select * from table', tag});
+    while (rs.next()){
+        utl.log('row json',rs.row);
+        let x = rs.row;
+        utl.log('get field  ['+x+']');
+        utl.log('get field  ['+rs.get('column')+']');
+        utl.log('get field by Index  ['+rs.get(0)+']');
+    }
+  }
+  run();
+ /**
+  *  Execute mongodb
+  *  https://www.mongodb.com/docs/manual/reference/command/
+ **/
+  const endpointMongo= {
+    uri: '',
+    user: '',
+    password: '',
+    client:'mongodb'
+  };
+
+   const localMongo= {
+      uri:'', 
+      poolSize:8,
+      local:true, 
+      debug:false,
+      client:'mongodb'
+  };
+  const runMongo =async()=>{
+
+    // localhost
+    let insert =  await bonsaif.query({endpoint:localMongo, options:{db:'', sys:''}, query:{insert: "collection", documents: [{ 'id':1, 'ds':'demo1' }]}, tag});
+
+    //endpoint
+    let insert =  await bonsaif.query({endpoint:endpointMongo, options:{db:'', sys:''}, query:{insert: "collection", documents: [{ 'id':1, 'ds':'demo1' }]}, tag});
+    let find =    await bonsaif.query({endpoint:endpointMongo, options:{db:'', sys:''}, query:{find: "collection", filter: { 'id':1 }}, tag});
+    let update =  await bonsaif.query({endpoint:endpointMongo, options:{db:'', sys:''}, query:{update: "collection", filter: { _id:1 } documents: [{ "id":1, "ds":"ds Change", "NewC":1 }]}, tag});
+    let upsert =  await bonsaif.query({endpoint:endpointMongo, options:{db:'', sys:''}, query:{upsert: "collection", filter: { _id:1 }, document:{ 'id':1, 'ds':'ds1', 'live':0 } }, tag});
+  }
+
+  runMongo();
+
+
+  /**
+  *  Execute redis
+  *  https://redis.io/commands/?group=set
+ **/
+  const endpointRedis= {
+    uri: '',
+    user: '',
+    password: '',
+    client:'redis'
+  };
+
+  const localRedis= {
+      uri:'', 
+      local:true, 
+      debug:false,
+      client:'redis'
+  };
+
+  const runRedis =async()=>{
+    let redis;
+    
+    // localhost
+    redis =  await bonsaif.query({endpoint:localRedis, options:{db:'', sys:''} query:{set:"Key:Test", value:"123456"}, tag:'test'});
+    utl.log('set ',redis);
+
+  //endpoint
+    redis =  await bonsaif.query({endpoint:endpointRedis, options:{db:'1', sys:'cc2'}, query:{set:"Key:Test", value:"123456"}, tag:'test'});
+    utl.log('set ',redis);
+
+    redis =  await bonsaif.query({endpoint:endpointRedis, options:{db:'1', sys:'cc2'}, query:{set:"Key:Expire", value:"123456", expire:20}, tag:'test'});
+    utl.log('set expire ',redis);  
+
+    redis =  await bonsaif.query({endpoint:endpointRedis, options:{db:'1', sys:'cc2'}, query:{get:"Key:Test"}, tag:'test'});
+    utl.log('get ',redis);
+
+    redis =  await bonsaif.query({endpoint:endpointRedis, options:{db:'1', sys:'cc2'}, query:{scan:"log*"}, tag:'test'});
+    utl.log('scan ',redis);
+    
+    redis =  await bonsaif.query({endpoint:endpointRedis, options:{db:'1', sys:'cc2'}, query:{upsert:"log:test", value:{"id_":1, "ds":"ds", live:1, "child_id":2}, filter:{"id_":1}}, tag:'test'});
+    redis =  await bonsaif.query({endpoint:endpointRedis, options:{db:'1', sys:'cc2'}, query:{upsert:"log:test", value:{"id_":2, "ds":"ds2", live:1, "child_id":2}, filter:{"id_":2}}, tag:'test'});
+    utl.log('upsert (sadd) ',redis);
+
+    redis =  await bonsaif.query({endpoint:endpointRedis, options:{db:'1', sys:'cc2'}, query:{hfind:"log:test",  filter:{"id_":"*"} }, tag:'test'});
+    utl.log('hfind (smembers) ',redis);
+
+    redis =  await bonsaif.query({endpoint:endpointRedis, options:{db:'1', sys:'cc2'}, query:{hfind:"log:test",  filter:{"id_":"1"} }, tag:'test'});
+    utl.log('hfind (smembers) ',redis);
+
+    redis =  await bonsaif.query({endpoint:endpointRedis, options:{db:'1', sys:'cc2'}, query:{hfind:"log:test",  filter:{$and:[{"id_":1},{"child_id":"2"}]},}, tag:'test'});
+    utl.log('hfind (smembers) ',redis);
+
+    redis =  await bonsaif.query({endpoint:endpointRedis, options:{db:'1', sys:'cc2'}, query:{hfind:"log:test",  filter:{$or:[{"id_":1},{"child_id":"2"}]},}, tag:'test'});
+    utl.log('hfind (smembers) ',redis);
+
+    redis =  await bonsaif.query({endpoint:endpointRedis, options:{db:'1', sys:'cc2'}, query:{hfind:"log:test",  filter:{"id_":{$in:[1,2]}}}, tag:'test'});
+    utl.log('in (smembers) ',redis);
+    
+    redis =  await bonsaif.query({endpoint:endpointRedis, options:{db:'1', sys:'cc2'}, query:{set:"Key:Test:Del", value:"123456"}, tag:'test'});
+    redis =  await bonsaif.query({endpoint:endpointRedis, options:{db:'1', sys:'cc2'}, query:{del:"Key:Test:Del" }, tag:'test'});
+    utl.log('del ',redis);
+
+    //redis =  await bonsaif.query({endpoint:endpointRedis, options:{db:'1', sys:'cc2'}, query:{del:"Total" }, tag:'test'});
+    redis =  await bonsaif.query({endpoint:endpointRedis, options:{db:'1', sys:'cc2'}, query:{incrby:"Total", value:1000, counter:1 }, tag:'test'});
+    utl.log('incrby ',redis);
+
+    //redis =  await bonsaif.query({endpoint:endpointRedis, options:{db:'1', sys:'cc2'}, query:{del:"Total:Float" }, tag:'test'});
+    redis =  await bonsaif.query({endpoint:endpointRedis, options:{db:'1', sys:'cc2'}, query:{incrbyfloat:"Total:Float", value:1000.00, counter:-5.1 }, tag:'test'});
+    utl.log('TotalFloat ',redis);
+
+    redis =  await bonsaif.query({endpoint:endpointRedis, options:{db:'1', sys:'cc2'}, query:{sadd:"Member", "value":"1" }, tag:'test'});
+    redis =  await bonsaif.query({endpoint:endpointRedis, options:{db:'1', sys:'cc2'}, query:{sadd:"Member", "value":"2" }, tag:'test'});
+    redis =  await bonsaif.query({endpoint:endpointRedis, options:{db:'1', sys:'cc2'}, query:{sadd:"Member", "value":"3" }, tag:'test'});
+    utl.log('sadd ',redis);
+
+    redis =  await bonsaif.query({endpoint:endpointRedis, options:{db:'1', sys:'cc2'}, query:{smembers:"Member", "value":"2" }, tag:'test'});
+    utl.log('smembers ',redis);
+
+    redis =  await bonsaif.query({endpoint:endpointRedis, options:{db:'1', sys:'cc2'}, query:{srem:"Member", "value":"2" }, tag:'test'});
+    utl.log('srem ',redis);
+
+    redis =  await bonsaif.query({endpoint:endpointRedis, options:{db:'1', sys:'cc2'}, query:{hset:"hset", "value":{"id_cli":"1000","username":"1","password": "2", "A":"1" } }, tag:'test'});
+    utl.log('hset ',redis);
+
+    redis =  await bonsaif.query({endpoint:endpointRedis, options:{db:'1', sys:'cc2'}, query:{hgetall:"hset"}, tag:'test'});
+    utl.log('hgetall ',redis);
+  }
+
+  runRedis();
+  
+  utl.log('custom log '+utl.date()+' '+utl.hour());
+
+  /**
+   * Encript
+   **/
+  
+  let key = ec.StringToHex('keyString');
+  utl.log('['+ec.fromHexString(key)+']');
+
+  let keyKP = ec.StringToHexKP('llave','keyStringKP');
+  utl.log('['+ec.fromHexStringKP('llave',keyKP)+']');
+
+
+```
+
+
+## License
+[MIT](https://choosealicense.com/licenses/mit/)

package/index.js

@@ -0,0 +1,6 @@
+/**
+ * ::: B[]NSAIF() ::: => 2022
+ */
+'use strict';
+
+module.exports = require('./lib/bonsaif');

package/lib/bonsaif.js

@@ -0,0 +1,27 @@
+/**
+ * ::: B[]NSAIF() ::: => 2022
+ */
+
+'use strict';
+
+const utl          = require('./utl');
+const execute      = require('./execute'); 
+const ec           = require('./ec');
+const network      = require('./network');
+
+const query=(o)=>{
+    return execute.query(o);
+}
+
+const backend=(o)=>{
+    return execute.backend(o);
+}
+
+module.exports={
+    utl,
+    execute,
+    query,
+    backend,
+    ec,
+    network
+}

package/lib/ec.js

@@ -0,0 +1,202 @@
+/**
+ * ::: B[]NSAIF() ::: => 2022
+ */
+
+ 'use strict';
+
+const Key = "bonsaif.key";
+
+const WH = ["ff1", "ff2", "ff3", "ff4", "ff5", "ff6", "ff7", "ff8", "ff9", "ff",
+        "c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9", "c0",
+        "111", "222", "333", "444", "555", "666", "777", "888", "999", "000",
+        "1x", "2x", "3x", "4x", "5x", "6x", "7x", "8x", "9x", "0x"
+        //,"we","ue","aw","uf","6a","wa","v0"
+];
+const WC = ["z", "y", "x", "w", "v", "u", "t", "s", "r", "q",
+    "p", "o", "n", "m", "l", "k", "j", "i", "h", "g",
+    "Z", "Y", "X", "W", "V", "U", "T", "S", "R", "Q",
+    "P", "O", "N", "M", "L", "K", "J", "I", "H", "G"
+    //,".",",",":",";","!","*","@"
+];
+
+
+const StringToHex = (str) => {
+    let tag = "StringToHexW: ";
+    try{
+        let chars = Array.from(str.trim());
+        //logger.log(tag + 'chars', chars);
+        let c_key = Array.from(Key)
+        //logger.log(tag + 'c_key', c_key);
+        let iTkey = Key.length, ikey = 0, ichar = 0;
+
+        let dchar = 0.0, rchar = 0.0;//doubles
+        let strBuffer = "";
+        let Hex = "";
+
+        for (let i = 0; i < chars.length; i++) {
+            //ichar = ((int) chars[i] + (int) c_key[ikey]);
+            ichar = chars[i].charCodeAt(0) + c_key[ikey].charCodeAt(0);
+            dchar = Math.floor(ichar / 2);
+            rchar = ichar % 2;
+            if (ikey >= iTkey - 1) {
+                ikey = 0;
+            } else {
+                ikey = ikey + 1;
+            }
+            //Hex = Integer.toHexString((int) dchar);
+            let intChar = Math.trunc(dchar);
+            Hex = intChar.toString(16);
+            if (Hex.length == 1) {
+                Hex = "0" + Hex;
+            }
+            if (rchar > 0) {
+                //strBuffer.append("ff");
+                strBuffer += "ff";
+            }
+
+            //strBuffer.append(Hex);
+            strBuffer += Hex;
+        }
+        return compress(strBuffer);
+    }catch(e){
+        return "err"+e;
+    }
+}
+
+const fromHexString = (hex) => {
+    let tag = "fromHexString: ";
+    try{
+        hex = uncompress(hex);
+        let str = "";
+        let c_key = Array.from(Key);
+        let iTkey = Key.length, ikey = 0, ichar = 0;
+        let iV = 0;
+        for (let i = 0; i < hex.length; i += 2) {
+            if (hex.substring(i, i + 2) == "ff" || hex.substring(i, i + 2) == "FF" || hex.substring(i, i + 2) == "fF" || hex.substring(i, i + 2) == "Ff") {
+                iV = 1;
+            } else {
+                ichar = parseInt(parseInt(hex.substring(i, i + 2), 16), 10);
+                ichar = (ichar * 2) - c_key[ikey].charCodeAt(0);
+                ichar = ichar + iV;
+                //let caracter = String.fromCharCode(ichar).toString();
+                //logger.log(tag + 'caracter ' + caracter);
+                str += String.fromCharCode(ichar)
+                if (ikey >= iTkey - 1) {
+                    ikey = 0;
+                } else {
+                    ikey = ikey + 1;
+                }
+                iV = 0;
+            }
+        }
+        return str;
+    }catch(e){
+        return "err"+e;
+    }
+}
+
+const compress = (str) =>{
+    try{
+        let compress = str;
+        for (let w = 0; w < WH.length; w++) {
+            let replacer = new RegExp(WH[w], 'g')
+            compress = compress.replace(replacer, WC[w]);
+        }
+        return compress.trim();
+    }catch(e){
+        return "err"+e;
+    }
+}
+
+const uncompress = (str) => {
+    try{
+        let uncompress = str;
+        for (let w = WH.length - 1; w >= 0; w--) {
+            let replacer = new RegExp(WC[w], 'g')
+            uncompress = uncompress.replace(replacer, WH[w]);
+        }
+        return uncompress.trim();
+    }catch(e){
+        return "err"+e;
+    }
+}
+
+const StringToHexKP = (K, str) => {
+    let tag = "StringToHexKP: ";
+    try{
+        let chars = Array.from(str);
+        //logger.log(tag + 'chars', chars);
+        let c_key = Array.from(K)
+        //logger.log(tag + 'c_key', c_key);
+        let iTkey = K.length, ikey = 0, ichar = 0;
+
+        let dchar = 0.0, rchar = 0.0;//doubles
+        let strBuffer = "";
+        let Hex = "";
+
+        for (let i = 0; i < chars.length; i++) {
+            //ichar = ((int) chars[i] + (int) c_key[ikey]);
+            ichar = chars[i].charCodeAt(0) + c_key[ikey].charCodeAt(0);
+            dchar = Math.floor(ichar / 2);
+            rchar = ichar % 2;
+            if (ikey >= iTkey - 1) {
+                ikey = 0;
+            } else {
+                ikey = ikey + 1;
+            }
+            //Hex = Integer.toHexString((int) dchar);
+            let intChar = Math.trunc(dchar);
+            Hex = intChar.toString(16);
+            if (Hex.length == 1) {
+                Hex = "0" + Hex;
+            }
+            if (rchar > 0) {
+                //strBuffer.append("ff");
+                strBuffer += "ff";
+            }
+            //strBuffer.append(Hex);
+            strBuffer += Hex;
+        }
+        return compress(strBuffer);
+    }catch(e){
+        return "err"+e;
+    }
+}
+
+const fromHexStringKP = (K, hex)  => {
+    try{
+        hex = uncompress(hex);
+        let str = '';
+        
+        let c_key = Array.from(K);
+        let iTkey = K.length, ikey = 0, ichar = 0;
+
+        let iV = 0;
+        for (let i = 0; i < hex.length; i += 2) {
+            if (hex.substring(i, i + 2) == "ff" || hex.substring(i, i + 2) == "FF" || hex.substring(i, i + 2) == "fF" || hex.substring(i, i + 2) == "Ff") {
+                iV = 1;
+            } else {
+                ichar = parseInt(parseInt(hex.substring(i, i + 2), 16), 10);
+                ichar = (ichar * 2) - c_key[ikey].charCodeAt(0);
+                ichar = ichar + iV;
+                str += String.fromCharCode(ichar)
+                if (ikey >= iTkey - 1) {
+                    ikey = 0;
+                } else {
+                    ikey = ikey + 1;
+                }
+                iV = 0;
+            }
+        }
+        return str;
+    }catch(e){
+        return "err"+e;
+    }
+}
+
+module.exports = {
+    StringToHex,
+    fromHexString,
+    StringToHexKP,
+    fromHexStringKP
+};