@hemia/db-connector 0.0.2 → 0.0.4

package/dist/hemia-db-connector.esm.js

@@ -1,5 +1,5 @@
-import mongoose from 'mongoose';
-export { Document, Model, Schema } from 'mongoose';
+import mongoose__default from 'mongoose';
+export * from 'mongoose';
 import { ValidationError, DatabaseError, AccessDeniedError, Sequelize } from 'sequelize';
 export { DataTypes, Model as ModelSequelize, Op, QueryTypes, Sequelize, Transaction, fn } from 'sequelize';
 
@@ -65,7 +65,7 @@ class MongoDBConnector extends NoSQLConnector {
         this.currentSession = null;
         this.config = param;
         this.provider = DBNoSQLType.MongoDB;
-        this.mongooseConnection = mongoose.connection;
+        this.mongooseConnection = mongoose__default.connection;
     }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -73,13 +73,13 @@ class MongoDBConnector extends NoSQLConnector {
                 if (this.mongooseConnection.readyState === 1) {
                     return;
                 }
-                yield mongoose.connect(`mongodb://${this.config.host}:${this.config.port || 27017}`, {
+                yield mongoose__default.connect(`mongodb://${this.config.host}:${this.config.port || 27017}`, {
                     user: this.config.user,
                     pass: this.config.password,
                     dbName: this.config.database,
                     authSource: this.config.authSource
                 });
-                this.mongooseConnection = mongoose.connection;
+                this.mongooseConnection = mongoose__default.connection;
                 console.log('Connected to MongoDB');
             }
             catch (error) {
@@ -278,6 +278,97 @@ class MongoDBConnector extends NoSQLConnector {
             }
         });
     }
+    executeWithModel(model, operation, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield operation(model, session);
+            }
+            catch (error) {
+                console.error('Error en operación personalizada:', error);
+                throw error;
+            }
+        });
+    }
+    updateMany(model, query, updateData, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield model.updateMany(query, updateData, { session });
+                return { matchedCount: result.matchedCount, modifiedCount: result.modifiedCount };
+            }
+            catch (error) {
+                console.error('Error al actualizar documentos:', error);
+                throw error;
+            }
+        });
+    }
+    deleteMany(model, query, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield model.deleteMany(query, { session });
+                return { deletedCount: result.deletedCount };
+            }
+            catch (error) {
+                console.error('Error al eliminar múltiples documentos:', error);
+                throw error;
+            }
+        });
+    }
+    countDocuments(model, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield model.countDocuments(query);
+            }
+            catch (error) {
+                console.error('Error al contar documentos:', error);
+                throw error;
+            }
+        });
+    }
+    distinct(model, field, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield model.distinct(field, query);
+            }
+            catch (error) {
+                console.error('Error al obtener valores distintos:', error);
+                throw error;
+            }
+        });
+    }
+    insertMany(model, docs, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield model.insertMany(docs, { session });
+            }
+            catch (error) {
+                console.error('Error al insertar múltiples documentos:', error);
+                throw error;
+            }
+        });
+    }
+    exists(model, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield model.exists(query);
+                return result !== null;
+            }
+            catch (error) {
+                console.error('Error al verificar existencia:', error);
+                throw error;
+            }
+        });
+    }
+    bulkWrite(model, operations, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield model.bulkWrite(operations, { session });
+            }
+            catch (error) {
+                console.error('Error en operación bulk:', error);
+                throw error;
+            }
+        });
+    }
 }
 
 class NoSQLConnectionManager {

package/dist/hemia-db-connector.js

@@ -278,6 +278,97 @@ class MongoDBConnector extends NoSQLConnector {
             }
         });
     }
