bonsaif 1.10.38 → 1.10.40

package/README.md

@@ -92,139 +92,6 @@ const localMariaDB= {
   runMongo();
 
 
-  /**
-  *  Execute Mongoose (MongoDB ORM with Schema validation)
-  *  https://mongoosejs.com/docs/guide.html
- **/
-  const endpointMongoose= {
-    uri: '',
-    user: '',
-    password: '',
-    client:'mongoose'
-  };
-
-   const localMongoose= {
-      uri:'mongodb://localhost:27017', 
-      poolSize:8,
-      local:true, 
-      debug:false,
-      client:'mongoose'
-  };
-
-  // Schema definition (opcional - también acepta documentos sin schema)
-  const userSchema = {
-    name: { type: 'String', required: true, minlength: 3 },
-    email: { type: 'String', required: true, unique: true, lowercase: true },
-    age: { type: 'Number', min: 18, max: 100 },
-    status: { type: 'String', enum: ['active', 'inactive', 'pending'], default: 'active' }
-  };
-
-  const runMongoose = async()=>{
-
-    // INSERT con schema y validaciones
-    let insert = await bonsaif.query({
-      endpoint:localMongoose, 
-      options:{db:'mydb', sys:''}, 
-      query:{
-        dml: 'insert',
-        collection: 'users',
-        schema: userSchema,
-        document: { name: 'John Doe', email: 'john@example.com', age: 30 }
-      }, 
-      tag
-    });
-
-    // INSERT sin schema (genérico - acepta cualquier campo)
-    let insertGeneric = await bonsaif.query({
-      endpoint:localMongoose, 
-      options:{db:'mydb'}, 
-      query:{
-        dml: 'insert',
-        collection: 'logs',
-        document: { event: 'login', user_id: 123, timestamp: new Date() }
-      }
-    });
-
-    // FIND con filtros, sorting y populate
-    let find = await bonsaif.query({
-      endpoint:localMongoose, 
-      options:{db:'mydb'}, 
-      query:{
-        dml: 'find',
-        collection: 'users',
-        filter: { age: { $gte: 25 } },
-        sort: { age: -1 },
-        limit: 10,
-        select: 'name email age'
-      }
-    });
-
-    // UPSERT (update o insert)
-    let upsert = await bonsaif.query({
-      endpoint:localMongoose, 
-      options:{db:'mydb'}, 
-      query:{
-        dml: 'upsert',
-        collection: 'users',
-        filter: { email: 'jane@example.com' },
-        document: { name: 'Jane Doe', email: 'jane@example.com', age: 28 }
-      }
-    });
-
-    // AGGREGATE con pipeline
-    let aggregate = await bonsaif.query({
-      endpoint:localMongoose, 
-      options:{db:'mydb'}, 
-      query:{
-        dml: 'aggregate',
-        collection: 'users',
-        pipeline: [
-          { $match: { age: { $gte: 25 } } },
-          { $group: { _id: '$status', count: { $sum: 1 }, avgAge: { $avg: '$age' } } },
-          { $sort: { count: -1 } }
-        ]
-      }
-    });
-
-    // UPDATE / UPDATEMANY
-    let update = await bonsaif.query({
-      endpoint:localMongoose, 
-      options:{db:'mydb'}, 
-      query:{
-        dml: 'updateMany',
-        collection: 'users',
-        filter: { age: { $lt: 30 } },
-        update: { $set: { category: 'young' } }
-      }
-    });
-
-    // DELETE / DELETEMANY
-    let deleteMany = await bonsaif.query({
-      endpoint:localMongoose, 
-      options:{db:'mydb'}, 
-      query:{
-        dml: 'deleteMany',
-        collection: 'users',
-        filter: { status: 'inactive' }
-      }
-    });
-
-    // DISTINCT
-    let distinct = await bonsaif.query({
-      endpoint:localMongoose, 
-      options:{db:'mydb'}, 
-      query:{
-        dml: 'distinct',
-        collection: 'users',
-        field: 'status',
-        filter: {}
-      }
-    });
-  }
-
-  runMongoose();
-
-
   /**
   *  Execute redis
   *  https://redis.io/commands/?group=set

package/lib/execute.js

@@ -45,7 +45,6 @@ const query = async (o)=>{
     switch(o.endpoint.client){
         case 'mariadb':     rs = await mariadb(o); break;
         case 'mongodb':     rs = await mongodb(o); break;
-        case 'mongoose':    rs = await mongoose(o); break;
         case 'redis':       rs = await redis(o); break;
         case 'api':         rs = await api(o); break;
         case 'postgres':    rs = await postgres(o); break;        
@@ -128,33 +127,6 @@ const mariadb= async(o)=>{
 
   /**
  * 
- * @param {object} o  Configuracion de mongoose
- * @returns 
- */
-   const mongoose= async(o)=>{
-    const { local=false } = o.endpoint;
-    const { db = '', resultFormat=true} = o.options;
-    o.options.dml = 'api';
-    o.body = o.query;
-
-    if (local){
-        let mongoose = require("../lib/hookup/mongoose");
-        let r=  await mongoose.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 
  */

package/lib/hookup/exec.js

@@ -53,10 +53,8 @@ module.exports = {
     
     mongoClose: async function (mongoclient){
         try{
-            if (mongoclient && typeof mongoclient.close === 'function') {
-                await mongoclient.close();
-                this.debug ? utl.log(`${tag} [Mongo] closing connection`) : '';
-            }
+            mongoclient.then(function(mongoclient){mongoclient.close();});
+            this.debug ? utl.log(`${tag} [Mongo] closing connection`) : '';
         }catch(e){
              utl.log(`${tag} [Mongo] err.exec.mongoClose`,e);
         }

package/lib/hookup/mariadb.js

@@ -15,12 +15,17 @@
     let obj_json ={};
     let headers = '';
     const start = Date.now();
-    
     return new Promise(function(resolve, reject) {
-      conn.query(query, async function (err, rows, fields) {
+      //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});
@@ -45,6 +50,7 @@
               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;
@@ -54,20 +60,13 @@
           }
         }catch(e){
           console.log(e);
-          resolve({"result":{dml, headers:"",  time:utl.milisegundosASegundos(time), code:500, error:1, msg:e}, results:e});
-        }finally{
-          // Cerrar conexión SIEMPRE
-          try{
-            await exec.mariadbClose(conn);
-          }catch(e){
-            utl.log('err.qson.close '+e);
-          }
         }
       });
     });
   }
 
 const api=async (options,db,query,dml,ip,tag,callback)=>{ 
+  //Inicializar conexiones a bases
   tag = tag == null ? '': tag; 
   const exec   = require("./exec");
 
@@ -79,14 +78,6 @@ const api=async (options,db,query,dml,ip,tag,callback)=>{
   }catch(e){
     r.result.headers = 'err';
     r.data=[{'err':e}];
-    // Cerrar conexión si hubo error antes de qson
-    if (con){
-      try{
-        await exec.mariadbClose(con);
-      }catch(closeErr){
-        utl.log('err.api.close.catch '+closeErr);
-      }
-    }
   }finally {
     try{
       let code = r.result.code;
@@ -98,16 +89,7 @@ const api=async (options,db,query,dml,ip,tag,callback)=>{
             let connErr = await execErr.mariadbConn(options);
             try{
                 let rerr = await qson(db,connErr,qErr,dml,ip);
-                // qson ya cierra connErr, no necesitamos cerrarlo aquí
             }catch(e){
-                // Si falla el logging, cerrar la conexión de error
-                if (connErr){
-                  try{
-                    await execErr.mariadbClose(connErr);
-                  }catch(closeErr){
-                    utl.log('err.api.connErr.close '+closeErr);
-                  }
-                }
             }
         }
     }catch(e){