bonsaif 1.10.41 → 1.10.43

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});
+    });
   })
 }
 
@@ -320,6 +326,7 @@ const buildQuery=(field,value)=>{
       //console.log('tipo:'+tipo);
       switch (tipo){
         case 'id':
+        case '_id':
           eval('where.'+ltField[i]+' = new ObjectId('+val+'); '); 
         break;
 
@@ -607,7 +614,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 +625,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 +636,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 +646,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 +678,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 +709,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 +983,10 @@ module.exports ={
     command,
     api,
     drop,
-    findMany
+    findMany,
+    aggregate,
+    distinct,
+    findOneAndUpdate,
+    findOneAndDelete,
+    replaceOne
 }

package/lib/hookup/redis.js

@@ -560,7 +560,7 @@ const del=async( options,db, key )=>{  //DEL key [key ...]
 
 // Busca llaves de un hash con la combinacion de busquedas similar a un where
 // 2022/04/26 VRSZ Se cambia la busqueda de rows 
-const hfind=async(options,db, key, filter, order, limit=100)=>{   
+const hfind=async(options,db, key, filter, order, limit=1000)=>{   
   let {field:orderBy, val:orderVal} = getFirstField(order);
   
   //2022/10/14 VRSZ Se realiza regla para combinar sentencias IN, AND, y/o OR 
@@ -882,7 +882,7 @@ const api=async(options, dbm, json)=>{
   let order = json.order!=null ? json.order:{};
   let counter  = json.counter!=null?json.counter:0; 
   let toJson  = json.toJson!=null?json.toJson:0;
-  let limit  = json.limit!=null?json.limit:100;
+  let limit  = json.limit!=null?json.limit:1000;
 
   let lstart = json.start!=null?json.start*1:0;
   let lstop  = json.stop!=null?json.stop*1:-1;

package/package.json

@@ -14,7 +14,7 @@
   },
   "name": "bonsaif",
   "description": "bonsaif is a library to connect to bonsaif apis",
-  "version": "1.10.41",
+  "version": "1.10.43",
   "main": "index.js",
   "directories": {
     "lib": "lib"

package/tests/test-mongodb.js

@@ -1,133 +1,254 @@
 /**
- * Pruebas de conexiones MongoDB
+ * Pruebas y Ejemplos de MongoDB
  * Ejecutar: node tests/test-mongodb.js
  */
 
 const config = require('./config');
 const mongodb = require('../lib/hookup/mongodb');
 
-console.log('=== INICIANDO PRUEBAS MONGODB ===\n');
+console.log('=== EJEMPLOS Y PRUEBAS MONGODB ===\n');
 
-async function testMongoDB() {
+async function ejemplosYPruebas() {
   const dbName = 'test_bonsaif';
   const collection = 'test_collection';
   
   try {
-    // Test 1: INSERT
-    console.log('1. Probando INSERT...');
-    const insertResult = await mongodb.insert(
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('📝 EJEMPLOS DE INSERT');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+
+    // EJEMPLO 1: INSERT con 1 documento usando api()
+    console.log('1️⃣  INSERT con documents[] - UN documento (usa insert internamente):');
+    console.log('   Código:');
+    console.log('   await mongodb.api(config.mongodb, dbName, {');
+    console.log('     insert: collection,');
+    console.log('     documents: [{name: "Juan", email: "juan@example.com"}]');
+    console.log('   })\n');
+    const insertResult = await mongodb.api(
       config.mongodb,
       dbName,
-      collection,
-      {name: 'Test User', email: 'test@example.com', created: new Date()}
+      {
+        insert: collection,
+        documents: [{name: 'Juan Pérez', email: 'juan@example.com', age: 30, created: new Date()}]
+      }
     );
-    console.log('   ✓ INSERT exitoso:', insertResult);
+    console.log('   ✅ Resultado:', insertResult.result);
     const insertId = insertResult.result.insertId;
-    
-    // Test 2: FIND
-    console.log('\n2. Probando FIND...');
-    const findResult = await mongodb.find(
+
+    // EJEMPLO 2: INSERT con múltiples documentos usando api()
+    console.log('\n2️⃣  INSERT con documents[] - MÚLTIPLES documentos (usa insertMany automáticamente):');
+    console.log('   Código:');
+    console.log('   await mongodb.api(config.mongodb, dbName, {');
+    console.log('     insert: collection,');
+    console.log('     documents: [');
+    console.log('       {name: "María", email: "maria@example.com"},');
+    console.log('       {name: "Pedro", email: "pedro@example.com"},');
+    console.log('       {name: "Ana", email: "ana@example.com"}');
+    console.log('     ]');
+    console.log('   })\n');
+    const insertManyResult = await mongodb.api(
       config.mongodb,
       dbName,
-      collection,
-      {name: 'Test User'},
-      {created: -1},
-      10
+      {
+        insert: collection,
+        documents: [
+          {name: 'María López', email: 'maria@example.com', age: 25, status: 'active'},
+          {name: 'Pedro Ramírez', email: 'pedro@example.com', age: 35, status: 'active'},
+          {name: 'Ana García', email: 'ana@example.com', age: 28, status: 'inactive'}
+        ]
+      }
     );
-    console.log('   ✓ FIND exitoso:', {
-      count: findResult.data?.length,
-      data: findResult.data?.[0]
-    });
-    
-    // Test 3: UPDATE
-    console.log('\n3. Probando UPDATE...');
-    const updateResult = await mongodb.update(
+    console.log('   ✅ Resultado:', insertManyResult.result);
+    console.log('   ✅ Documentos insertados:', insertManyResult.result.insertedCount);
+
+    console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('📝 EJEMPLOS DE UPDATE');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+
+    // EJEMPLO 3: UPDATE con 1 documento
+    console.log('3️⃣  UPDATE con documents[] - UN documento (usa update/updateOne):');
+    console.log('   Código:');
+    console.log('   await mongodb.api(config.mongodb, dbName, {');
+    console.log('     update: collection,');
+    console.log('     filter: {name: "Juan Pérez"},');
+    console.log('     documents: [{email: "juannuevo@example.com", updated: new Date()}]');
+    console.log('   })\n');
+    const updateResult = await mongodb.api(
       config.mongodb,
       dbName,
-      collection,
-      {email: 'updated@example.com', updated: new Date()},
-      {_id: insertId}
+      {
+        update: collection,
+        filter: {name: 'Juan Pérez'},
+        documents: [{email: 'juannuevo@example.com', updated: new Date()}]
+      }
     );
-    console.log('   ✓ UPDATE exitoso:', updateResult);
-    
-    // Test 4: COUNT
-    console.log('\n4. Probando COUNT...');
-    const countResult = await mongodb.count(
+    console.log('   ✅ Resultado:', updateResult.result);
+
+    // EJEMPLO 4: UPDATEMANY con múltiples documentos
+    console.log('\n4️⃣  UPDATE con documents[] - MÚLTIPLES documentos (usa updateMany):');
+    console.log('   Código:');
+    console.log('   await mongodb.api(config.mongodb, dbName, {');
+    console.log('     updateMany: collection,');
+    console.log('     filter: {status: "active"},');
+    console.log('     documents: [{status: "verified", verifiedAt: new Date()}]');
+    console.log('   })\n');
+    const updateManyResult = await mongodb.api(
       config.mongodb,
       dbName,
-      collection,
-      {filter: {name: 'Test User'}}
+      {
+        updateMany: collection,
+        filter: {status: 'active'},
+        documents: [{status: 'verified', verifiedAt: new Date()}]
+      }
     );
-    console.log('   ✓ COUNT exitoso:', countResult);
-    
-    // Test 5: COMMAND (find)
-    console.log('\n5. Probando COMMAND...');
-    const commandResult = await mongodb.command(
+    console.log('   ✅ Resultado:', updateManyResult.result);
+
+    console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('📝 EJEMPLOS DE OTROS COMANDOS');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+
+    // EJEMPLO 5: FINDONE
+    console.log('5️⃣  FINDONE - Buscar un documento:');
+    console.log('   Código:');
+    console.log('   await mongodb.api(config.mongodb, dbName, {');
+    console.log('     findOne: collection,');
+    console.log('     filter: {name: "Juan Pérez"}');
+    console.log('   })\n');
+    const findOneResult = await mongodb.api(
       config.mongodb,
       dbName,
-      {find: collection, filter: {name: 'Test User'}, limit: 5}
+      {
+        findOne: collection,
+        filter: {name: 'Juan Pérez'}
+      }
     );
-    console.log('   ✓ COMMAND exitoso:', {
-      count: commandResult.data?.length
-    });
-    
-    // Test 6: UPSERT (update existing)
-    console.log('\n6. Probando UPSERT (update)...');
-    const upsertUpdateResult = await mongodb.upsert(
+    console.log('   ✅ Encontrado:', findOneResult.data?.[0]?.name);
+
+    // EJEMPLO 6: AGGREGATE
+    console.log('\n6️⃣  AGGREGATE - Pipeline de agregación:');
+    console.log('   Código:');
+    console.log('   await mongodb.api(config.mongodb, dbName, {');
+    console.log('     aggregate: collection,');
+    console.log('     pipeline: [');
+    console.log('       {$match: {status: "verified"}},');
+    console.log('       {$group: {_id: "$status", count: {$sum: 1}}}');
+    console.log('     ]');
+    console.log('   })\n');
+    const aggregateResult = await mongodb.api(
       config.mongodb,
       dbName,
-      collection,
-      {name: 'Test User', email: 'upserted@example.com'},
-      {_id: insertId}
+      {
+        aggregate: collection,
+        pipeline: [
+          {$match: {status: 'verified'}},
+          {$group: {_id: '$status', total: {$sum: 1}, avgAge: {$avg: '$age'}}}
+        ]
+      }
     );
-    console.log('   ✓ UPSERT (update) exitoso:', upsertUpdateResult);
-    
-    // Test 7: UPSERT (insert new)
-    console.log('\n7. Probando UPSERT (insert)...');
-    const upsertInsertResult = await mongodb.upsert(
+    console.log('   ✅ Resultado:', aggregateResult.data);
+
+    // EJEMPLO 7: DISTINCT
+    console.log('\n7️⃣  DISTINCT - Valores únicos:');
+    console.log('   Código:');
+    console.log('   await mongodb.api(config.mongodb, dbName, {');
+    console.log('     distinct: collection,');
+    console.log('     field: "status",');
+    console.log('     filter: {}');
+    console.log('   })\n');
+    const distinctResult = await mongodb.api(
       config.mongodb,
       dbName,
-      collection,
-      {name: 'New User', email: 'new@example.com'},
-      {name: 'New User'}
+      {
+        distinct: collection,
+        field: 'status',
+        filter: {}
+      }
     );
-    console.log('   ✓ UPSERT (insert) exitoso:', upsertInsertResult);
-    
-    // Test 8: DBS
-    console.log('\n8. Probando DBS...');
-    const dbsResult = await mongodb.dbs(config.mongodb);
-    console.log('   ✓ DBS exitoso:', {
-      totalSize: dbsResult.results?.totalSize,
-      dbCount: dbsResult.data?.length
-    });
-    
-    // Test 9: COLLECTIONS
-    console.log('\n9. Probando COLLECTIONS...');
-    const collectionsResult = await mongodb.collections(config.mongodb, dbName);
-    console.log('   ✓ COLLECTIONS exitoso:', {
-      count: collectionsResult.data?.length,
-      collections: collectionsResult.data?.map(c => c.name).slice(0, 5)
-    });
-    
-    // Cleanup
-    console.log('\n10. Limpiando datos de prueba...');
+    console.log('   ✅ Valores únicos de status:', distinctResult.data);
+
+    // EJEMPLO 8: REPLACEONE
+    console.log('\n8️⃣  REPLACEONE - Reemplazar documento completo:');
+    console.log('   Código:');
+    console.log('   await mongodb.api(config.mongodb, dbName, {');
+    console.log('     replaceOne: collection,');
+    console.log('     filter: {name: "Ana García"},');
+    console.log('     documents: [{name: "Ana García Updated", email: "ananueva@example.com", replaced: true}]');
+    console.log('   })\n');
+    const replaceOneResult = await mongodb.api(
+      config.mongodb,
+      dbName,
+      {
+        replaceOne: collection,
+        filter: {name: 'Ana García'},
+        documents: [{name: 'Ana García Updated', email: 'ananueva@example.com', replaced: true}]
+      }
+    );
+    console.log('   ✅ Resultado:', replaceOneResult.result);
+
+    // EJEMPLO 9: FINDONEANDUPDATE
+    console.log('\n9️⃣  FINDONEANDUPDATE - Buscar y actualizar (retorna el documento):');
+    console.log('   Código:');
+    console.log('   await mongodb.api(config.mongodb, dbName, {');
+    console.log('     findOneAndUpdate: collection,');
+    console.log('     filter: {name: "María López"},');
+    console.log('     documents: [{score: 100}],');
+    console.log('     returnNew: true  // true = retorna actualizado, false = retorna anterior');
+    console.log('   })\n');
+    const findOneAndUpdateResult = await mongodb.api(
+      config.mongodb,
+      dbName,
+      {
+        findOneAndUpdate: collection,
+        filter: {name: 'María López'},
+        documents: [{score: 100, modified: true}],
+        returnNew: true
+      }
+    );
+    console.log('   ✅ Documento actualizado:', findOneAndUpdateResult.data?.[0]);
+
+    // EJEMPLO 10: UPSERT
+    console.log('\n🔟 UPSERT - Actualizar si existe, insertar si no existe:');
+    console.log('   Código:');
+    console.log('   await mongodb.api(config.mongodb, dbName, {');
+    console.log('     upsert: collection,');
+    console.log('     filter: {name: "Usuario Nuevo"},');
+    console.log('     document: {name: "Usuario Nuevo", email: "nuevo@example.com"}');
+    console.log('   })\n');
+    const upsertResult = await mongodb.api(
+      config.mongodb,
+      dbName,
+      {
+        upsert: collection,
+        filter: {name: 'Usuario Nuevo'},
+        document: {name: 'Usuario Nuevo', email: 'nuevo@example.com', created: new Date()}
+      }
+    );
+    console.log('   ✅ Resultado:', upsertResult.result);
+
+    // Limpieza
+    console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('🧹 Limpiando datos de prueba...');
     const deleteResult = await mongodb.api(
       config.mongodb,
       dbName,
       {
         deleteMany: collection,
-        filter: {$or: [{name: 'Test User'}, {name: 'New User'}]}
+        filter: {}
       }
     );
-    console.log('   ✓ Limpieza completada:', deleteResult.result);
+    console.log('✅ Limpieza completada\n');
     
-    console.log('\n=== ✓ TODAS LAS PRUEBAS MONGODB EXITOSAS ===\n');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('✅ TODOS LOS EJEMPLOS Y PRUEBAS COMPLETADOS');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+    process.exit(0);
     
   } catch (error) {
-    console.error('\n=== ✗ ERROR EN PRUEBAS MONGODB ===');
+    console.error('\n=== ✗ ERROR EN EJEMPLOS ===');
     console.error(error);
     process.exit(1);
   }
 }
 
-testMongoDB();
+ejemplosYPruebas();
+