+    executeWithModel(model, operation, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield operation(model, session);
+            }
+            catch (error) {
+                console.error('Error en operación personalizada:', error);
+                throw error;
+            }
+        });
+    }
+    updateMany(model, query, updateData, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield model.updateMany(query, updateData, { session });
+                return { matchedCount: result.matchedCount, modifiedCount: result.modifiedCount };
+            }
+            catch (error) {
+                console.error('Error al actualizar documentos:', error);
+                throw error;
+            }
+        });
+    }
+    deleteMany(model, query, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield model.deleteMany(query, { session });
+                return { deletedCount: result.deletedCount };
+            }
+            catch (error) {
+                console.error('Error al eliminar múltiples documentos:', error);
+                throw error;
+            }
+        });
+    }
+    countDocuments(model, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield model.countDocuments(query);
+            }
+            catch (error) {
+                console.error('Error al contar documentos:', error);
+                throw error;
+            }
+        });
+    }
+    distinct(model, field, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield model.distinct(field, query);
+            }
+            catch (error) {
+                console.error('Error al obtener valores distintos:', error);
+                throw error;
+            }
+        });
+    }
+    insertMany(model, docs, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield model.insertMany(docs, { session });
+            }
+            catch (error) {
+                console.error('Error al insertar múltiples documentos:', error);
+                throw error;
+            }
+        });
+    }
+    exists(model, query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield model.exists(query);
+                return result !== null;
+            }
+            catch (error) {
+                console.error('Error al verificar existencia:', error);
+                throw error;
+            }
+        });
+    }
+    bulkWrite(model, operations, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield model.bulkWrite(operations, { session });
+            }
+            catch (error) {
+                console.error('Error en operación bulk:', error);
+                throw error;
+            }
+        });
+    }
 }
 
 class NoSQLConnectionManager {
@@ -568,18 +659,6 @@ class DBConnector {
 }
 DBConnector.instance = null;
 
-Object.defineProperty(exports, "Document", {
-    enumerable: true,
-    get: function () { return mongoose.Document; }
-});
-Object.defineProperty(exports, "Model", {
-    enumerable: true,
-    get: function () { return mongoose.Model; }
-});
-Object.defineProperty(exports, "Schema", {
-    enumerable: true,
-    get: function () { return mongoose.Schema; }
-});
 Object.defineProperty(exports, "DataTypes", {
     enumerable: true,
     get: function () { return sequelize.DataTypes; }
@@ -613,3 +692,9 @@ exports.DBError = DBError;
 exports.MySQLConnectionError = MySQLConnectionError;
 exports.NoSQLConnector = NoSQLConnector;
 exports.SqlConnector = SqlConnector;
+Object.keys(mongoose).forEach(function (k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function () { return mongoose[k]; }
+    });
+});

package/dist/types/Core/MongoDBConnector.d.ts

@@ -27,4 +27,17 @@ export declare class MongoDBConnector extends NoSQLConnector {
     deleteById<T extends Document>(model: Model<T>, id: string, session?: ClientSession): Promise<boolean>;
     findAllFromMultipleModels<U extends Document>(models: Array<Model<U>>, filter: object): Promise<U[]>;
     aggregate<T extends Document>(model: Model<T>, pipeline: mongoose.PipelineStage[], options?: AggregateOptions): Promise<any[]>;
+    executeWithModel<T extends Document, R>(model: Model<T>, operation: (model: Model<T>, session?: ClientSession) => Promise<R>, session?: ClientSession): Promise<R>;
+    updateMany<T extends Document>(model: Model<T>, query: object, updateData: object, session?: ClientSession): Promise<{
+        matchedCount: number;
+        modifiedCount: number;
+    }>;
+    deleteMany<T extends Document>(model: Model<T>, query: object, session?: ClientSession): Promise<{
+        deletedCount: number;
+    }>;
+    countDocuments<T extends Document>(model: Model<T>, query: object): Promise<number>;
+    distinct<T extends Document>(model: Model<T>, field: string, query?: object): Promise<any[]>;
+    insertMany<T extends Document>(model: Model<T>, docs: Partial<T>[], session?: ClientSession): Promise<T[]>;
+    exists<T extends Document>(model: Model<T>, query: object): Promise<boolean>;
+    bulkWrite<T extends Document>(model: Model<T>, operations: any[], session?: ClientSession): Promise<any>;
 }

package/dist/types/abstract/NoSQLConnector.d.ts

@@ -37,4 +37,17 @@ export declare abstract class NoSQLConnector {
     abstract findAllFromMultipleModels<U extends Document>(models: Array<Model<U>>, filter: object): Promise<U[]>;
     abstract aggregate<T>(model: any, pipeline: PipelineStage[]): Promise<any[]>;
     abstract aggregate<T extends Document>(model: Model<T>, pipeline: PipelineStage[], options?: AggregateOptions): Promise<any[]>;
+    abstract executeWithModel<T extends Document, R>(model: Model<T>, operation: (model: Model<T>, session?: ClientSession) => Promise<R>, session?: ClientSession): Promise<R>;
+    abstract exists<T extends Document>(model: Model<T>, query: object): Promise<boolean>;
+    abstract updateMany<T extends Document>(model: Model<T>, query: object, updateData: object, session?: ClientSession): Promise<{
+        matchedCount: number;
+        modifiedCount: number;
+    }>;
+    abstract deleteMany<T extends Document>(model: Model<T>, query: object, session?: ClientSession): Promise<{
+        deletedCount: number;
+    }>;
+    abstract countDocuments<T extends Document>(model: Model<T>, query: object): Promise<number>;
+    abstract distinct<T extends Document>(model: Model<T>, field: string, query?: object): Promise<any[]>;
+    abstract insertMany<T extends Document>(model: Model<T>, docs: Partial<T>[], session?: ClientSession): Promise<T[]>;
+    abstract bulkWrite<T extends Document>(model: Model<T>, operations: any[], session?: ClientSession): Promise<any>;
 }

package/dist/types/index.d.ts

@@ -7,7 +7,7 @@ export { DBNoSQLType } from "./types/DBNoSQLTypes";
 export { NoSQLConnector } from "./abstract/NoSQLConnector";
 export { SqlConnector, Filter } from "./abstract/SQLConnector";
 export { NoSQLOptions } from "./types/NoSQLOptions";
-export { Document, Model, Schema, UpdateQuery, FilterQuery, ClientSession, PipelineStage, SortOrder, AggregateOptions } from 'mongoose';
+export * from 'mongoose';
 export { Model as ModelSequelize, Sequelize, DataTypes, CreateOptions, UpdateOptions, DestroyOptions, FindOptions, Attributes, WhereOptions, QueryOptions, InferAttributes, CreationAttributes, InferCreationAttributes, QueryTypes, QueryOptionsWithType, Transaction, Op, fn } from "sequelize";
 export { DBError } from "./errors/DBError";
 export { MySQLConnectionError } from "./errors/MySQLConnectionError";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hemia/db-connector",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Hemia Database Conector",
   "main": "dist/hemia-db-connector.js",
   "module": "dist/hemia-db-connector.esm.js",