@classytic/mongokit 3.0.0 → 3.0.1

package/README.md

@@ -15,7 +15,7 @@
 - ✅ **Plugin architecture** for reusable behaviors
 - ✅ **TypeScript** first-class support with discriminated unions
 - ✅ **Optional caching** - Redis/Memcached with auto-invalidation
-- ✅ **Battle-tested** in production with 182 passing tests
+- ✅ **Battle-tested** in production with 187 passing tests
 
 ---
 
@@ -682,6 +682,35 @@ const redisAdapter = {
 };
 ```
 
+### Cascade Delete
+
+Automatically delete related documents when a parent is deleted:
+
+```javascript
+import { Repository, cascadePlugin, softDeletePlugin } from '@classytic/mongokit';
+
+const productRepo = new Repository(ProductModel, [
+  softDeletePlugin(),  // optional - cascade respects soft delete behavior
+  cascadePlugin({
+    relations: [
+      { model: 'StockEntry', foreignKey: 'product' },
+      { model: 'StockMovement', foreignKey: 'product' },
+    ],
+    parallel: true,  // default, runs cascade deletes in parallel
+    logger: console, // optional logging
+  })
+]);
+
+// When product is deleted, all related StockEntry and StockMovement docs are also deleted
+await productRepo.delete(productId);
+```
+
+**Options:**
+- `relations` - Array of related models to cascade delete
+- `parallel` - Run cascade deletes in parallel (default: `true`)
+- `logger` - Optional logger for debugging
+- Per-relation `softDelete` - Override soft delete behavior per relation
+
 ### More Plugins
 
 - **`timestampPlugin()`** - Auto-manage `createdAt`/`updatedAt`
@@ -689,6 +718,7 @@ const redisAdapter = {
 - **`batchOperationsPlugin()`** - Adds `updateMany`, `deleteMany`
 - **`aggregateHelpersPlugin()`** - Adds `groupBy`, `sum`, `average`, etc.
 - **`subdocumentPlugin()`** - Manage subdocument arrays easily
+- **`cascadePlugin()`** - Auto-delete related documents on parent delete
 
 ---
 
@@ -993,8 +1023,8 @@ const total = result.total;
 - ✅ Framework-agnostic
 
 ### vs. Raw Repository Pattern
-- ✅ Battle-tested implementation (68 passing tests)
-- ✅ 11 built-in plugins ready to use
+- ✅ Battle-tested implementation (187 passing tests)
+- ✅ 12 built-in plugins ready to use
 - ✅ Comprehensive documentation
 - ✅ TypeScript discriminated unions
 - ✅ Active maintenance
@@ -1008,12 +1038,13 @@ npm test
 ```
 
 **Test Coverage:**
-- 184 tests (182 passing, 2 skipped - require replica set)
+- 189 tests (187 passing, 2 skipped - require replica set)
 - CRUD operations
 - Offset pagination
 - Keyset pagination
 - Aggregation pagination
 - Caching (hit/miss, invalidation)
+- Cascade delete (hard & soft delete)
 - Multi-tenancy
 - Text search + infinite scroll
 - Real-world scenarios

package/dist/actions/index.d.ts

@@ -1,3 +1,3 @@
-export { a as aggregate, c as create, _ as deleteActions, r as read, u as update } from '../index-CgOJ2pqz.js';
+export { a as aggregate, c as create, _ as deleteActions, r as read, u as update } from '../index-CKy3H2SY.js';
 import 'mongoose';
-import '../types-Nxhmi1aI.js';
+import '../types-vDtcOhyx.js';

package/dist/actions/index.js

@@ -469,5 +469,3 @@ async function minMax(Model, field, query = {}, options = {}) {
 }
 
 export { aggregate_exports as aggregate, create_exports as create, delete_exports as deleteActions, read_exports as read, update_exports as update };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map

package/dist/{index-CgOJ2pqz.d.ts → index-CKy3H2SY.d.ts}

@@ -1,5 +1,5 @@
 import { Model, ClientSession, PipelineStage } from 'mongoose';
