bonsaif 1.10.40 → 1.10.41

package/lib/hookup/mongoose.js

@@ -0,0 +1,1102 @@
+/**
+ * ::: B[]NSAIF() ::: => 2024
+ * Hookup para Mongoose (MongoDB ORM)
+ * Compatible con múltiples versiones de Node y Mongoose
+ */
+
+'use strict';
+
+const utl = require('../utl');
+let debug = false;
+let tag = ` ::: B[]NSAIF() ::: => mongoose.js `;
+
+// Validar disponibilidad de Mongoose
+let mongoose = null;
+let isMongooseAvailable = false;
+let mongooseVersion = null;
+
+try {
+  mongoose = require('mongoose');
+  isMongooseAvailable = true;
+  mongooseVersion = mongoose.version;
+  
+  // Validar versión de Node
+  const nodeVersion = process.version;
+  const nodeMajor = parseInt(nodeVersion.split('.')[0].substring(1));
+  
+  if (nodeMajor < 12) {
+    utl.log(`${tag} WARNING: Node ${nodeVersion} no es compatible con Mongoose. Se requiere Node >= 12.0.0`);
+    isMongooseAvailable = false;
+  }
+  
+} catch (e) {
+  utl.log(`${tag} Mongoose no está instalado. Para usar mongoose, instala: npm install mongoose@"^6.12.0" (Node 12-14) o mongoose@"^8.0.0" (Node >= 16.20.1)`);
+  isMongooseAvailable = false;
+}
+
+// Cache de modelos dinámicos por base de datos y colección
+const modelCache = new Map();
+
+/**
+ * Validar que Mongoose esté disponible
+ */
+const checkMongooseAvailable = () => {
+  if (!isMongooseAvailable) {
+    return {
+      result: {
+        dml: 'error',
+        time: 0,
+        code: 503,
+        error: 1,
+        msg: 'Mongoose no está disponible en este sistema',
+        details: {
+          nodeVersion: process.version,
+          mongooseInstalled: mongoose !== null,
+          recommendation: process.version.startsWith('v12') || process.version.startsWith('v14') 
+            ? 'Instala: npm install mongoose@^6.12.0' 
+            : 'Instala: npm install mongoose@^8.0.0 (requiere Node >= 16.20.1)'
+        }
+      },
+      data: []
+    };
+  }
+  return null;
+};
+
+/**
+ * Parsear schema dinámico recibido del cliente
+ * Convierte definición simple a Schema de Mongoose
+ */
+const parseSchema = (schemaDefinition) => {
+  const parsedSchema = {};
+  
+  for (const [field, def] of Object.entries(schemaDefinition)) {
+    if (typeof def === 'string') {
+      // Formato simple: { "name": "String" }
+      parsedSchema[field] = { type: mongoose.Schema.Types[def] || String };
+    } else if (typeof def === 'object') {
+      // Formato completo: { "name": { "type": "String", "required": true } }
+      const fieldDef = { ...def };
+      
+      // Convertir string del type a tipo real de Mongoose
+      if (def.type && typeof def.type === 'string') {
+        fieldDef.type = mongoose.Schema.Types[def.type] || String;
+      }
+      
+      // Convertir enum si existe
+      if (def.enum && Array.isArray(def.enum)) {
+        fieldDef.enum = def.enum;
+      }
+      
+      // Convertir default
+      if (def.default !== undefined) {
+        fieldDef.default = def.default;
+      }
+      
+      // Validaciones
+      if (def.required !== undefined) fieldDef.required = def.required;
+      if (def.unique !== undefined) fieldDef.unique = def.unique;
+      if (def.min !== undefined) fieldDef.min = def.min;
+      if (def.max !== undefined) fieldDef.max = def.max;
+      if (def.minlength !== undefined) fieldDef.minlength = def.minlength;
+      if (def.maxlength !== undefined) fieldDef.maxlength = def.maxlength;
+      if (def.trim !== undefined) fieldDef.trim = def.trim;
+      if (def.lowercase !== undefined) fieldDef.lowercase = def.lowercase;
+      if (def.uppercase !== undefined) fieldDef.uppercase = def.uppercase;
+      if (def.match !== undefined) fieldDef.match = new RegExp(def.match);
+      
+      // Referencias (populate)
+      if (def.ref) {
+        fieldDef.ref = def.ref;
+        fieldDef.type = mongoose.Schema.Types.ObjectId;
+      }
+      
+      parsedSchema[field] = fieldDef;
+    }
+  }
+  
+  return parsedSchema;
+};
+
+/**
+ * Conectar a MongoDB usando Mongoose
+ */
+const connect = async (options) => {
+  const availabilityError = checkMongooseAvailable();
+  if (availabilityError) throw new Error(availabilityError.result.msg);
+  
+  const { uri = '', poolSize = 10, debug: debugMode = false } = options.endpoint;
+  
+  try {
+    if (mongoose.connection.readyState === 1) {
+      debugMode ? utl.log(`${tag} [Mongoose] ya conectado`) : '';
+      return mongoose.connection;
+    }
+    
+    // Opciones compatibles con múltiples versiones de Mongoose
+    const connectOptions = {
+      serverSelectionTimeoutMS: 15000,
+      socketTimeoutMS: 45000,
+      connectTimeoutMS: 10000
+    };
+    
+    // Mongoose 6.x y 7.x usan useNewUrlParser, useUnifiedTopology
+    // Mongoose 8.x los depreca
+    const majorVersion = parseInt(mongooseVersion.split('.')[0]);
+    
+    if (majorVersion >= 6) {
+      // Mongoose 6.x, 7.x, 8.x
+      connectOptions.maxPoolSize = poolSize;
+      connectOptions.minPoolSize = 2;
+    } else {
+      // Mongoose 5.x
+      connectOptions.poolSize = poolSize;
+      connectOptions.useNewUrlParser = true;
+      connectOptions.useUnifiedTopology = true;
+    }
+    
+    await mongoose.connect(uri, connectOptions);
+    
+    debugMode ? utl.log(`${tag} [Mongoose ${mongooseVersion}] conectado a ${uri}`) : '';
+    return mongoose.connection;
+  } catch (e) {
+    utl.log(`${tag} [Mongoose] error de conexión:`, e);
+    throw e;
+  }
+};
+
+/**
+ * Obtener o crear modelo dinámico para una colección
+ */
+const getModel = (db, collection, schemaDefinition = null) => {
+  const cacheKey = schemaDefinition 
+    ? `${db}.${collection}.custom.${JSON.stringify(schemaDefinition)}` 
+    : `${db}.${collection}.generic`;
+  
+  if (modelCache.has(cacheKey)) {
+    return modelCache.get(cacheKey);
+  }
+  
+  let schema;
+  
+  if (schemaDefinition) {
+    // Schema personalizado con validaciones
+    const parsedSchema = parseSchema(schemaDefinition);
+    schema = new mongoose.Schema(parsedSchema, {
+      strict: true,
+      timestamps: true,
+      collection: collection
+    });
+  } else {
+    // Schema genérico (acepta cualquier campo)
+    schema = new mongoose.Schema({}, {
+      strict: false,
+      timestamps: true,
+      collection: collection
+    });
+  }
+  
+  // Crear modelo en la conexión específica de la BD
+  const conn = mongoose.connection.useDb(db);
+  
+  // Nombre único para evitar conflictos
+  const modelName = schemaDefinition 
+    ? `${collection}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
+    : collection;
+  
+  const Model = conn.model(modelName, schema);
+  
+  modelCache.set(cacheKey, Model);
+  return Model;
+};
+
+/**
+ * FIND - Búsqueda dinámica
+ */
+const find = async (options, db, collection, query) => {
+  const availabilityError = checkMongooseAvailable();
+  if (availabilityError) return availabilityError;
+  
+  const start = Date.now();
+  
+  try {
+    await connect(options);
+    
+    const { filter = {}, select = '', sort = {}, limit = 0, skip = 0, populate = '', schema = null } = query;
+    
+    const Model = getModel(db, collection, schema);
+    let mongoQuery = Model.find(filter);
+    
+    if (select) mongoQuery = mongoQuery.select(select);
+    if (Object.keys(sort).length > 0) mongoQuery = mongoQuery.sort(sort);
+    if (limit > 0) mongoQuery = mongoQuery.limit(limit);
+    if (skip > 0) mongoQuery = mongoQuery.skip(skip);
+    if (populate) mongoQuery = mongoQuery.populate(populate);
+    
+    const data = await mongoQuery.lean().exec();
+    
+    const end = Date.now();
+    const time = end - start;
+    
+    return {
+      result: {
+        dml: 'find',
+        collection,
+        db,
+        time: utl.milisegundosASegundos(time),
+        code: 200,
+        error: 0
+      },
+      data
+    };
+  } catch (e) {
+    const end = Date.now();
+    const time = end - start;
+    utl.log(`${tag} find error:`, e);
+    return {
+      result: {
+        dml: 'find',
+        time: utl.milisegundosASegundos(time),
+        code: 500,
+        error: 1,
+        msg: e.message
+      },
+      data: []
+    };
+  }
+};
+
+/**
+ * FINDONE - Buscar un solo documento
+ */
+const findOne = async (options, db, collection, query) => {
+  const availabilityError = checkMongooseAvailable();
+  if (availabilityError) return availabilityError;
+  
+  const start = Date.now();
+  
+  try {
+    await connect(options);
+    
+    const { filter = {}, select = '', populate = '', schema = null } = query;
+    
+    const Model = getModel(db, collection, schema);
+    let mongoQuery = Model.findOne(filter);
+    
+    if (select) mongoQuery = mongoQuery.select(select);
+    if (populate) mongoQuery = mongoQuery.populate(populate);
+    
+    const data = await mongoQuery.lean().exec();
+    
+    const end = Date.now();
+    const time = end - start;
+    
+    return {
+      result: {
+        dml: 'findOne',
+        collection,
+        db,
+        time: utl.milisegundosASegundos(time),
+        code: 200,
+        error: 0
+      },
+      data: data ? [data] : []
+    };
+  } catch (e) {
+    const end = Date.now();
+    const time = end - start;
+    utl.log(`${tag} findOne error:`, e);
+    return {
+      result: {
+        dml: 'findOne',
+        time: utl.milisegundosASegundos(time),
+        code: 500,
+        error: 1,
+        msg: e.message
+      },
+      data: []
+    };
+  }
+};
+
+/**
+ * COUNT - Contar documentos
+ */
+const count = async (options, db, collection, query) => {
+  const availabilityError = checkMongooseAvailable();
+  if (availabilityError) return availabilityError;
+  
+  const start = Date.now();
+  
+  try {
+    await connect(options);
+    
+    const { filter = {}, schema = null } = query;
+    
+    const Model = getModel(db, collection, schema);
+    const total = await Model.countDocuments(filter);
+    
+    const end = Date.now();
+    const time = end - start;
+    
+    return {
+      result: {
+        dml: 'count',
+        collection,
+        db,
+        time: utl.milisegundosASegundos(time),
+        code: 200,
+        error: 0
+      },
+      data: { count: total }
+    };
+  } catch (e) {
+    const end = Date.now();
+    const time = end - start;
+    utl.log(`${tag} count error:`, e);
+    return {
+      result: {
+        dml: 'count',
+        time: utl.milisegundosASegundos(time),
+        code: 500,
+        error: 1,
+        msg: e.message
+      },
+      data: { count: 0 }
+    };
+  }
+};
+
+/**
+ * INSERT - Crear documento
+ */
+const insert = async (options, db, collection, query) => {
+  const availabilityError = checkMongooseAvailable();
+  if (availabilityError) return availabilityError;
+  
+  const start = Date.now();
+  
+  try {
+    await connect(options);
+    
+    const { document = {}, schema = null } = query;
+    
+    const Model = getModel(db, collection, schema);
+    const doc = new Model(document);
+    const result = await doc.save();
+    
+    const end = Date.now();
+    const time = end - start;
+    
+    return {
+      result: {
+        dml: 'insert',
+        collection,
+        db,
+        insertId: result._id,
+        time: utl.milisegundosASegundos(time),
+        code: 200,
+        error: 0
+      },
+      data: [result.toObject()]
+    };
+  } catch (e) {
+    const end = Date.now();
+    const time = end - start;
+    utl.log(`${tag} insert error:`, e);
+    return {
+      result: {
+        dml: 'insert',
+        time: utl.milisegundosASegundos(time),
+        code: 500,
+        error: 1,
+        msg: e.message,
+        validationErrors: e.errors ? Object.keys(e.errors).map(key => ({
+          field: key,
+          message: e.errors[key].message
+        })) : undefined
+      },
+      data: []
+    };
+  }
+};
+
+/**
+ * INSERTMANY - Crear múltiples documentos
+ */
+const insertMany = async (options, db, collection, query) => {
+  const availabilityError = checkMongooseAvailable();
+  if (availabilityError) return availabilityError;
+  
+  const start = Date.now();
+  
+  try {
+    await connect(options);
+    
+    const { documents = [], schema = null } = query;
+    
+    const Model = getModel(db, collection, schema);
+    const results = await Model.insertMany(documents);
+    
+    const end = Date.now();
+    const time = end - start;
+    
+    return {
+      result: {
+        dml: 'insertMany',
+        collection,
+        db,
+        insertedCount: results.length,
+        time: utl.milisegundosASegundos(time),
+        code: 200,
+        error: 0
+      },
+      data: results.map(doc => doc.toObject())
+    };
+  } catch (e) {
+    const end = Date.now();
+    const time = end - start;
+    utl.log(`${tag} insertMany error:`, e);
+    return {
+      result: {
+        dml: 'insertMany',
+        time: utl.milisegundosASegundos(time),
+        code: 500,
+        error: 1,
+        msg: e.message
+      },
+      data: []
+    };
+  }
+};
+
+/**
+ * UPDATE - Actualizar documento(s)
+ */
+const update = async (options, db, collection, query) => {
+  const availabilityError = checkMongooseAvailable();
+  if (availabilityError) return availabilityError;
+  
+  const start = Date.now();
+  
+  try {
+    await connect(options);
+    
+    const { filter = {}, update: updateDoc = {}, options: updateOpts = {}, schema = null } = query;
+    
+    const Model = getModel(db, collection, schema);
+    const result = await Model.updateOne(filter, updateDoc, updateOpts);
+    
+    const end = Date.now();
+    const time = end - start;
+    
+    return {
+      result: {
+        dml: 'update',
+        collection,
+        db,
+        matchedCount: result.matchedCount,
+        modifiedCount: result.modifiedCount,
+        time: utl.milisegundosASegundos(time),
+        code: 200,
+        error: 0
+      },
+      data: {
+        matchedCount: result.matchedCount,
+        modifiedCount: result.modifiedCount
+      }
+    };
+  } catch (e) {
+    const end = Date.now();
+    const time = end - start;
+    utl.log(`${tag} update error:`, e);
+    return {
+      result: {
+        dml: 'update',
+        time: utl.milisegundosASegundos(time),
+        code: 500,
+        error: 1,
+        msg: e.message
+      },
+      data: {}
+    };
+  }
+};
+
+/**
+ * UPDATEMANY - Actualizar múltiples documentos
+ */
+const updateMany = async (options, db, collection, query) => {
+  const availabilityError = checkMongooseAvailable();
+  if (availabilityError) return availabilityError;
+  
+  const start = Date.now();
+  
+  try {
+    await connect(options);
+    
+    const { filter = {}, update: updateDoc = {}, options: updateOpts = {}, schema = null } = query;
+    
+    const Model = getModel(db, collection, schema);
+    const result = await Model.updateMany(filter, updateDoc, updateOpts);
+    
+    const end = Date.now();
+    const time = end - start;
+    
+    return {
+      result: {
+        dml: 'updateMany',
+        collection,
+        db,
+        matchedCount: result.matchedCount,
+        modifiedCount: result.modifiedCount,
+        time: utl.milisegundosASegundos(time),
+        code: 200,
+        error: 0
+      },
+      data: {
+        matchedCount: result.matchedCount,
+        modifiedCount: result.modifiedCount
+      }
+    };
+  } catch (e) {
+    const end = Date.now();
+    const time = end - start;
+    utl.log(`${tag} updateMany error:`, e);
+    return {
+      result: {
+        dml: 'updateMany',
+        time: utl.milisegundosASegundos(time),
+        code: 500,
+        error: 1,
+        msg: e.message
+      },
+      data: {}
+    };
+  }
+};
+
+/**
+ * UPSERT - Actualizar o insertar
+ */
+const upsert = async (options, db, collection, query) => {
+  const availabilityError = checkMongooseAvailable();
+  if (availabilityError) return availabilityError;
+  
+  const start = Date.now();
+  
+  try {
+    await connect(options);
+    
+    const { filter = {}, document = {}, schema = null } = query;
+    
+    const Model = getModel(db, collection, schema);
+    
+    // Buscar documento existente
+    const existing = await Model.findOne(filter);
+    
+    let result, operation;
+    
+    if (existing) {
+      // Actualizar
+      Object.assign(existing, document);
+      result = await existing.save();
+      operation = 'update';
+    } else {
+      // Insertar
+      const doc = new Model({ ...filter, ...document });
+      result = await doc.save();
+      operation = 'insert';
+    }
+    
+    const end = Date.now();
+    const time = end - start;
+    
+    return {
+      result: {
+        dml: 'upsert',
+        operation,
+        collection,
+        db,
+        time: utl.milisegundosASegundos(time),
+        code: 200,
+        error: 0
+      },
+      data: [result.toObject()]
+    };
+  } catch (e) {
+    const end = Date.now();
+    const time = end - start;
+    utl.log(`${tag} upsert error:`, e);
+    return {
+      result: {
+        dml: 'upsert',
+        time: utl.milisegundosASegundos(time),
+        code: 500,
+        error: 1,
+        msg: e.message
+      },
+      data: []
+    };
+  }
+};
+
+/**
+ * DELETE - Eliminar documento(s)
+ */
+const deleteOne = async (options, db, collection, query) => {
+  const availabilityError = checkMongooseAvailable();
+  if (availabilityError) return availabilityError;
+  
+  const start = Date.now();
+  
+  try {
+    await connect(options);
+    
+    const { filter = {}, schema = null } = query;
+    
+    const Model = getModel(db, collection, schema);
+    const result = await Model.deleteOne(filter);
+    
+    const end = Date.now();
+    const time = end - start;
+    
+    return {
+      result: {
+        dml: 'delete',
+        collection,
+        db,
+        deletedCount: result.deletedCount,
+        time: utl.milisegundosASegundos(time),
+        code: 200,
+        error: 0
+      },
+      data: { deletedCount: result.deletedCount }
+    };
+  } catch (e) {
+    const end = Date.now();
+    const time = end - start;
+    utl.log(`${tag} delete error:`, e);
+    return {
+      result: {
+        dml: 'delete',
+        time: utl.milisegundosASegundos(time),
+        code: 500,
+        error: 1,
+        msg: e.message
+      },
+      data: { deletedCount: 0 }
+    };
+  }
+};
+
+/**
+ * DELETEMANY - Eliminar múltiples documentos
+ */
+const deleteMany = async (options, db, collection, query) => {
+  const availabilityError = checkMongooseAvailable();
+  if (availabilityError) return availabilityError;
+  
+  const start = Date.now();
+  
+  try {
+    await connect(options);
+    
+    const { filter = {}, schema = null } = query;
+    
+    const Model = getModel(db, collection, schema);
+    const result = await Model.deleteMany(filter);
+    
+    const end = Date.now();
+    const time = end - start;
+    
+    return {
+      result: {
+        dml: 'deleteMany',
+        collection,
+        db,
+        deletedCount: result.deletedCount,
+        time: utl.milisegundosASegundos(time),
+        code: 200,
+        error: 0
+      },
+      data: { deletedCount: result.deletedCount }
+    };
+  } catch (e) {
+    const end = Date.now();
+    const time = end - start;
+    utl.log(`${tag} deleteMany error:`, e);
+    return {
+      result: {
+        dml: 'deleteMany',
+        time: utl.milisegundosASegundos(time),
+        code: 500,
+        error: 1,
+        msg: e.message
+      },
+      data: { deletedCount: 0 }
+    };
+  }
+};
+
+/**
+ * AGGREGATE - Pipeline de agregación
+ */
+const aggregate = async (options, db, collection, query) => {
+  const availabilityError = checkMongooseAvailable();
+  if (availabilityError) return availabilityError;
+  
+  const start = Date.now();
+  
+  try {
+    await connect(options);
+    
+    const { pipeline = [], schema = null } = query;
+    
+    const Model = getModel(db, collection, schema);
+    const data = await Model.aggregate(pipeline);
+    
+    const end = Date.now();
+    const time = end - start;
+    
+    return {
+      result: {
+        dml: 'aggregate',
+        collection,
+        db,
+        time: utl.milisegundosASegundos(time),
+        code: 200,
+        error: 0
+      },
+      data
+    };
+  } catch (e) {
+    const end = Date.now();
+    const time = end - start;
+    utl.log(`${tag} aggregate error:`, e);
+    return {
+      result: {
+        dml: 'aggregate',
+        time: utl.milisegundosASegundos(time),
+        code: 500,
+        error: 1,
+        msg: e.message
+      },
+      data: []
+    };
+  }
+};
+
+/**
+ * DISTINCT - Valores únicos
+ */
+const distinct = async (options, db, collection, query) => {
+  const availabilityError = checkMongooseAvailable();
+  if (availabilityError) return availabilityError;
+  
+  const start = Date.now();
+  
+  try {
+    await connect(options);
+    
+    const { field = '', filter = {}, schema = null } = query;
+    
+    const Model = getModel(db, collection, schema);
+    const data = await Model.distinct(field, filter);
+    
+    const end = Date.now();
+    const time = end - start;
+    
+    return {
+      result: {
+        dml: 'distinct',
+        collection,
+        db,
+        time: utl.milisegundosASegundos(time),
+        code: 200,
+        error: 0
+      },
+      data
+    };
+  } catch (e) {
+    const end = Date.now();
+    const time = end - start;
+    utl.log(`${tag} distinct error:`, e);
+    return {
+      result: {
+        dml: 'distinct',
+        time: utl.milisegundosASegundos(time),
+        code: 500,
+        error: 1,
+        msg: e.message
+      },
+      data: []
+    };
+  }
+};
+
+/**
+ * DBS - Listar todas las bases de datos
+ */
+const dbs = async (options) => {
+  const availabilityError = checkMongooseAvailable();
+  if (availabilityError) return availabilityError;
+  
+  const start = Date.now();
+  
+  try {
+    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 availabilityError = checkMongooseAvailable();
+  if (availabilityError) return availabilityError;
+  
+  const start = Date.now();
+  
+  try {
+    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 availabilityError = checkMongooseAvailable();
+  if (availabilityError) return availabilityError;
+  
+  const start = Date.now();
+  
+  try {
+    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) => {
+  const availabilityError = checkMongooseAvailable();
+  if (availabilityError) return availabilityError;
+  
+  let { dml = '', collection = '' } = body;
+  
+  // 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] !== undefined) {
+        dml = possibleDml;
+        // En formato MongoDB, la colección viene en body.[dml]
+        if (typeof body[possibleDml] === 'string') {
+          collection = body[possibleDml];
+        }
+        break;
+      }
+    }
+  }
+  
+  // 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: errorMsg,
+        debug: {
+          receivedDml: body.dml,
+          detectedDml: dml,
+          collectionValue: collection,
+          collectionIsEmpty: collection === '',
+          bodyKeys: Object.keys(body)
+        }
+      },
+      data: []
+    };
+  }
+  
+  let r;
+  
+  switch (dml) {
+    case 'find':        r = await find(options, db, collection, body); break;
+    case 'findOne':     r = await findOne(options, db, collection, body); break;
+    case 'count':       r = await count(options, db, collection, body); break;
+    case 'insert':      r = await insert(options, db, collection, body); break;
+    case 'insertMany':  r = await insertMany(options, db, collection, body); break;
+    case 'update':      r = await update(options, db, collection, body); break;
+    case 'updateMany':  r = await updateMany(options, db, collection, body); break;
+    case 'upsert':      r = await upsert(options, db, collection, body); break;
+    case 'delete':      r = await deleteOne(options, db, collection, body); break;
+    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: {
+          dml: dml || 'unknown',
+          time: 0,
+          code: 400,
+          error: 1,
+          msg: `Operación "${dml}" no soportada`
+        },
+        supportedOperations: [
+          'find', 'findOne', 'count', 'insert', 'insertMany',
+          'update', 'updateMany', 'upsert', 'delete', 'deleteMany',
+          'aggregate', 'distinct', 'dbs', 'collections', 'drop'
+        ]
+      };
+  }
+  
+  return new Promise((resolve) => {
+    resolve(r);
+  });
+};
+
+module.exports = {
+  api,
+  find,
+  findOne,
+  count,
+  insert,
+  insertMany,
+  update,
+  updateMany,
+  upsert,
+  deleteOne,
+  deleteMany,
+  aggregate,
+  distinct,
+  dbs,
+  collections,
+  drop,
+  connect,
+  getModel,
+  isMongooseAvailable,
+  mongooseVersion
+};