bonsaif 1.10.37 → 1.10.38

package/lib/hookup/mongoose.js

@@ -732,38 +732,195 @@ const distinct = async (options, db, collection, query) => {
   }
 };
 
+/**
+ * DBS - Listar todas las bases de datos
+ */
+const dbs = async (options) => {
+  const start = Date.now();
+  
+  try {
+    const mongoose = require('mongoose');
+    await connect(options);
+    
+    const adminDb = mongoose.connection.db.admin();
+    const result = await adminDb.listDatabases();
+    
+    const end = Date.now();
+    const time = end - start;
+    
+    return {
+      result: {
+        dml: 'dbs',
+        headers: 'name|sizeOnDisk|empty',
+        time: utl.milisegundosASegundos(time),
+        code: 200,
+        error: 0
+      },
+      results: { totalSize: result.totalSize || 0 },
+      data: result.databases || []
+    };
+  } catch (e) {
+    const end = Date.now();
+    const time = end - start;
+    utl.log(`${tag} dbs error:`, e);
+    return {
+      result: {
+        dml: 'dbs',
+        time: utl.milisegundosASegundos(time),
+        code: 500,
+        error: 1,
+        msg: e.message
+      },
+      data: []
+    };
+  }
+};
+
+/**
+ * COLLECTIONS - Listar todas las colecciones de una base de datos
+ */
+const collections = async (options, db) => {
+  const start = Date.now();
+  
+  try {
+    const mongoose = require('mongoose');
+    await connect(options);
+    
+    const dbConn = mongoose.connection.useDb(db);
+    const colls = await dbConn.db.listCollections().toArray();
+    
+    const end = Date.now();
+    const time = end - start;
+    
+    return {
+      result: {
+        dml: 'collections',
+        headers: 'name|type',
+        db,
+        time: utl.milisegundosASegundos(time),
+        code: 200,
+        error: 0
+      },
+      results: colls,
+      data: colls
+    };
+  } catch (e) {
+    const end = Date.now();
+    const time = end - start;
+    utl.log(`${tag} collections error:`, e);
+    return {
+      result: {
+        dml: 'collections',
+        time: utl.milisegundosASegundos(time),
+        code: 500,
+        error: 1,
+        msg: e.message
+      },
+      data: []
+    };
+  }
+};
+
+/**
+ * DROP - Eliminar una colección completa
+ */
+const drop = async (options, db, collection) => {
+  const start = Date.now();
+  
+  try {
+    const mongoose = require('mongoose');
+    await connect(options);
+    
+    const dbConn = mongoose.connection.useDb(db);
+    const result = await dbConn.db.dropCollection(collection);
+    
+    const end = Date.now();
+    const time = end - start;
+    
+    return {
+      result: {
+        dml: 'drop',
+        collection,
+        db,
+        time: utl.milisegundosASegundos(time),
+        code: 200,
+        error: 0
+      },
+      results: result,
+      data: { drop: result }
+    };
+  } catch (e) {
+    const end = Date.now();
+    const time = end - start;
+    utl.log(`${tag} drop error:`, e);
+    return {
+      result: {
+        dml: 'drop',
+        time: utl.milisegundosASegundos(time),
+        code: 500,
+        error: 1,
+        msg: e.message
+      },
+      data: { drop: false }
+    };
+  }
+};
+
 /**
  * API - Router principal para todas las operaciones
  */
 const api = async (options, db, body) => {
   let { dml = '', collection = '' } = body;
   
-  // Compatibilidad con formato MongoDB: collection puede venir en json.[dml]
-  if (!collection && dml) {
-    collection = body[dml] || '';
-  }
-  
-  // Si aún no hay collection, intentar extraer del body
-  if (!collection) {
-    const possibleDmls = ['find', 'findOne', 'insert', 'update', 'updateMany', 
-                          'delete', 'deleteMany', 'upsert', 'count', 'aggregate', 'distinct'];
+  // Si dml es 'api', buscar el DML real en el body
+  if (dml === 'api' || !dml) {
+    const possibleDmls = ['find', 'findOne', 'insert', 'insertMany', 'update', 'updateMany', 
+                          'delete', 'deleteMany', 'upsert', 'count', 'aggregate', 'distinct',
+                          'dbs', 'collections', 'drop'];
     for (const possibleDml of possibleDmls) {
-      if (body[possibleDml]) {
+      if (body[possibleDml] !== undefined) {
         dml = possibleDml;
-        collection = body[possibleDml];
+        // En formato MongoDB, la colección viene en body.[dml]
+        if (typeof body[possibleDml] === 'string') {
+          collection = body[possibleDml];
+        }
         break;
       }
     }
   }
   
-  if (!collection) {
+  // Compatibilidad con formato MongoDB: collection puede venir en json.[dml]
+  if (!collection && dml && dml !== 'api') {
+    collection = body[dml] || '';
+  }
+  
+  // Si aún no hay collection pero hay document/documents, usar dml por defecto
+  if (!collection && body.document) {
+    dml = dml || 'insert';
+  }
+  
+  // Validar que collection tenga un valor (excepto para dbs y collections que no lo necesitan)
+  const requiresCollection = !['dbs', 'collections'].includes(dml);
+  
+  if (requiresCollection && (!collection || collection === '')) {
+    const errorMsg = collection === '' 
+      ? 'La "collection" está vacía. Asegúrate de que la variable tenga un valor válido.'
+      : 'Se requiere especificar "collection" en body.collection o body.[dml]';
+    
     return {
       result: {
         dml: dml || 'unknown',
         time: 0,
         code: 400,
         error: 1,
-        msg: 'Se requiere especificar "collection" en body.collection o body.[dml]'
+        msg: errorMsg,
+        debug: {
+          receivedDml: body.dml,
+          detectedDml: dml,
+          collectionValue: collection,
+          collectionIsEmpty: collection === '',
+          bodyKeys: Object.keys(body)
+        }
       },
       data: []
     };
@@ -784,6 +941,9 @@ const api = async (options, db, body) => {
     case 'deleteMany':  r = await deleteMany(options, db, collection, body); break;
     case 'aggregate':   r = await aggregate(options, db, collection, body); break;
     case 'distinct':    r = await distinct(options, db, collection, body); break;
+    case 'dbs':         r = await dbs(options); break;
+    case 'collections': r = await collections(options, db); break;
+    case 'drop':        r = await drop(options, db, collection); break;
     default:
       r = {
         result: {
@@ -796,7 +956,7 @@ const api = async (options, db, body) => {
         supportedOperations: [
           'find', 'findOne', 'count', 'insert', 'insertMany',
           'update', 'updateMany', 'upsert', 'delete', 'deleteMany',
-          'aggregate', 'distinct'
+          'aggregate', 'distinct', 'dbs', 'collections', 'drop'
         ]
       };
   }
@@ -820,6 +980,9 @@ module.exports = {
   deleteMany,
   aggregate,
   distinct,
+  dbs,
+  collections,
+  drop,
   connect,
   getModel
 };

package/package.json

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