bonsaif 1.10.34 → 1.10.36

package/README.md

@@ -92,6 +92,139 @@ 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,6 +45,7 @@ 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;        
@@ -127,6 +128,33 @@ 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,8 +53,10 @@ module.exports = {
     
     mongoClose: async function (mongoclient){
         try{
-            mongoclient.then(function(mongoclient){mongoclient.close();});
-            this.debug ? utl.log(`${tag} [Mongo] closing connection`) : '';
+            if (mongoclient && typeof mongoclient.close === 'function') {
+                await 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,17 +15,12 @@
     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) {
+      conn.query(query, async 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});
@@ -50,7 +45,6 @@
               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;
@@ -60,13 +54,20 @@
           }
         }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");
 
@@ -78,6 +79,14 @@ 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;
@@ -89,7 +98,16 @@ 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){