@abejarano/ts-mongodb-criteria 1.8.2 → 1.8.4

package/README.md

@@ -180,11 +180,12 @@ Indexes are created lazily the first time the repository accesses the collection
 Use the `collection` argument inside `ensureIndexes` to avoid recursion.
 
 MongoRepository provides ready-to-use public methods for repositories that extend it:
+
 - `list(criteria, fieldsToExclude?)` for paginated queries
 - `one(filter)` to fetch a single entity
 - `upsert(entity)` to persist an aggregate
-Internal helpers are private, so repositories should call these public methods
-directly.
+  Internal helpers are private, so repositories should call these public methods
+  directly.
 
 If you need a repository interface in your app, extend `IRepository<T>` so your
 custom interfaces stay aligned with the library return types:
@@ -401,15 +402,16 @@ This will create a `migrate-mongo-config.js` file in your project root. You must
 
 ### Commands
 
-| Command | Description |
-|---|---|
-| `init` | Initialize configuration file |
-| `migrate:create <name>` | Create a new migration file |
-| `migrate:up` | Run pending migrations |
-| `migrate:down` | Revert the last applied migration |
-| `migrate:status` | Check the status of migrations |
+| Command                 | Description                       |
+| ----------------------- | --------------------------------- |
+| `init`                  | Initialize configuration file     |
+| `migrate:create <name>` | Create a new migration file       |
+| `migrate:up`            | Run pending migrations            |
+| `migrate:down`          | Revert the last applied migration |
+| `migrate:status`        | Check the status of migrations    |
 
 Example:
+
 ```bash
 bun run ts-mongo migrate:create add-users-collection
 ```

package/dist/cjs/bin/cli.js

@@ -25,7 +25,7 @@ const validCommands = ["init", "create", "up", "down", "status"];
 const normalizedCommand = command.replace("migrate:", "");
 if (!validCommands.includes(normalizedCommand)) {
     console.error(`Unknown command: ${command}.`);
-    console.error(`Available commands: ${validCommands.map(c => `migrate:${c}`).join(", ")}`);
+    console.error(`Available commands: ${validCommands.map((c) => `migrate:${c}`).join(", ")}`);
     process.exit(1);
 }
 let extraOptions = "";

package/dist/cjs/mongo/MongoClientFactory.js

