bonsaif 1.10.40 → 1.10.42

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,44 @@ 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){
+        try {
+            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 ;
+        } catch (e) {
+            return {
+                result: {
+                    error: 1,
+                    code: 503,
+                    msg: 'Mongoose no disponible: ' + e.message
+                },
+                data: []
+            };
+        }
+    }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/mongodb.js

@@ -163,34 +163,40 @@ const update=async(options,dbm, col, json_obj, query)=>{
 }
 
 const upsert=async(options,dbm, col, json_obj, query)=>{
+  const exec        = require("./exec");
+  const mongoclient = exec.mongoConn(options);
+  const start = Date.now();
+  
   return new Promise((resolve, reject)=>{
-  find(options, dbm,col, query)
-  .then(result=>{
-    if (result.error==1){
-      resolve(result);
-    }
-
-    if (result.data[0]){ //update
-      update(options,dbm,col, json_obj, query)
-      .then(result_update=>{
-        resolve(result_update);
-      })
-      .catch(err=>{
-        reject(err);
-      });
-    }else{  // Insert
-      insert(options,dbm,col, json_obj)
-      .then(result_insert=>{
-        resolve(result_insert);
-      })
-      .catch(err=>{
-        reject(err);
-      });
-    }
-  })
-  .catch(err=>{
-    reject(err);
-  });
+    mongoclient.then(
+      function(client){
+         let db = client.db(dbm);
+         db.collection(col).updateOne(query, { $set: json_obj }, { upsert: true }, function(err, res) {
+           const end = Date.now();
+           const time = end - start;
+           let result, upsertedCount=0, modifiedCount=0, upsertedId=null;
+           try{ 
+             result = res.result; 
+             upsertedCount = res.upsertedCount || 0;
+             modifiedCount = res.modifiedCount || 0;
+             upsertedId = res.upsertedId ? res.upsertedId._id : null;
+           } catch(e){ }           
+            if (err) { 
+              resolve({result:{dml:"upsert", headers:"", time:utl.milisegundosASegundos(time), code:204, error:1, msg:err}, results:err});
+            }else{
+              let action = upsertedCount > 0 ? 'inserted' : 'updated';
+              resolve({result:{dml:"upsert", headers:"upsert", insertId:upsertedId, time:utl.milisegundosASegundos(time), code:200, error:0}, results:{WriteResult:`1 document ${action}`, result }});
+            }
+            try{
+              exec.mongoClose(mongoclient);
+            }catch(e){
+              utl.log('err.upsert '+e);
+            }
+         });
+      }
+    ).catch(err=>{
+      resolve({result:{dml:"upsert", headers:"", time:0, code:404, error:1}, results:err});
+    });
   })
 }
 
