bonsaif 1.10.39 → 1.10.40

package/lib/hookup/mongoose.js

@@ -1,988 +0,0 @@
-/**
- * ::: B[]NSAIF() ::: => 2024
- * Hookup para Mongoose (MongoDB ORM)
- */
-
-'use strict';
-
-const utl = require('../utl');
-let debug = false;
-let tag = ` ::: B[]NSAIF() ::: => mongoose.js `;
-
-// Cache de modelos dinámicos por base de datos y colección
-const modelCache = new Map();
-
-/**
- * Parsear schema dinámico recibido del cliente
- * Convierte definición simple a Schema de Mongoose
- */
-const parseSchema = (schemaDefinition) => {
-  const mongoose = require('mongoose');
-  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 mongoose = require('mongoose');
-  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;
-    }
-    
-    await mongoose.connect(uri, {
-      maxPoolSize: poolSize,
-      minPoolSize: 2,
-      serverSelectionTimeoutMS: 15000,
-      socketTimeoutMS: 45000,
-      connectTimeoutMS: 10000
-    });
-    
-    debugMode ? utl.log(`${tag} [Mongoose] 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 mongoose = require('mongoose');
-  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 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 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 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 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 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 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 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 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 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 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 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 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 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;
-  
-  // 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
-};