@@ -27,15 +27,13 @@ class MongoClientFactory {
      * Crea y conecta una nueva instancia de MongoClient.
      */
     static async createAndConnectClient() {
-        const MONGO_PASS = process.env.MONGO_PASS;
-        const MONGO_USER = process.env.MONGO_USER;
-        const MONGO_DB = process.env.MONGO_DB;
-        const MONGO_SERVER = process.env.MONGO_SERVER;
-        if (!MONGO_PASS || !MONGO_USER || !MONGO_DB || !MONGO_SERVER) {
-            throw new Error("Missing MongoDB environment variables.");
+        const uri = process.env.MONGO_URI;
+        if (!uri) {
+            throw new Error("MONGO_URI environment variables are missing to connect to the MongoDB server");
         }
-        const uri = `mongodb+srv://${MONGO_USER}:${MONGO_PASS}@${MONGO_SERVER}/${MONGO_DB}?retryWrites=true&w=majority`;
-        const client = new mongodb_1.MongoClient(uri, { ignoreUndefined: true });
+        const client = new mongodb_1.MongoClient(process.env.MONGO_URI, {
+            ignoreUndefined: true,
+        });
         try {
             await client.connect();
             return client;

package/dist/cjs/mongo/MongoRepository.js

@@ -9,23 +9,6 @@ class MongoRepository {
         this.aggregateRootClass = aggregateRootClass;
         this.criteriaConverter = new MongoCriteriaConverter_1.MongoCriteriaConverter();
     }
-    async ensureIndexesOnce() {
-        const key = this.collectionName();
-        if (MongoRepository.indexRegistry.has(key))
-            return;
-        const collection = await this.collectionRaw();
-        await this.ensureIndexes(collection);
-        MongoRepository.indexRegistry.add(key);
-    }
-    async collection() {
-        await this.ensureIndexesOnce();
-        return this.collectionRaw();
-    }
-    async collectionRaw() {
-        return (await MongoClientFactory_1.MongoClientFactory.createClient())
-            .db()
-            .collection(this.collectionName());
-    }
     /** Finds a single entity and hydrates it via the aggregate's fromPrimitives. */
     async one(filter) {
         const collection = await this.collection();
@@ -47,12 +30,40 @@ class MongoRepository {
         const documents = await this.searchByCriteria(criteria, fieldsToExclude);
         return this.paginate(documents);
     }
+    /**
+     * Deletes documents from the database based on a filter and optional options.
+     *
+     * @param {object} filter - The query to match documents that should be deleted.
+     * @param {DeleteOptions} [options] - Optional parameters that modify the behavior of the delete operation.
+     * @return {Promise<void>} A promise that resolves when the deletion is complete, or rejects if an error occurs.
+     */
+    async delete(filter, options) {
+        const collection = await this.collection();
+        await collection.deleteMany(filter, options);
+    }
+    async ensureIndexesOnce() {
+        const key = this.collectionName();
+        if (MongoRepository.indexRegistry.has(key))
+            return;
+        const collection = await this.collectionRaw();
+        await this.ensureIndexes(collection);
+        MongoRepository.indexRegistry.add(key);
+    }
+    async collection() {
+        await this.ensureIndexesOnce();
+        return this.collectionRaw();
+    }
     async updateOne(filter, update) {
         const collection = await this.collection();
         await collection.updateOne(filter, update, {
             upsert: true,
         });
     }
+    async collectionRaw() {
+        return (await MongoClientFactory_1.MongoClientFactory.createClient())
+            .db()
+            .collection(this.collectionName());
+    }
     async persist(id, aggregateRoot) {
         let primitives;
         if (aggregateRoot.toPrimitives() instanceof Promise) {

package/dist/esm/bin/cli.js

@@ -20,7 +20,7 @@ const validCommands = ["init", "create", "up", "down", "status"];
 const normalizedCommand = command.replace("migrate:", "");
 if (!validCommands.includes(normalizedCommand)) {
     console.error(`Unknown command: ${command}.`);
-    console.error(`Available commands: ${validCommands.map(c => `migrate:${c}`).join(", ")}`);
+    console.error(`Available commands: ${validCommands.map((c) => `migrate:${c}`).join(", ")}`);
     process.exit(1);
 }
 let extraOptions = "";

package/dist/esm/mongo/MongoClientFactory.js

@@ -24,15 +24,13 @@ export class MongoClientFactory {
      * Crea y conecta una nueva instancia de MongoClient.
      */
     static async createAndConnectClient() {
-        const MONGO_PASS = process.env.MONGO_PASS;
-        const MONGO_USER = process.env.MONGO_USER;
-        const MONGO_DB = process.env.MONGO_DB;
-        const MONGO_SERVER = process.env.MONGO_SERVER;
-        if (!MONGO_PASS || !MONGO_USER || !MONGO_DB || !MONGO_SERVER) {
-            throw new Error("Missing MongoDB environment variables.");
+        const uri = process.env.MONGO_URI;
+        if (!uri) {
+            throw new Error("MONGO_URI environment variables are missing to connect to the MongoDB server");
         }
-        const uri = `mongodb+srv://${MONGO_USER}:${MONGO_PASS}@${MONGO_SERVER}/${MONGO_DB}?retryWrites=true&w=majority`;
-        const client = new MongoClient(uri, { ignoreUndefined: true });
+        const client = new MongoClient(process.env.MONGO_URI, {
+            ignoreUndefined: true,
+        });
         try {
             await client.connect();
             return client;

package/dist/esm/mongo/MongoRepository.js

@@ -1,28 +1,11 @@
 import { MongoCriteriaConverter } from "./MongoCriteriaConverter";
 import { MongoClientFactory } from "./MongoClientFactory";
-import { ObjectId } from "mongodb";
+import { ObjectId, } from "mongodb";
 export class MongoRepository {
     constructor(aggregateRootClass) {
         this.aggregateRootClass = aggregateRootClass;
         this.criteriaConverter = new MongoCriteriaConverter();
     }
-    async ensureIndexesOnce() {
-        const key = this.collectionName();
-        if (MongoRepository.indexRegistry.has(key))
-            return;
-        const collection = await this.collectionRaw();
-        await this.ensureIndexes(collection);
-        MongoRepository.indexRegistry.add(key);
-    }
-    async collection() {
-        await this.ensureIndexesOnce();
-        return this.collectionRaw();
-    }
-    async collectionRaw() {
-        return (await MongoClientFactory.createClient())
-            .db()
-            .collection(this.collectionName());
-    }
     /** Finds a single entity and hydrates it via the aggregate's fromPrimitives. */
     async one(filter) {
         const collection = await this.collection();
@@ -44,12 +27,40 @@ export class MongoRepository {
         const documents = await this.searchByCriteria(criteria, fieldsToExclude);
         return this.paginate(documents);
     }
+    /**
+     * Deletes documents from the database based on a filter and optional options.
+     *
+     * @param {object} filter - The query to match documents that should be deleted.
+     * @param {DeleteOptions} [options] - Optional parameters that modify the behavior of the delete operation.
+     * @return {Promise<void>} A promise that resolves when the deletion is complete, or rejects if an error occurs.
+     */
+    async delete(filter, options) {
+        const collection = await this.collection();
+        await collection.deleteMany(filter, options);
+    }
+    async ensureIndexesOnce() {
+        const key = this.collectionName();
+        if (MongoRepository.indexRegistry.has(key))
+            return;
+        const collection = await this.collectionRaw();
+        await this.ensureIndexes(collection);
+        MongoRepository.indexRegistry.add(key);
+    }
+    async collection() {
+        await this.ensureIndexesOnce();
+        return this.collectionRaw();
+    }
     async updateOne(filter, update) {
         const collection = await this.collection();
         await collection.updateOne(filter, update, {
             upsert: true,
         });
     }
+    async collectionRaw() {
+        return (await MongoClientFactory.createClient())
+            .db()
+            .collection(this.collectionName());
+    }
     async persist(id, aggregateRoot) {
         let primitives;
         if (aggregateRoot.toPrimitives() instanceof Promise) {

package/dist/types/mongo/IRepository.d.ts

@@ -1,7 +1,9 @@
 import { Criteria, Paginate } from "../criteria";
 import { AggregateRoot } from "../AggregateRoot";
+import { DeleteOptions } from "mongodb";
 export interface IRepository<T extends AggregateRoot> {
     one(filter: object): Promise<T | null>;
     list<D>(criteria: Criteria, fieldsToExclude?: string[]): Promise<Paginate<D>>;
     upsert(entity: T): Promise<void>;
+    delete(filter: object, options?: DeleteOptions): Promise<void>;
 }

package/dist/types/mongo/MongoRepository.d.ts

@@ -1,25 +1,33 @@
 import { Criteria, Paginate } from "../criteria";
 import { AggregateRoot, AggregateRootClass } from "../AggregateRoot";
-import { Collection, Document, UpdateFilter } from "mongodb";
+import { Collection, DeleteOptions, Document, UpdateFilter } from "mongodb";
 export declare abstract class MongoRepository<T extends AggregateRoot> {
     private readonly aggregateRootClass;
+    private static indexRegistry;
     private criteriaConverter;
     private query;
     private criteria;
-    private static indexRegistry;
     protected constructor(aggregateRootClass: AggregateRootClass<T>);
     abstract collectionName(): string;
-    protected abstract ensureIndexes(collection: Collection): Promise<void>;
-    protected ensureIndexesOnce(): Promise<void>;
-    protected collection<U extends Document>(): Promise<Collection<U>>;
-    private collectionRaw;
     /** Finds a single entity and hydrates it via the aggregate's fromPrimitives. */
     one(filter: object): Promise<T | null>;
     /** Upserts an aggregate by delegating to persist with its id. */
     upsert(entity: T): Promise<void>;
     /** Lists entities by criteria and returns a paginated response. */
     list<D>(criteria: Criteria, fieldsToExclude?: string[]): Promise<Paginate<D>>;
+    /**
+     * Deletes documents from the database based on a filter and optional options.
+     *
+     * @param {object} filter - The query to match documents that should be deleted.
+     * @param {DeleteOptions} [options] - Optional parameters that modify the behavior of the delete operation.
+     * @return {Promise<void>} A promise that resolves when the deletion is complete, or rejects if an error occurs.
+     */
+    delete(filter: object, options?: DeleteOptions): Promise<void>;
+    protected abstract ensureIndexes(collection: Collection): Promise<void>;
+    protected ensureIndexesOnce(): Promise<void>;
+    protected collection<U extends Document>(): Promise<Collection<U>>;
     protected updateOne(filter: object, update: Document[] | UpdateFilter<any>): Promise<void>;
+    private collectionRaw;
     private persist;
     private searchByCriteria;
     private paginate;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@abejarano/ts-mongodb-criteria",
   "author": "angel bejarano / angel.bejarano@jaspesoft.com",
-  "version": "1.8.2",
+  "version": "1.8.4",
   "description": "Patrón Criteria para consultas MongoDB en TypeScript",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -63,7 +63,7 @@
     "@types/node": "^24.5.2",
     "jest": "^29.7.0",
     "mongodb": "^7.0.0",
-    "prettier": "^3.7.4",
+    "prettier": "^3.8.3",
     "rimraf": "^6.1.2",
     "semantic-release": "^24.2.9",
     "ts-jest": "^29.1.2",