-import { A as AnyDocument, C as CreateOptions, l as OperationOptions, S as SelectSpec, f as PopulateSpec, g as SortSpec, U as UpdateOptions, n as UpdateWithValidationResult, m as UpdateManyResult, D as DeleteResult, I as GroupResult, G as LookupOptions, M as MinMaxResult } from './types-Nxhmi1aI.js';
+import { A as AnyDocument, C as CreateOptions, l as OperationOptions, S as SelectSpec, f as PopulateSpec, g as SortSpec, U as UpdateOptions, n as UpdateWithValidationResult, m as UpdateManyResult, D as DeleteResult, I as GroupResult, G as LookupOptions, M as MinMaxResult } from './types-vDtcOhyx.js';
 
 /**
  * Create Actions

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-import { A as AnyDocument, e as PluginType, P as PaginationConfig, S as SelectSpec, f as PopulateSpec, g as SortSpec, a as OffsetPaginationResult, b as KeysetPaginationResult, d as AggregatePaginationResult, R as RepositoryContext, H as HttpError } from './types-Nxhmi1aI.js';
-export { c as AggregatePaginationOptions, i as AnyModel, N as CacheAdapter, T as CacheOperationOptions, Q as CacheOptions, W as CacheStats, C as CreateOptions, w as CrudSchemas, x as DecodedCursor, D as DeleteResult, E as EventPayload, F as FieldPreset, u as FieldRules, I as GroupResult, J as JsonSchema, K as KeysetPaginationOptions, L as Logger, G as LookupOptions, M as MinMaxResult, h as ObjectId, O as OffsetPaginationOptions, l as OperationOptions, k as PaginationResult, t as ParsedQuery, p as Plugin, q as PluginFunction, s as RepositoryEvent, r as RepositoryInstance, v as SchemaBuilderOptions, B as SoftDeleteOptions, j as SortDirection, m as UpdateManyResult, U as UpdateOptions, n as UpdateWithValidationResult, o as UserContext, z as ValidationChainOptions, V as ValidationResult, y as ValidatorDefinition } from './types-Nxhmi1aI.js';
+import { A as AnyDocument, e as PluginType, P as PaginationConfig, S as SelectSpec, f as PopulateSpec, g as SortSpec, a as OffsetPaginationResult, b as KeysetPaginationResult, d as AggregatePaginationResult, R as RepositoryContext, H as HttpError } from './types-vDtcOhyx.js';
+export { c as AggregatePaginationOptions, i as AnyModel, N as CacheAdapter, T as CacheOperationOptions, Q as CacheOptions, W as CacheStats, Y as CascadeOptions, X as CascadeRelation, C as CreateOptions, w as CrudSchemas, x as DecodedCursor, D as DeleteResult, E as EventPayload, F as FieldPreset, u as FieldRules, I as GroupResult, J as JsonSchema, K as KeysetPaginationOptions, L as Logger, G as LookupOptions, M as MinMaxResult, h as ObjectId, O as OffsetPaginationOptions, l as OperationOptions, k as PaginationResult, t as ParsedQuery, p as Plugin, q as PluginFunction, s as RepositoryEvent, r as RepositoryInstance, v as SchemaBuilderOptions, B as SoftDeleteOptions, j as SortDirection, m as UpdateManyResult, U as UpdateOptions, n as UpdateWithValidationResult, o as UserContext, z as ValidationChainOptions, V as ValidationResult, y as ValidatorDefinition } from './types-vDtcOhyx.js';
 import * as mongoose from 'mongoose';
 import { Model, ClientSession, PipelineStage, PopulateOptions } from 'mongoose';
 import { PaginationEngine } from './pagination/PaginationEngine.js';
-export { aggregateHelpersPlugin, auditLogPlugin, autoInject, batchOperationsPlugin, blockIf, cachePlugin, fieldFilterPlugin, immutableField, methodRegistryPlugin, mongoOperationsPlugin, requireField, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validationChainPlugin } from './plugins/index.js';
-export { b as createError, c as createFieldPreset, d as createMemoryCache, f as filterResponseData, g as getFieldsForUser, a as getMongooseProjection } from './memory-cache-DG2oSSbx.js';
-export { i as actions } from './index-CgOJ2pqz.js';
+export { aggregateHelpersPlugin, auditLogPlugin, autoInject, batchOperationsPlugin, blockIf, cachePlugin, cascadePlugin, fieldFilterPlugin, immutableField, methodRegistryPlugin, mongoOperationsPlugin, requireField, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validationChainPlugin } from './plugins/index.js';
+export { b as createError, c as createFieldPreset, d as createMemoryCache, f as filterResponseData, g as getFieldsForUser, a as getMongooseProjection } from './memory-cache-tn3v1xgG.js';
+export { i as actions } from './index-CKy3H2SY.js';
 
 /**
  * Repository Pattern - Data Access Layer
@@ -55,9 +55,13 @@ declare class Repository<TDoc = AnyDocument> {
      */
     on(event: string, listener: HookListener): this;
     /**
-     * Emit event
+     * Emit event (sync - for backwards compatibility)
      */
     emit(event: string, data: unknown): void;