@@ -607,7 +613,8 @@ const api=async(options,dbm, json)=>{
   }
 
   if (utl.ObjectEmpty(json, 'insert')){
-    dml = 'insert'; 
+    dml = 'insert';
+    col = json.insert;
     json_api = json.documents?json.documents:[];
     if (json_api.length==1){
         json_api = json.documents[0];
@@ -617,7 +624,8 @@ const api=async(options,dbm, json)=>{
   }
 
   if (utl.ObjectEmpty(json, 'update')){
-    dml = 'update'; 
+    dml = 'update';
+    col = json.update;
     json_api = json.documents?json.documents:[];
     if (json_api.length==1){
         json_api = json.documents[0];
@@ -627,7 +635,8 @@ const api=async(options,dbm, json)=>{
   }
 
   if (utl.ObjectEmpty(json, 'updateMany')){
-    dml = 'updateMany'; 
+    dml = 'updateMany';
+    col = json.updateMany;
     json_api = json.documents?json.documents:[];
     if (json_api.length==1){
         json_api = json.documents[0];
@@ -636,7 +645,31 @@ const api=async(options,dbm, json)=>{
     }
   }
 
-  let ltdml = ['find','delete','count','dbs','collections','deleteMany','drop'];
+  if (utl.ObjectEmpty(json, 'replaceOne')){
+    dml = 'replaceOne';
+    col = json.replaceOne;
+    json_api = json.documents?json.documents:[];
+    if (json_api.length==1){
+        json_api = json.documents[0];
+    }
+  }
+
+  if (utl.ObjectEmpty(json, 'findOneAndUpdate')){
+    dml = 'findOneAndUpdate';
+    col = json.findOneAndUpdate;
+    json_api = json.documents?json.documents:[];
+    if (json_api.length==1){
+        json_api = json.documents[0];
+    }
+  }
+
+  if (utl.ObjectEmpty(json, 'insertMany')){
+    dml = 'insertMany';
+    col = json.insertMany;
+    json_api = json.documents?json.documents:[];
+  }
+
+  let ltdml = ['find','findOne','delete','deleteOne','deleteMany','count','dbs','collections','drop','aggregate','distinct','findOneAndDelete'];
   for (let x of ltdml){
     if (utl.ObjectEmpty(json,x)){
       dml = x; break;
@@ -644,20 +677,30 @@ const api=async(options,dbm, json)=>{
   }
   dml==''? dml='command':'';
 
-  eval(` try{ col = json.${dml}; } catch(e){ } `);
+  if (!col){
+    eval(` try{ col = json.${dml}; } catch(e){ } `);
+  }
   let r;
   switch (dml){
-    case 'insert':      r = await insert(options,dbm,col, json_api); break;
-    case 'upsert':      r = await upsert(options,dbm,col, json_api, query); break;
-    case 'update':      r = await update(options,dbm,col, json_api, query); break;
-    case 'count':       r = await count(options,dbm,col, json); break;
-    case 'dbs':         r = await dbs(options); break;
-    case 'collections': r = await collections(options,dbm); break;
-    case 'deleteMany':  r = await deleteMany(options,dbm,col, json); break;
-    case 'updateMany':  r = await updateMany(options,dbm,col, json_api, query); break;
-    case 'drop':        r = await drop(options,dbm,col); break;
-    case 'find':        r = await findMany(options,dbm,col,json); break;
-    default:            r = await command(options,dbm,json); 
+    case 'insert':            r = await insert(options,dbm,col, json_api); break;
+    case 'insertMany':        r = await insertMany(options,dbm,col, json_api); break;
+    case 'upsert':            r = await upsert(options,dbm,col, json_api, query); break;
+    case 'update':            r = await update(options,dbm,col, json_api, query); break;
+    case 'updateMany':        r = await updateMany(options,dbm,col, json_api, query); break;
+    case 'deleteOne':         r = await deleteOne(options,dbm,col, query); break;
+    case 'deleteMany':        r = await deleteMany(options,dbm,col, json); break;
+    case 'count':             r = await count(options,dbm,col, json); break;
+    case 'dbs':               r = await dbs(options); break;
+    case 'collections':       r = await collections(options,dbm); break;
+    case 'drop':              r = await drop(options,dbm,col); break;
+    case 'find':              r = await findMany(options,dbm,col,json); break;
+    case 'findOne':           r = await findOne(options,dbm,col, query, json.sort); break;
+    case 'aggregate':         r = await aggregate(options,dbm,col, json.pipeline); break;
+    case 'distinct':          r = await distinct(options,dbm,col, json.field, query); break;
+    case 'findOneAndUpdate':  r = await findOneAndUpdate(options,dbm,col, query, json_api, json.returnNew); break;
+    case 'findOneAndDelete':  r = await findOneAndDelete(options,dbm,col, query); break;
+    case 'replaceOne':        r = await replaceOne(options,dbm,col, query, json_api); break;
+    default:                  r = await command(options,dbm,json); 
     }
 
   return new Promise((resolve, reject)=>{ 
@@ -665,10 +708,271 @@ const api=async(options,dbm, json)=>{
   })
 }
 
+const findOne=async(options,dbm, col, query, orderby)=>{
+  const exec        = require("./exec");
+  const mongoclient = exec.mongoConn(options);
+  orderby = orderby!=null?orderby:'';
+  const start = Date.now();
+  
+  return new Promise((resolve, reject)=>{
+    mongoclient.then(
+      function(client){
+         let db = client.db(dbm);
+         db.collection(col).findOne(query, {sort: orderby}, function(err, result) {
+            const end = Date.now();
+            const time = end - start;
+
+            if (err) {
+              resolve({"result":{"dml":"findOne", "headers":"", "time":utl.milisegundosASegundos(time), code:204, error:1, msg:err}, results:err});
+            }else{
+              resolve({"result":{"dml":"findOne", "headers":getFields(result), "time":utl.milisegundosASegundos(time), code:200, error:0}, data:result ? [result] : []});
+            }
+
+            try{
+              exec.mongoClose(mongoclient);
+            }catch(e){
+              utl.log('err.findOne '+e);
+            }
+         });
+      }
+    ).catch(err=>{
+      resolve({"result":{"dml":"findOne", "headers":"", time:0, code:404, error:1}, "results":err});
+    });
+  })
+}
+
+const deleteOne=async(options,dbm, col, query)=>{
+  const exec        = require("./exec");
+  const mongoclient = exec.mongoConn(options);
+  const start = Date.now();
+  
+  return new Promise((resolve, reject)=>{
+    mongoclient.then(
+      function(client){
+         let db = client.db(dbm);
+         db.collection(col).deleteOne(query, function(err, res) {
+           const end = Date.now();
+           const time = end - start;
+           let result, deletedCount=0;
+           try{ result = res.result; deletedCount = res.result.n; } catch(e){ }           
+            if (err) { 
+              resolve({result:{dml:"deleteOne", headers:"", time:utl.milisegundosASegundos(time), code:204, error:1, msg:err}, results:err});
+            }else{
+              resolve({result:{dml:"deleteOne", headers:"deletedCount", time:utl.milisegundosASegundos(time), code:200, error:0}, results:{WriteResult:`${deletedCount} document deleted`, result }});
+            }
+            try{
+              exec.mongoClose(mongoclient);
+            }catch(e){
+              utl.log('err.deleteOne '+e);
+            }
+         });
+      }
+    ).catch(err=>{
+      resolve({result:{dml:"deleteOne", headers:"", time:0, code:404, error:1}, results:err});
+    });
+  })
+}
+
+const insertMany=async(options,dbm, col, documents)=>{
+  const exec        = require("./exec");
+  const mongoclient = exec.mongoConn(options);
+  const start = Date.now();
+  
+  return new Promise((resolve, reject)=>{
+    mongoclient.then(
+      function(client){
+         let db = client.db(dbm);
+         db.collection(col).insertMany(documents, function(err, res) {
+          const end = Date.now();
+          const time = end - start;
+            if (err) {
+              resolve({result:{dml:"insertMany", headers:"", time:utl.milisegundosASegundos(time), code:204, error:1, msg:err}, results:err});
+            }else{
+              let ops=res.ops!=null?res.ops:{};
+              resolve({result:{dml:"insertMany", headers:"insertedCount", insertedCount:res.insertedCount, time:utl.milisegundosASegundos(time), code:200, error:0}, results:{WriteResult:`${res.insertedCount} documents inserted`, ops}});
+            }
+            try{
+              exec.mongoClose(mongoclient);
+            }catch(e){
+              utl.log('err.insertMany '+e);
+            }
+         });
+      }
+    ).catch(err=>{
+      resolve({"result":{"dml":"insertMany", "headers":"", time:0, code:404, error:1}, results:err});
+    });
+  })
+}
+
+const aggregate=async(options,dbm, col, pipeline)=>{
+  const exec        = require("./exec");
+  const mongoclient = exec.mongoConn(options);
+  const start = Date.now();
+  
+  return new Promise((resolve, reject)=>{
+    mongoclient.then(
+      function(client){
+         let db = client.db(dbm);
+         db.collection(col).aggregate(pipeline).toArray(function(err, result) {
+            const end = Date.now();
+            const time = end - start;
+
+            if (err) {
+              resolve({"result":{"dml":"aggregate", "headers":"", "time":utl.milisegundosASegundos(time), code:204, error:1, msg:err}, results:err});
+            }else{
+              resolve({"result":{"dml":"aggregate", "headers":getFields(result[0]), "time":utl.milisegundosASegundos(time), code:200, error:0}, data:result});
+            }
+
+            try{
+              exec.mongoClose(mongoclient);
+            }catch(e){
+              utl.log('err.aggregate '+e);
+            }
+         });
+      }
+    ).catch(err=>{
+      resolve({"result":{"dml":"aggregate", "headers":"", time:0, code:404, error:1}, "results":err});
+    });
+  })
+}
+
+const distinct=async(options,dbm, col, field, query={})=>{
+  const exec        = require("./exec");
+  const mongoclient = exec.mongoConn(options);
+  const start = Date.now();
+  
+  return new Promise((resolve, reject)=>{
+    mongoclient.then(
+      function(client){
+         let db = client.db(dbm);
+         db.collection(col).distinct(field, query, function(err, result) {
+            const end = Date.now();
+            const time = end - start;
+
+            if (err) {
+              resolve({"result":{"dml":"distinct", "headers":"", "time":utl.milisegundosASegundos(time), code:204, error:1, msg:err}, results:err});
+            }else{
+              resolve({"result":{"dml":"distinct", "headers":field, "time":utl.milisegundosASegundos(time), code:200, error:0}, data:result});
+            }
+
+            try{
+              exec.mongoClose(mongoclient);
+            }catch(e){
+              utl.log('err.distinct '+e);
+            }
+         });
+      }
+    ).catch(err=>{
+      resolve({"result":{"dml":"distinct", "headers":"", time:0, code:404, error:1}, "results":err});
+    });
+  })
+}
+
+const findOneAndUpdate=async(options,dbm, col, query, json_obj, returnNew=true)=>{
+  const exec        = require("./exec");
+  const mongoclient = exec.mongoConn(options);
+  const start = Date.now();
+  
+  return new Promise((resolve, reject)=>{
+    mongoclient.then(
+      function(client){
+         let db = client.db(dbm);
+         db.collection(col).findOneAndUpdate(query, { $set: json_obj }, { returnDocument: returnNew ? 'after' : 'before' }, function(err, res) {
+           const end = Date.now();
+           const time = end - start;
+           let result;
+           try{ result = res.value; } catch(e){ }           
+            if (err) { 
+              resolve({result:{dml:"findOneAndUpdate", headers:"", time:utl.milisegundosASegundos(time), code:204, error:1, msg:err}, results:err});
+            }else{
+              resolve({result:{dml:"findOneAndUpdate", headers:getFields(result), time:utl.milisegundosASegundos(time), code:200, error:0}, data:result ? [result] : [], results:{ok: res.ok, lastErrorObject: res.lastErrorObject}});
+            }
+            try{
+              exec.mongoClose(mongoclient);
+            }catch(e){
+              utl.log('err.findOneAndUpdate '+e);
+            }
+         });
+      }
+    ).catch(err=>{
+      resolve({result:{dml:"findOneAndUpdate", headers:"", time:0, code:404, error:1}, results:err});
+    });
+  })
+}
+
+const findOneAndDelete=async(options,dbm, col, query)=>{
+  const exec        = require("./exec");
+  const mongoclient = exec.mongoConn(options);
+  const start = Date.now();
+  
+  return new Promise((resolve, reject)=>{
+    mongoclient.then(
+      function(client){
+         let db = client.db(dbm);
+         db.collection(col).findOneAndDelete(query, function(err, res) {
+           const end = Date.now();
+           const time = end - start;
+           let result;
+           try{ result = res.value; } catch(e){ }           
+            if (err) { 
+              resolve({result:{dml:"findOneAndDelete", headers:"", time:utl.milisegundosASegundos(time), code:204, error:1, msg:err}, results:err});
+            }else{
+              resolve({result:{dml:"findOneAndDelete", headers:getFields(result), time:utl.milisegundosASegundos(time), code:200, error:0}, data:result ? [result] : [], results:{ok: res.ok, lastErrorObject: res.lastErrorObject}});
+            }
+            try{
+              exec.mongoClose(mongoclient);
+            }catch(e){
+              utl.log('err.findOneAndDelete '+e);
+            }
+         });
+      }
+    ).catch(err=>{
+      resolve({result:{dml:"findOneAndDelete", headers:"", time:0, code:404, error:1}, results:err});
+    });
+  })
+}
+
+const replaceOne=async(options,dbm, col, query, json_obj)=>{
+  const exec        = require("./exec");
+  const mongoclient = exec.mongoConn(options);
+  const start = Date.now();
+  
+  return new Promise((resolve, reject)=>{
+    mongoclient.then(
+      function(client){
+         let db = client.db(dbm);
+         db.collection(col).replaceOne(query, json_obj, function(err, res) {
+           const end = Date.now();
+           const time = end - start;
+           let result, modifiedCount=0;
+           try{ result = res.result; modifiedCount = res.result.nModified; } catch(e){ }           
+            if (err) { 
+              resolve({result:{dml:"replaceOne", headers:"", time:utl.milisegundosASegundos(time), code:204, error:1, msg:err}, results:err});
+            }else{
+              resolve({result:{dml:"replaceOne", headers:"replaceOne", time:utl.milisegundosASegundos(time), code:200, error:0}, results:{WriteResult:`${modifiedCount} document replaced`, result }});
+            }
+            try{
+              exec.mongoClose(mongoclient);
+            }catch(e){
+              utl.log('err.replaceOne '+e);
+            }
+         });
+      }
+    ).catch(err=>{
+      resolve({result:{dml:"replaceOne", headers:"", time:0, code:404, error:1}, results:err});
+    });
+  })
+}
+
 module.exports ={
     find,
+    findOne,
     insert,
+    insertMany,
     update,
+    updateMany,
+    deleteMany,
+    deleteOne,
     count,
     dbs,
     collections,
@@ -678,5 +982,10 @@ module.exports ={
     command,
     api,
     drop,
-    findMany
+    findMany,
+    aggregate,
+    distinct,
+    findOneAndUpdate,
+    findOneAndDelete,
+    replaceOne
 }