@classytic/mongokit 3.0.0 → 3.0.2

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-CMCrkd2v.js';
 import 'mongoose';
-import '../types-Nxhmi1aI.js';
+import '../types-B3dPUKjs.js';

package/dist/actions/index.js

@@ -147,6 +147,14 @@ __export(update_exports, {
   updateWithConstraints: () => updateWithConstraints,
   updateWithValidation: () => updateWithValidation
 });
+function assertUpdatePipelineAllowed(update2, updatePipeline) {
+  if (Array.isArray(update2) && updatePipeline !== true) {
+    throw createError(
+      400,
+      "Update pipelines (array updates) are disabled by default; pass `{ updatePipeline: true }` to explicitly allow pipeline-style updates."
+    );
+  }
+}
 function parsePopulate2(populate) {
   if (!populate) return [];
   if (typeof populate === "string") {
@@ -158,6 +166,7 @@ function parsePopulate2(populate) {
   return [populate];
 }
 async function update(Model, id, data, options = {}) {
+  assertUpdatePipelineAllowed(data, options.updatePipeline);
   const document = await Model.findByIdAndUpdate(id, data, {
     new: true,
     runValidators: true,
@@ -170,6 +179,7 @@ async function update(Model, id, data, options = {}) {
   return document;
 }
 async function updateWithConstraints(Model, id, data, constraints = {}, options = {}) {
+  assertUpdatePipelineAllowed(data, options.updatePipeline);
   const query = { _id: id, ...constraints };
   const document = await Model.findOneAndUpdate(query, data, {
     new: true,
@@ -181,6 +191,7 @@ async function updateWithConstraints(Model, id, data, constraints = {}, options
 }
 async function updateWithValidation(Model, id, data, validationOptions = {}, options = {}) {
   const { buildConstraints, validateUpdate } = validationOptions;
+  assertUpdatePipelineAllowed(data, options.updatePipeline);
   if (buildConstraints) {
     const constraints = buildConstraints(data);
     const document = await updateWithConstraints(Model, id, data, constraints, options);
@@ -215,6 +226,7 @@ async function updateWithValidation(Model, id, data, validationOptions = {}, opt
   return { success: true, data: updated };
 }
 async function updateMany(Model, query, data, options = {}) {
+  assertUpdatePipelineAllowed(data, options.updatePipeline);
   const result = await Model.updateMany(query, data, {
     runValidators: true,
     session: options.session,
@@ -226,6 +238,7 @@ async function updateMany(Model, query, data, options = {}) {
   };
 }
 async function updateByQuery(Model, query, data, options = {}) {
+  assertUpdatePipelineAllowed(data, options.updatePipeline);
   const document = await Model.findOneAndUpdate(query, data, {
     new: true,
     runValidators: true,
@@ -469,5 +482,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-CMCrkd2v.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, f as ObjectId, n as OperationOptions, S as SelectSpec, g as PopulateSpec, h as SortSpec, U as UpdateOptions, p as UpdateWithValidationResult, o as UpdateManyResult, D as DeleteResult, N as GroupResult, M as LookupOptions, Q as MinMaxResult } from './types-B3dPUKjs.js';
 
 /**
  * Create Actions
@@ -48,7 +48,7 @@ declare namespace create$1 {
  * @returns Document or null
  * @throws Error if document not found and throwOnNotFound is true
  */
-declare function getById<TDoc = AnyDocument>(Model: Model<TDoc>, id: string, options?: OperationOptions): Promise<TDoc | null>;
+declare function getById<TDoc = AnyDocument>(Model: Model<TDoc>, id: string | ObjectId, options?: OperationOptions): Promise<TDoc | null>;
 /**
  * Get document by query
  *
@@ -117,12 +117,12 @@ declare namespace read {
 /**
  * Update by ID
  */
-declare function update<TDoc = AnyDocument>(Model: Model<TDoc>, id: string, data: Record<string, unknown>, options?: UpdateOptions): Promise<TDoc>;
+declare function update<TDoc = AnyDocument>(Model: Model<TDoc>, id: string | ObjectId, data: Record<string, unknown>, options?: UpdateOptions): Promise<TDoc>;
 /**
  * Update with query constraints (optimized)
  * Returns null if constraints not met (not an error)
  */
-declare function updateWithConstraints<TDoc = AnyDocument>(Model: Model<TDoc>, id: string, data: Record<string, unknown>, constraints?: Record<string, unknown>, options?: UpdateOptions): Promise<TDoc | null>;
+declare function updateWithConstraints<TDoc = AnyDocument>(Model: Model<TDoc>, id: string | ObjectId, data: Record<string, unknown>, constraints?: Record<string, unknown>, options?: UpdateOptions): Promise<TDoc | null>;
 /**
  * Validation options for smart update
  */
@@ -141,7 +141,7 @@ interface ValidationOptions {
  * Update with validation (smart optimization)
  * 1-query on success, 2-queries for detailed errors
  */
-declare function updateWithValidation<TDoc = AnyDocument>(Model: Model<TDoc>, id: string, data: Record<string, unknown>, validationOptions?: ValidationOptions, options?: UpdateOptions): Promise<UpdateWithValidationResult<TDoc>>;
+declare function updateWithValidation<TDoc = AnyDocument>(Model: Model<TDoc>, id: string | ObjectId, data: Record<string, unknown>, validationOptions?: ValidationOptions, options?: UpdateOptions): Promise<UpdateWithValidationResult<TDoc>>;
 /**
  * Update many documents
  */
@@ -156,15 +156,15 @@ declare function updateByQuery<TDoc = AnyDocument>(Model: Model<TDoc>, query: Re
 /**
  * Increment field
  */
-declare function increment<TDoc = AnyDocument>(Model: Model<TDoc>, id: string, field: string, value?: number, options?: UpdateOptions): Promise<TDoc>;
+declare function increment<TDoc = AnyDocument>(Model: Model<TDoc>, id: string | ObjectId, field: string, value?: number, options?: UpdateOptions): Promise<TDoc>;
 /**
  * Push to array
  */
-declare function pushToArray<TDoc = AnyDocument>(Model: Model<TDoc>, id: string, field: string, value: unknown, options?: UpdateOptions): Promise<TDoc>;
+declare function pushToArray<TDoc = AnyDocument>(Model: Model<TDoc>, id: string | ObjectId, field: string, value: unknown, options?: UpdateOptions): Promise<TDoc>;
 /**
  * Pull from array
  */
-declare function pullFromArray<TDoc = AnyDocument>(Model: Model<TDoc>, id: string, field: string, value: unknown, options?: UpdateOptions): Promise<TDoc>;
+declare function pullFromArray<TDoc = AnyDocument>(Model: Model<TDoc>, id: string | ObjectId, field: string, value: unknown, options?: UpdateOptions): Promise<TDoc>;
 
 declare const update$1_increment: typeof increment;
 declare const update$1_pullFromArray: typeof pullFromArray;
@@ -186,7 +186,7 @@ declare namespace update$1 {
 /**
  * Delete by ID
  */
-declare function deleteById(Model: Model<any>, id: string, options?: {
+declare function deleteById(Model: Model<any>, id: string | ObjectId, options?: {
     session?: ClientSession;
 }): Promise<DeleteResult>;
 /**
@@ -205,14 +205,14 @@ declare function deleteByQuery(Model: Model<any>, query: Record<string, unknown>
 /**
  * Soft delete (set deleted flag)
  */
-declare function softDelete<TDoc = AnyDocument>(Model: Model<TDoc>, id: string, options?: {
+declare function softDelete<TDoc = AnyDocument>(Model: Model<TDoc>, id: string | ObjectId, options?: {
     session?: ClientSession;
     userId?: string;
 }): Promise<DeleteResult>;
 /**
  * Restore soft deleted document
  */
-declare function restore<TDoc = AnyDocument>(Model: Model<TDoc>, id: string, options?: {
+declare function restore<TDoc = AnyDocument>(Model: Model<TDoc>, id: string | ObjectId, options?: {
     session?: ClientSession;
 }): Promise<DeleteResult>;
 

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, R as RepositoryOptions, f as ObjectId, S as SelectSpec, g as PopulateSpec, h as SortSpec, a as OffsetPaginationResult, b as KeysetPaginationResult, U as UpdateOptions, d as AggregatePaginationResult, i as RepositoryContext, H as HttpError } from './types-B3dPUKjs.js';
+export { c as AggregatePaginationOptions, j as AnyModel, T as CacheAdapter, X as CacheOperationOptions, W as CacheOptions, Y as CacheStats, _ as CascadeOptions, Z as CascadeRelation, C as CreateOptions, y as CrudSchemas, z as DecodedCursor, D as DeleteResult, E as EventPayload, F as FieldPreset, w as FieldRules, N as GroupResult, l as HookMode, J as JsonSchema, K as KeysetPaginationOptions, L as Logger, M as LookupOptions, Q as MinMaxResult, O as OffsetPaginationOptions, n as OperationOptions, m as PaginationResult, v as ParsedQuery, r as Plugin, s as PluginFunction, u as RepositoryEvent, t as RepositoryInstance, x as SchemaBuilderOptions, I as SoftDeleteOptions, k as SortDirection, o as UpdateManyResult, p as UpdateWithValidationResult, q as UserContext, G as ValidationChainOptions, V as ValidationResult, B as ValidatorDefinition } from './types-B3dPUKjs.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-Bn_-Kk-0.js';
+export { i as actions } from './index-CMCrkd2v.js';
 
 /**
  * Repository Pattern - Data Access Layer
@@ -44,8 +44,9 @@ declare class Repository<TDoc = AnyDocument> {
     readonly model: string;
     readonly _hooks: Map<string, HookListener[]>;
     readonly _pagination: PaginationEngine<TDoc>;
+    private readonly _hookMode;
     [key: string]: unknown;
-    constructor(Model: Model<TDoc>, plugins?: PluginType[], paginationConfig?: PaginationConfig);
+    constructor(Model: Model<TDoc>, plugins?: PluginType[], paginationConfig?: PaginationConfig, options?: RepositoryOptions);
     /**
      * Register a plugin
      */
@@ -55,9 +56,15 @@ 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>;
+    private _emitHook;
+    private _emitErrorHook;
     /**
      * Create single document
      */
@@ -74,7 +81,7 @@ declare class Repository<TDoc = AnyDocument> {
     /**
      * Get document by ID
      */
-    getById(id: string, options?: {
+    getById(id: string | ObjectId, options?: {
         select?: SelectSpec;
         populate?: PopulateSpec;
         lean?: boolean;
@@ -161,16 +168,11 @@ declare class Repository<TDoc = AnyDocument> {
     /**
      * Update document by ID
      */
-    update(id: string, data: Record<string, unknown>, options?: {
-        select?: SelectSpec;
-        populate?: PopulateSpec;
-        lean?: boolean;
-        session?: ClientSession;
-    }): Promise<TDoc>;
+    update(id: string | ObjectId, data: Record<string, unknown>, options?: UpdateOptions): Promise<TDoc>;
     /**
      * Delete document by ID
      */
-    delete(id: string, options?: {
+    delete(id: string | ObjectId, options?: {
         session?: ClientSession;
     }): Promise<{
         success: boolean;
@@ -234,6 +236,6 @@ declare class Repository<TDoc = AnyDocument> {
  * @example
  * const userRepo = createRepository(UserModel, [timestampPlugin()]);
  */
-declare function createRepository<TDoc>(Model: mongoose.Model<TDoc>, plugins?: PluginType[]): Repository<TDoc>;
+declare function createRepository<TDoc>(Model: mongoose.Model<TDoc>, plugins?: PluginType[], paginationConfig?: PaginationConfig, options?: RepositoryOptions): Repository<TDoc>;
 
-export { AggregatePaginationResult, AnyDocument, HttpError, KeysetPaginationResult, OffsetPaginationResult, PaginationConfig, PaginationEngine, PluginType, PopulateSpec, Repository, RepositoryContext, SelectSpec, SortSpec, createRepository, Repository as default };
+export { AggregatePaginationResult, AnyDocument, HttpError, KeysetPaginationResult, ObjectId, OffsetPaginationResult, PaginationConfig, PaginationEngine, PluginType, PopulateSpec, Repository, RepositoryContext, RepositoryOptions, SelectSpec, SortSpec, UpdateOptions, createRepository, Repository as default };

package/dist/index.js

@@ -147,6 +147,14 @@ __export(update_exports, {
   updateWithConstraints: () => updateWithConstraints,
   updateWithValidation: () => updateWithValidation
 });
+function assertUpdatePipelineAllowed(update2, updatePipeline) {
+  if (Array.isArray(update2) && updatePipeline !== true) {
+    throw createError(
+      400,
+      "Update pipelines (array updates) are disabled by default; pass `{ updatePipeline: true }` to explicitly allow pipeline-style updates."
+    );
+  }
+}
 function parsePopulate2(populate) {
   if (!populate) return [];
   if (typeof populate === "string") {
@@ -158,6 +166,7 @@ function parsePopulate2(populate) {
   return [populate];
 }
 async function update(Model, id, data, options = {}) {
+  assertUpdatePipelineAllowed(data, options.updatePipeline);
   const document = await Model.findByIdAndUpdate(id, data, {
     new: true,
     runValidators: true,
@@ -170,6 +179,7 @@ async function update(Model, id, data, options = {}) {
   return document;
 }
 async function updateWithConstraints(Model, id, data, constraints = {}, options = {}) {
+  assertUpdatePipelineAllowed(data, options.updatePipeline);
   const query = { _id: id, ...constraints };
   const document = await Model.findOneAndUpdate(query, data, {
     new: true,
@@ -181,6 +191,7 @@ async function updateWithConstraints(Model, id, data, constraints = {}, options
 }
 async function updateWithValidation(Model, id, data, validationOptions = {}, options = {}) {
   const { buildConstraints, validateUpdate } = validationOptions;
+  assertUpdatePipelineAllowed(data, options.updatePipeline);
   if (buildConstraints) {
     const constraints = buildConstraints(data);
     const document = await updateWithConstraints(Model, id, data, constraints, options);
@@ -215,6 +226,7 @@ async function updateWithValidation(Model, id, data, validationOptions = {}, opt
   return { success: true, data: updated };
 }
 async function updateMany(Model, query, data, options = {}) {
+  assertUpdatePipelineAllowed(data, options.updatePipeline);
   const result = await Model.updateMany(query, data, {
     runValidators: true,
     session: options.session,
@@ -226,6 +238,7 @@ async function updateMany(Model, query, data, options = {}) {
   };
 }
 async function updateByQuery(Model, query, data, options = {}) {
+  assertUpdatePipelineAllowed(data, options.updatePipeline);
   const document = await Model.findOneAndUpdate(query, data, {
     new: true,
     runValidators: true,
@@ -829,11 +842,13 @@ var Repository = class {
   model;
   _hooks;
   _pagination;
-  constructor(Model, plugins = [], paginationConfig = {}) {
+  _hookMode;
+  constructor(Model, plugins = [], paginationConfig = {}, options = {}) {
     this.Model = Model;
     this.model = Model.modelName;
     this._hooks = /* @__PURE__ */ new Map();
     this._pagination = new PaginationEngine(Model, paginationConfig);
+    this._hookMode = options.hooks ?? "async";
     plugins.forEach((plugin) => this.use(plugin));
   }
   /**
@@ -858,11 +873,48 @@ 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));
+    for (const listener of listeners) {
+      try {
+        const result = listener(data);
+        if (result && typeof result.then === "function") {
+          void result.catch((error) => {
+            if (event === "error:hook") return;
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.emit("error:hook", { event, error: err });
+          });
+        }
+      } catch (error) {
+        if (event === "error:hook") continue;
+        const err = error instanceof Error ? error : new Error(String(error));
+        this.emit("error:hook", { event, error: err });
+      }
+    }
+  }
+  /**
+   * 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);
+    }
+  }
+  async _emitHook(event, data) {
+    if (this._hookMode === "async") {
+      await this.emitAsync(event, data);
+      return;
+    }
+    this.emit(event, data);
+  }
+  async _emitErrorHook(event, data) {
+    try {
+      await this._emitHook(event, data);
+    } catch {
+    }
   }
   /**
    * Create single document
@@ -871,10 +923,10 @@ var Repository = class {
     const context = await this._buildContext("create", { data, ...options });
     try {
       const result = await create(this.Model, context.data || data, options);
-      this.emit("after:create", { context, result });
+      await this._emitHook("after:create", { context, result });
       return result;
     } catch (error) {
-      this.emit("error:create", { context, error });
+      await this._emitErrorHook("error:create", { context, error });
       throw this._handleError(error);
     }
   }
@@ -885,10 +937,10 @@ var Repository = class {
     const context = await this._buildContext("createMany", { dataArray, ...options });
     try {
       const result = await createMany(this.Model, context.dataArray || dataArray, options);
-      this.emit("after:createMany", { context, result });
+      await this._emitHook("after:createMany", { context, result });
       return result;
     } catch (error) {
-      this.emit("error:createMany", { context, error });
+      await this._emitErrorHook("error:createMany", { context, error });
       throw this._handleError(error);
     }
   }
@@ -901,7 +953,7 @@ var Repository = class {
       return context._cachedResult;
     }
     const result = await getById(this.Model, id, context);
-    this.emit("after:getById", { context, result });
+    await this._emitHook("after:getById", { context, result });
     return result;
   }
   /**
@@ -913,7 +965,7 @@ var Repository = class {
       return context._cachedResult;
     }
     const result = await getByQuery(this.Model, query, context);
-    this.emit("after:getByQuery", { context, result });
+    await this._emitHook("after:getByQuery", { context, result });
     return result;
   }
   /**
@@ -978,7 +1030,7 @@ var Repository = class {
         page
       });
     }
-    this.emit("after:getAll", { context, result });
+    await this._emitHook("after:getAll", { context, result });
     return result;
   }
   /**
@@ -1006,10 +1058,10 @@ var Repository = class {
     const context = await this._buildContext("update", { id, data, ...options });
     try {
       const result = await update(this.Model, id, context.data || data, context);
-      this.emit("after:update", { context, result });
+      await this._emitHook("after:update", { context, result });
       return result;
     } catch (error) {
-      this.emit("error:update", { context, error });
+      await this._emitErrorHook("error:update", { context, error });
       throw this._handleError(error);
     }
   }
@@ -1021,14 +1073,14 @@ var Repository = class {
     try {
       if (context.softDeleted) {
         const result2 = { success: true, message: "Soft deleted successfully" };
-        this.emit("after:delete", { context, result: result2 });
+        await this._emitHook("after:delete", { context, result: result2 });
         return result2;
       }
       const result = await deleteById(this.Model, id, options);
-      this.emit("after:delete", { context, result });
+      await this._emitHook("after:delete", { context, result });
       return result;
     } catch (error) {
-      this.emit("error:delete", { context, error });
+      await this._emitErrorHook("error:delete", { context, error });
       throw this._handleError(error);
     }
   }
@@ -1077,10 +1129,10 @@ var Repository = class {
     const context = await this._buildContext(operation, {});
     try {
       const result = await buildQuery(this.Model);
-      this.emit(`after:${operation}`, { context, result });
+      await this._emitHook(`after:${operation}`, { context, result });
       return result;
     } catch (error) {
-      this.emit(`error:${operation}`, { context, error });
+      await this._emitErrorHook(`error:${operation}`, { context, error });
       throw this._handleError(error);
     }
   }
@@ -1561,9 +1613,16 @@ function batchOperationsPlugin() {
         const context = await _buildContext.call(this, "updateMany", { query, data, options });
         try {
           this.emit("before:updateMany", context);
+          if (Array.isArray(data) && options.updatePipeline !== true) {
+            throw createError(
+              400,
+              "Update pipelines (array updates) are disabled by default; pass `{ updatePipeline: true }` to explicitly allow pipeline-style updates."
+            );
+          }
           const result = await this.Model.updateMany(query, data, {
             runValidators: true,
-            session: options.session
+            session: options.session,
+            ...options.updatePipeline !== void 0 ? { updatePipeline: options.updatePipeline } : {}
           }).exec();
           this.emit("after:updateMany", { context, result });
           return result;
@@ -1992,6 +2051,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) {
@@ -2060,8 +2289,8 @@ __export(actions_exports, {
 });
 
 // src/index.ts
-function createRepository(Model, plugins = []) {
-  return new Repository(Model, plugins);
+function createRepository(Model, plugins = [], paginationConfig = {}, options = {}) {
+  return new Repository(Model, plugins, paginationConfig, options);
 }
 var index_default = Repository;
 /**
@@ -2103,6 +2332,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-Bn_-Kk-0.d.ts}

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