+    /**
+     * Emit event and await all async handlers
+     */
+    emitAsync(event: string, data: unknown): Promise<void>;
     /**
      * Create single document
      */

package/dist/index.js

@@ -858,12 +858,21 @@ var Repository = class {
     return this;
   }
   /**
-   * Emit event
+   * Emit event (sync - for backwards compatibility)
    */
   emit(event, data) {
     const listeners = this._hooks.get(event) || [];
     listeners.forEach((listener) => listener(data));
   }
+  /**
+   * Emit event and await all async handlers
+   */
+  async emitAsync(event, data) {
+    const listeners = this._hooks.get(event) || [];
+    for (const listener of listeners) {
+      await listener(data);
+    }
+  }
   /**
    * Create single document
    */
@@ -1021,11 +1030,11 @@ var Repository = class {
     try {
       if (context.softDeleted) {
         const result2 = { success: true, message: "Soft deleted successfully" };
-        this.emit("after:delete", { context, result: result2 });
+        await this.emitAsync("after:delete", { context, result: result2 });
         return result2;
       }
       const result = await deleteById(this.Model, id, options);
-      this.emit("after:delete", { context, result });
+      await this.emitAsync("after:delete", { context, result });
       return result;
     } catch (error) {
       this.emit("error:delete", { context, error });
@@ -1992,6 +2001,176 @@ function cachePlugin(options) {
     }
   };
 }
+function cascadePlugin(options) {
+  const { relations, parallel = true, logger } = options;
+  if (!relations || relations.length === 0) {
+    throw new Error("cascadePlugin requires at least one relation");
+  }
+  return {
+    name: "cascade",
+    apply(repo) {
+      repo.on("after:delete", async (payload) => {
+        const { context } = payload;
+        const deletedId = context.id;
+        if (!deletedId) {
+          logger?.warn?.("Cascade delete skipped: no document ID in context", {
+            model: context.model
+          });
+          return;
+        }
+        const isSoftDelete = context.softDeleted === true;
+        const cascadeDelete = async (relation) => {
+          const RelatedModel = mongoose.models[relation.model];
+          if (!RelatedModel) {
+            logger?.warn?.(`Cascade delete skipped: model '${relation.model}' not found`, {
+              parentModel: context.model,
+              parentId: String(deletedId)
+            });
+            return;
+          }
+          const query = { [relation.foreignKey]: deletedId };
+          try {
+            const shouldSoftDelete = relation.softDelete ?? isSoftDelete;
+            if (shouldSoftDelete) {
+              const updateResult = await RelatedModel.updateMany(
+                query,
+                {
+                  deletedAt: /* @__PURE__ */ new Date(),
+                  ...context.user ? { deletedBy: context.user._id || context.user.id } : {}
+                },
+                { session: context.session }
+              );
+              logger?.info?.(`Cascade soft-deleted ${updateResult.modifiedCount} documents`, {
+                parentModel: context.model,
+                parentId: String(deletedId),
+                relatedModel: relation.model,
+                foreignKey: relation.foreignKey,
+                count: updateResult.modifiedCount
+              });
+            } else {
+              const deleteResult = await RelatedModel.deleteMany(query, {
+                session: context.session
+              });
+              logger?.info?.(`Cascade deleted ${deleteResult.deletedCount} documents`, {
+                parentModel: context.model,
+                parentId: String(deletedId),
+                relatedModel: relation.model,
+                foreignKey: relation.foreignKey,
+                count: deleteResult.deletedCount
+              });
+            }
+          } catch (error) {
+            logger?.error?.(`Cascade delete failed for model '${relation.model}'`, {
+              parentModel: context.model,
+              parentId: String(deletedId),
+              relatedModel: relation.model,
+              foreignKey: relation.foreignKey,
+              error: error.message
+            });
+            throw error;
+          }
+        };
+        if (parallel) {
+          await Promise.all(relations.map(cascadeDelete));
+        } else {
+          for (const relation of relations) {
+            await cascadeDelete(relation);
+          }
+        }
+      });
+      repo.on("after:deleteMany", async (payload) => {
+        const { context, result } = payload;
+        const query = context.query;
+        if (!query || Object.keys(query).length === 0) {
+          logger?.warn?.("Cascade deleteMany skipped: empty query", {
+            model: context.model
+          });
+          return;
+        }
+        logger?.warn?.("Cascade deleteMany: use before:deleteMany hook for complete cascade support", {
+          model: context.model
+        });
+      });
+      repo.on("before:deleteMany", async (context) => {
+        const query = context.query;
+        if (!query || Object.keys(query).length === 0) {
+          return;
+        }
+        const docs = await repo.Model.find(query, { _id: 1 }).lean().session(context.session ?? null);
+        const ids = docs.map((doc) => doc._id);
+        context._cascadeIds = ids;
+      });
+      const originalAfterDeleteMany = repo._hooks.get("after:deleteMany") || [];
+      repo._hooks.set("after:deleteMany", [
+        ...originalAfterDeleteMany,
+        async (payload) => {
+          const { context } = payload;
+          const ids = context._cascadeIds;
+          if (!ids || ids.length === 0) {
+            return;
+          }
+          const isSoftDelete = context.softDeleted === true;
+          const cascadeDeleteMany = async (relation) => {
+            const RelatedModel = mongoose.models[relation.model];
+            if (!RelatedModel) {
+              logger?.warn?.(`Cascade deleteMany skipped: model '${relation.model}' not found`, {
+                parentModel: context.model
+              });
+              return;
+            }
+            const query = { [relation.foreignKey]: { $in: ids } };
+            const shouldSoftDelete = relation.softDelete ?? isSoftDelete;
+            try {
+              if (shouldSoftDelete) {
+                const updateResult = await RelatedModel.updateMany(
+                  query,
+                  {
+                    deletedAt: /* @__PURE__ */ new Date(),
+                    ...context.user ? { deletedBy: context.user._id || context.user.id } : {}
+                  },
+                  { session: context.session }
+                );
+                logger?.info?.(`Cascade soft-deleted ${updateResult.modifiedCount} documents (bulk)`, {
+                  parentModel: context.model,
+                  parentCount: ids.length,
+                  relatedModel: relation.model,
+                  foreignKey: relation.foreignKey,
+                  count: updateResult.modifiedCount
+                });
+              } else {
+                const deleteResult = await RelatedModel.deleteMany(query, {
+                  session: context.session
+                });
+                logger?.info?.(`Cascade deleted ${deleteResult.deletedCount} documents (bulk)`, {
+                  parentModel: context.model,
+                  parentCount: ids.length,
+                  relatedModel: relation.model,
+                  foreignKey: relation.foreignKey,
+                  count: deleteResult.deletedCount
+                });
+              }
+            } catch (error) {
+              logger?.error?.(`Cascade deleteMany failed for model '${relation.model}'`, {
+                parentModel: context.model,
+                relatedModel: relation.model,
+                foreignKey: relation.foreignKey,
+                error: error.message
+              });
+              throw error;
+            }
+          };
+          if (parallel) {
+            await Promise.all(relations.map(cascadeDeleteMany));
+          } else {
+            for (const relation of relations) {
+              await cascadeDeleteMany(relation);
+            }
+          }
+        }
+      ]);
+    }
+  };
+}
 
 // src/utils/memory-cache.ts
 function createMemoryCache(maxEntries = 1e3) {
@@ -2103,6 +2282,4 @@ var index_default = Repository;
  * ```
  */
 
-export { PaginationEngine, Repository, actions_exports as actions, aggregateHelpersPlugin, auditLogPlugin, autoInject, batchOperationsPlugin, blockIf, cachePlugin, createError, createFieldPreset, createMemoryCache, createRepository, index_default as default, fieldFilterPlugin, filterResponseData, getFieldsForUser, getMongooseProjection, immutableField, methodRegistryPlugin, mongoOperationsPlugin, requireField, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validationChainPlugin };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+export { PaginationEngine, Repository, actions_exports as actions, aggregateHelpersPlugin, auditLogPlugin, autoInject, batchOperationsPlugin, blockIf, cachePlugin, cascadePlugin, createError, createFieldPreset, createMemoryCache, createRepository, index_default as default, fieldFilterPlugin, filterResponseData, getFieldsForUser, getMongooseProjection, immutableField, methodRegistryPlugin, mongoOperationsPlugin, requireField, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validationChainPlugin };

package/dist/{memory-cache-DG2oSSbx.d.ts → memory-cache-tn3v1xgG.d.ts}

@@ -1,4 +1,4 @@
-import { o as UserContext, F as FieldPreset, H as HttpError, N as CacheAdapter } from './types-Nxhmi1aI.js';
+import { o as UserContext, F as FieldPreset, H as HttpError, N as CacheAdapter } from './types-vDtcOhyx.js';
 
 /**
  * Field Selection Utilities

package/dist/pagination/PaginationEngine.d.ts

@@ -1,5 +1,5 @@
 import { Model } from 'mongoose';
-import { A as AnyDocument, P as PaginationConfig, O as OffsetPaginationOptions, a as OffsetPaginationResult, K as KeysetPaginationOptions, b as KeysetPaginationResult, c as AggregatePaginationOptions, d as AggregatePaginationResult } from '../types-Nxhmi1aI.js';
+import { A as AnyDocument, P as PaginationConfig, O as OffsetPaginationOptions, a as OffsetPaginationResult, K as KeysetPaginationOptions, b as KeysetPaginationResult, c as AggregatePaginationOptions, d as AggregatePaginationResult } from '../types-vDtcOhyx.js';
 
 /**
  * Pagination Engine

package/dist/pagination/PaginationEngine.js

@@ -365,5 +365,3 @@ var PaginationEngine = class {
 };
 
 export { PaginationEngine };
-//# sourceMappingURL=PaginationEngine.js.map
-//# sourceMappingURL=PaginationEngine.js.map

package/dist/plugins/index.d.ts

@@ -1,4 +1,4 @@
-import { F as FieldPreset, p as Plugin, L as Logger, B as SoftDeleteOptions, r as RepositoryInstance, y as ValidatorDefinition, z as ValidationChainOptions, R as RepositoryContext, Q as CacheOptions } from '../types-Nxhmi1aI.js';
+import { F as FieldPreset, p as Plugin, L as Logger, B as SoftDeleteOptions, r as RepositoryInstance, y as ValidatorDefinition, z as ValidationChainOptions, R as RepositoryContext, Q as CacheOptions, Y as CascadeOptions } from '../types-vDtcOhyx.js';
 import 'mongoose';
 
 /**
@@ -272,4 +272,39 @@ declare function subdocumentPlugin(): Plugin;
  */
 declare function cachePlugin(options: CacheOptions): Plugin;
 
-export { type MethodRegistryRepository, aggregateHelpersPlugin, auditLogPlugin, autoInject, batchOperationsPlugin, blockIf, cachePlugin, fieldFilterPlugin, immutableField, methodRegistryPlugin, mongoOperationsPlugin, requireField, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validationChainPlugin };
+/**
+ * Cascade Delete Plugin
+ * Automatically deletes related documents when a parent document is deleted
+ *
+ * @example
+ * ```typescript
+ * import mongoose from 'mongoose';
+ * import { Repository, cascadePlugin, methodRegistryPlugin } from '@classytic/mongokit';
+ *
+ * const productRepo = new Repository(Product, [
+ *   methodRegistryPlugin(),
+ *   cascadePlugin({
+ *     relations: [
+ *       { model: 'StockEntry', foreignKey: 'product' },
+ *       { model: 'StockMovement', foreignKey: 'product' },
+ *     ]
+ *   })
+ * ]);
+ *
+ * // When a product is deleted, all related StockEntry and StockMovement docs are also deleted
+ * await productRepo.delete(productId);
+ * ```
+ */
+
+/**
+ * Cascade delete plugin
+ *
+ * Deletes related documents after the parent document is deleted.
+ * Works with both hard delete and soft delete scenarios.
+ *
+ * @param options - Cascade configuration
+ * @returns Plugin
+ */
+declare function cascadePlugin(options: CascadeOptions): Plugin;
+
+export { type MethodRegistryRepository, aggregateHelpersPlugin, auditLogPlugin, autoInject, batchOperationsPlugin, blockIf, cachePlugin, cascadePlugin, fieldFilterPlugin, immutableField, methodRegistryPlugin, mongoOperationsPlugin, requireField, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validationChainPlugin };

package/dist/plugins/index.js

@@ -1,3 +1,5 @@
+import mongoose from 'mongoose';
+
 // src/utils/field-selection.ts
 function getFieldsForUser(user, preset) {
   if (!preset) {
@@ -851,7 +853,175 @@ function cachePlugin(options) {
     }
   };
 }
+function cascadePlugin(options) {
+  const { relations, parallel = true, logger } = options;
+  if (!relations || relations.length === 0) {
+    throw new Error("cascadePlugin requires at least one relation");
+  }
+  return {
+    name: "cascade",
+    apply(repo) {
+      repo.on("after:delete", async (payload) => {
+        const { context } = payload;
+        const deletedId = context.id;
+        if (!deletedId) {
+          logger?.warn?.("Cascade delete skipped: no document ID in context", {
+            model: context.model
+          });
+          return;
+        }
+        const isSoftDelete = context.softDeleted === true;
+        const cascadeDelete = async (relation) => {
+          const RelatedModel = mongoose.models[relation.model];
+          if (!RelatedModel) {
+            logger?.warn?.(`Cascade delete skipped: model '${relation.model}' not found`, {
+              parentModel: context.model,
+              parentId: String(deletedId)
+            });
+            return;
+          }
+          const query = { [relation.foreignKey]: deletedId };
+          try {
+            const shouldSoftDelete = relation.softDelete ?? isSoftDelete;
+            if (shouldSoftDelete) {
+              const updateResult = await RelatedModel.updateMany(
+                query,
+                {
+                  deletedAt: /* @__PURE__ */ new Date(),
+                  ...context.user ? { deletedBy: context.user._id || context.user.id } : {}
+                },
+                { session: context.session }
+              );
+              logger?.info?.(`Cascade soft-deleted ${updateResult.modifiedCount} documents`, {
+                parentModel: context.model,
+                parentId: String(deletedId),
+                relatedModel: relation.model,
+                foreignKey: relation.foreignKey,
+                count: updateResult.modifiedCount
+              });
+            } else {
+              const deleteResult = await RelatedModel.deleteMany(query, {
+                session: context.session
+              });
+              logger?.info?.(`Cascade deleted ${deleteResult.deletedCount} documents`, {
+                parentModel: context.model,
+                parentId: String(deletedId),
+                relatedModel: relation.model,
+                foreignKey: relation.foreignKey,
+                count: deleteResult.deletedCount
+              });
+            }
+          } catch (error) {
+            logger?.error?.(`Cascade delete failed for model '${relation.model}'`, {
+              parentModel: context.model,
+              parentId: String(deletedId),
+              relatedModel: relation.model,
+              foreignKey: relation.foreignKey,
+              error: error.message
+            });
+            throw error;
+          }
+        };
+        if (parallel) {
+          await Promise.all(relations.map(cascadeDelete));
+        } else {
+          for (const relation of relations) {
+            await cascadeDelete(relation);
+          }
+        }
+      });
+      repo.on("after:deleteMany", async (payload) => {
+        const { context, result } = payload;
+        const query = context.query;
+        if (!query || Object.keys(query).length === 0) {
+          logger?.warn?.("Cascade deleteMany skipped: empty query", {
+            model: context.model
+          });
+          return;
+        }
+        logger?.warn?.("Cascade deleteMany: use before:deleteMany hook for complete cascade support", {
+          model: context.model
+        });
+      });
+      repo.on("before:deleteMany", async (context) => {
+        const query = context.query;
+        if (!query || Object.keys(query).length === 0) {
+          return;
+        }
+        const docs = await repo.Model.find(query, { _id: 1 }).lean().session(context.session ?? null);
+        const ids = docs.map((doc) => doc._id);
+        context._cascadeIds = ids;
+      });
+      const originalAfterDeleteMany = repo._hooks.get("after:deleteMany") || [];
+      repo._hooks.set("after:deleteMany", [
+        ...originalAfterDeleteMany,
+        async (payload) => {
+          const { context } = payload;
+          const ids = context._cascadeIds;
+          if (!ids || ids.length === 0) {
+            return;
+          }
+          const isSoftDelete = context.softDeleted === true;
+          const cascadeDeleteMany = async (relation) => {
+            const RelatedModel = mongoose.models[relation.model];
+            if (!RelatedModel) {
+              logger?.warn?.(`Cascade deleteMany skipped: model '${relation.model}' not found`, {
+                parentModel: context.model
+              });
+              return;
+            }
+            const query = { [relation.foreignKey]: { $in: ids } };
+            const shouldSoftDelete = relation.softDelete ?? isSoftDelete;
+            try {
+              if (shouldSoftDelete) {
+                const updateResult = await RelatedModel.updateMany(
+                  query,
+                  {
+                    deletedAt: /* @__PURE__ */ new Date(),
+                    ...context.user ? { deletedBy: context.user._id || context.user.id } : {}
+                  },
+                  { session: context.session }
+                );
+                logger?.info?.(`Cascade soft-deleted ${updateResult.modifiedCount} documents (bulk)`, {
+                  parentModel: context.model,
+                  parentCount: ids.length,
+                  relatedModel: relation.model,
+                  foreignKey: relation.foreignKey,
+                  count: updateResult.modifiedCount
+                });
+              } else {
+                const deleteResult = await RelatedModel.deleteMany(query, {
+                  session: context.session
+                });
+                logger?.info?.(`Cascade deleted ${deleteResult.deletedCount} documents (bulk)`, {
+                  parentModel: context.model,
+                  parentCount: ids.length,
+                  relatedModel: relation.model,
+                  foreignKey: relation.foreignKey,
+                  count: deleteResult.deletedCount
+                });
+              }
+            } catch (error) {
+              logger?.error?.(`Cascade deleteMany failed for model '${relation.model}'`, {
+                parentModel: context.model,
+                relatedModel: relation.model,
+                foreignKey: relation.foreignKey,
+                error: error.message
+              });
+              throw error;
+            }
+          };
+          if (parallel) {
+            await Promise.all(relations.map(cascadeDeleteMany));
+          } else {
+            for (const relation of relations) {
+              await cascadeDeleteMany(relation);
+            }
+          }
+        }
+      ]);
+    }
+  };
+}
 
-export { aggregateHelpersPlugin, auditLogPlugin, autoInject, batchOperationsPlugin, blockIf, cachePlugin, fieldFilterPlugin, immutableField, methodRegistryPlugin, mongoOperationsPlugin, requireField, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validationChainPlugin };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+export { aggregateHelpersPlugin, auditLogPlugin, autoInject, batchOperationsPlugin, blockIf, cachePlugin, cascadePlugin, fieldFilterPlugin, immutableField, methodRegistryPlugin, mongoOperationsPlugin, requireField, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validationChainPlugin };

package/dist/{types-Nxhmi1aI.d.ts → types-vDtcOhyx.d.ts}

@@ -498,6 +498,24 @@ interface CacheStats {
     sets: number;
     invalidations: number;
 }
+/** Cascade relation definition */
+interface CascadeRelation {
+    /** Model name to cascade delete to */
+    model: string;
+    /** Foreign key field in the related model that references the deleted document */
+    foreignKey: string;
+    /** Whether to use soft delete if available (default: follows parent behavior) */
+    softDelete?: boolean;
+}
+/** Cascade delete plugin options */
+interface CascadeOptions {
+    /** Relations to cascade delete */
+    relations: CascadeRelation[];
+    /** Run cascade deletes in parallel (default: true) */
+    parallel?: boolean;
+    /** Logger for cascade operations */
+    logger?: Logger;
+}
 /** HTTP Error with status code */
 interface HttpError extends Error {
     status: number;
@@ -507,4 +525,4 @@ interface HttpError extends Error {
     }>;
 }
 
-export type { AnyDocument as A, SoftDeleteOptions as B, CreateOptions as C, DeleteResult as D, EventPayload as E, FieldPreset as F, LookupOptions as G, HttpError as H, GroupResult as I, JsonSchema as J, KeysetPaginationOptions as K, Logger as L, MinMaxResult as M, CacheAdapter as N, OffsetPaginationOptions as O, PaginationConfig as P, CacheOptions as Q, RepositoryContext as R, SelectSpec as S, CacheOperationOptions as T, UpdateOptions as U, ValidationResult as V, CacheStats as W, OffsetPaginationResult as a, KeysetPaginationResult as b, AggregatePaginationOptions as c, AggregatePaginationResult as d, PluginType as e, PopulateSpec as f, SortSpec as g, ObjectId as h, AnyModel as i, SortDirection as j, PaginationResult as k, OperationOptions as l, UpdateManyResult as m, UpdateWithValidationResult as n, UserContext as o, Plugin as p, PluginFunction as q, RepositoryInstance as r, RepositoryEvent as s, ParsedQuery as t, FieldRules as u, SchemaBuilderOptions as v, CrudSchemas as w, DecodedCursor as x, ValidatorDefinition as y, ValidationChainOptions as z };
+export type { AnyDocument as A, SoftDeleteOptions as B, CreateOptions as C, DeleteResult as D, EventPayload as E, FieldPreset as F, LookupOptions as G, HttpError as H, GroupResult as I, JsonSchema as J, KeysetPaginationOptions as K, Logger as L, MinMaxResult as M, CacheAdapter as N, OffsetPaginationOptions as O, PaginationConfig as P, CacheOptions as Q, RepositoryContext as R, SelectSpec as S, CacheOperationOptions as T, UpdateOptions as U, ValidationResult as V, CacheStats as W, CascadeRelation as X, CascadeOptions as Y, OffsetPaginationResult as a, KeysetPaginationResult as b, AggregatePaginationOptions as c, AggregatePaginationResult as d, PluginType as e, PopulateSpec as f, SortSpec as g, ObjectId as h, AnyModel as i, SortDirection as j, PaginationResult as k, OperationOptions as l, UpdateManyResult as m, UpdateWithValidationResult as n, UserContext as o, Plugin as p, PluginFunction as q, RepositoryInstance as r, RepositoryEvent as s, ParsedQuery as t, FieldRules as u, SchemaBuilderOptions as v, CrudSchemas as w, DecodedCursor as x, ValidatorDefinition as y, ValidationChainOptions as z };

package/dist/utils/index.d.ts

@@ -1,5 +1,5 @@
-export { b as createError, c as createFieldPreset, d as createMemoryCache, f as filterResponseData, g as getFieldsForUser, a as getMongooseProjection } from '../memory-cache-DG2oSSbx.js';
-import { t as ParsedQuery, v as SchemaBuilderOptions, w as CrudSchemas, V as ValidationResult, S as SelectSpec, f as PopulateSpec, g as SortSpec } from '../types-Nxhmi1aI.js';
+export { b as createError, c as createFieldPreset, d as createMemoryCache, f as filterResponseData, g as getFieldsForUser, a as getMongooseProjection } from '../memory-cache-tn3v1xgG.js';
+import { t as ParsedQuery, v as SchemaBuilderOptions, w as CrudSchemas, V as ValidationResult, S as SelectSpec, f as PopulateSpec, g as SortSpec } from '../types-vDtcOhyx.js';
 import mongoose__default, { Schema } from 'mongoose';
 
 /**

package/dist/utils/index.js

@@ -639,5 +639,3 @@ function listPattern(prefix, model) {
 }
 
 export { buildCrudSchemasFromModel, buildCrudSchemasFromMongooseSchema, byIdKey, byQueryKey, createError, createFieldPreset, createMemoryCache, filterResponseData, getFieldsForUser, getImmutableFields, getMongooseProjection, getSystemManagedFields, isFieldUpdateAllowed, listPattern, listQueryKey, modelPattern, queryParser_default as queryParser, validateUpdateBody, versionKey };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map