@classytic/mongokit 3.2.0 → 3.2.2

package/dist/plugins/index.d.ts

@@ -1,922 +0,0 @@
-import { Q as FieldPreset, g as Plugin, a1 as Logger, a2 as SoftDeleteOptions, j as ObjectId, f as SortSpec, S as SelectSpec, e as PopulateSpec, a as OffsetPaginationResult, E as RepositoryInstance, $ as ValidatorDefinition, a0 as ValidationChainOptions, k as RepositoryContext, a8 as CacheOptions, aa as CacheStats, ac as CascadeOptions } from '../types-Jni1KgkP.js';
-import { ClientSession } from 'mongoose';
-
-/**
- * Field Filter Plugin
- * Automatically filters response fields based on user roles
- */
-
-/**
- * Field filter plugin that restricts fields based on user context
- *
- * @example
- * const fieldPreset = {
- *   public: ['id', 'name'],
- *   authenticated: ['email'],
- *   admin: ['createdAt', 'internalNotes']
- * };
- *
- * const repo = new Repository(Model, [fieldFilterPlugin(fieldPreset)]);
- */
-declare function fieldFilterPlugin(fieldPreset: FieldPreset): Plugin;
-
-/**
- * Timestamp Plugin
- * Auto-injects createdAt/updatedAt timestamps on create/update
- */
-
-/**
- * Timestamp plugin that auto-injects timestamps
- *
- * @example
- * const repo = new Repository(Model, [timestampPlugin()]);
- */
-declare function timestampPlugin(): Plugin;
-
-/**
- * Audit Log Plugin
- * Logs repository operations for auditing purposes
- */
-
-/**
- * Audit log plugin that logs all repository operations
- *
- * @example
- * const repo = new Repository(Model, [auditLogPlugin(console)]);
- */
-declare function auditLogPlugin(logger: Logger): Plugin;
-
-/**
- * Soft Delete Plugin
- * Implements soft delete pattern - marks documents as deleted instead of removing
- */
-
-/**
- * Soft delete plugin
- *
- * @example Basic usage
- * ```typescript
- * const repo = new Repository(Model, [
- *   softDeletePlugin({ deletedField: 'deletedAt' })
- * ]);
- *
- * // Delete (soft)
- * await repo.delete(id);
- *
- * // Restore
- * await repo.restore(id);
- *
- * // Get deleted documents
- * await repo.getDeleted({ page: 1, limit: 20 });
- * ```
- *
- * @example With null filter mode (for schemas with default: null)
- * ```typescript
- * // Schema: { deletedAt: { type: Date, default: null } }
- * const repo = new Repository(Model, [
- *   softDeletePlugin({
- *     deletedField: 'deletedAt',
- *     filterMode: 'null', // default - works with default: null
- *   })
- * ]);
- * ```
- *
- * @example With TTL for auto-cleanup
- * ```typescript
- * const repo = new Repository(Model, [
- *   softDeletePlugin({
- *     deletedField: 'deletedAt',
- *     ttlDays: 30, // Auto-delete after 30 days
- *   })
- * ]);
- * ```
- */
-declare function softDeletePlugin(options?: SoftDeleteOptions): Plugin;
-/**
- * TypeScript interface for soft delete plugin methods
- *
- * @example
- * ```typescript
- * import type { SoftDeleteMethods } from '@classytic/mongokit';
- *
- * type UserRepoWithSoftDelete = UserRepo & SoftDeleteMethods<IUser>;
- *
- * const userRepo = new UserRepo(UserModel, [
- *   methodRegistryPlugin(),
- *   softDeletePlugin({ deletedField: 'deletedAt' }),
- * ]) as UserRepoWithSoftDelete;
- *
- * // TypeScript autocomplete for soft delete methods
- * await userRepo.restore(userId);
- * const deleted = await userRepo.getDeleted({ page: 1, limit: 20 });
- * ```
- */
-interface SoftDeleteMethods<TDoc> {
-    /**
-     * Restore a soft-deleted document
-     * @param id - Document ID to restore
-     * @param options - Optional restore options
-     * @returns Restored document
-     */
-    restore(id: string | ObjectId, options?: {
-        session?: ClientSession;
-    }): Promise<TDoc>;
-    /**
-     * Get paginated list of soft-deleted documents
-     * @param params - Query parameters (filters, sort, pagination)
-     * @param options - Query options (select, populate, lean, session)
-     * @returns Paginated result of deleted documents
-     */
-    getDeleted(params?: {
-        filters?: Record<string, unknown>;
-        sort?: SortSpec | string;
-        page?: number;
-        limit?: number;
-    }, options?: {
-        select?: SelectSpec;
-        populate?: PopulateSpec;
-        lean?: boolean;
-        session?: ClientSession;
-    }): Promise<OffsetPaginationResult<TDoc>>;
-}
-
-/**
- * Method Registry Plugin
- *
- * Enables plugins to dynamically add methods to repository instances.
- * Foundation for extensibility - allows other plugins to extend repositories
- * with custom methods while maintaining type safety and proper binding.
- *
- * @example
- * ```typescript
- * const repo = new Repository(User, [methodRegistryPlugin()]);
- *
- * // Now you can register custom methods
- * repo.registerMethod('findActive', async function() {
- *   return this.getAll({ filters: { status: 'active' } });
- * });
- * ```
- */
-
-/**
- * Extended repository interface with method registry
- */
-interface MethodRegistryRepository extends RepositoryInstance {
-    registerMethod(name: string, fn: Function): void;
-    hasMethod(name: string): boolean;
-    getRegisteredMethods(): string[];
-}
-/**
- * Method registry plugin that enables dynamic method registration
- */
-declare function methodRegistryPlugin(): Plugin;
-
-/**
- * Validation Chain Plugin
- *
- * Composable validation for repository operations with customizable rules.
- */
-
-type OperationType = 'create' | 'createMany' | 'update' | 'delete';
-/**
- * Validation chain plugin
- *
- * @example
- * const repo = new Repository(Model, [
- *   validationChainPlugin([
- *     requireField('email'),
- *     uniqueField('email', 'Email already exists'),
- *     blockIf('no-delete-admin', ['delete'], ctx => ctx.data?.role === 'admin', 'Cannot delete admin'),
- *   ])
- * ]);
- */
-declare function validationChainPlugin(validators?: ValidatorDefinition[], options?: ValidationChainOptions): Plugin;
-/**
- * Block operation if condition is true
- *
- * @example
- * blockIf('block-library', ['delete'], ctx => ctx.data?.managed, 'Cannot delete managed records')
- */
-declare function blockIf(name: string, operations: OperationType[], condition: (context: RepositoryContext) => boolean, errorMessage: string): ValidatorDefinition;
-/**
- * Require a field to be present
- */
-declare function requireField(field: string, operations?: OperationType[]): ValidatorDefinition;
-/**
- * Auto-inject a value if not present
- */
-declare function autoInject(field: string, getter: (context: RepositoryContext) => unknown, operations?: OperationType[]): ValidatorDefinition;
-/**
- * Make a field immutable (cannot be updated)
- */
-declare function immutableField(field: string): ValidatorDefinition;
-/**
- * Ensure field value is unique
- */
-declare function uniqueField(field: string, errorMessage?: string): ValidatorDefinition;
-
-/**
- * MongoDB Operations Plugin
- *
- * Adds MongoDB-specific operations to repositories.
- * Requires method-registry.plugin.js to be loaded first.
- */
-
-/**
- * MongoDB operations plugin
- *
- * Adds MongoDB-specific atomic operations to repositories:
- * - upsert: Create or update document
- * - increment/decrement: Atomic numeric operations
- * - pushToArray/pullFromArray/addToSet: Array operations
- * - setField/unsetField/renameField: Field operations
- * - multiplyField: Multiply numeric field
- * - setMin/setMax: Conditional min/max updates
- *
- * @example Basic usage (no TypeScript autocomplete)
- * ```typescript
- * const repo = new Repository(ProductModel, [
- *   methodRegistryPlugin(),
- *   mongoOperationsPlugin(),
- * ]);
- *
- * // Works at runtime but TypeScript doesn't know about these methods
- * await (repo as any).increment(productId, 'views', 1);
- * await (repo as any).pushToArray(productId, 'tags', 'featured');
- * ```
- *
- * @example With TypeScript type safety (recommended)
- * ```typescript
- * import { Repository, mongoOperationsPlugin, methodRegistryPlugin } from '@classytic/mongokit';
- * import type { MongoOperationsMethods } from '@classytic/mongokit';
- *
- * class ProductRepo extends Repository<IProduct> {
- *   // Add your custom methods here
- * }
- *
- * // Create with type assertion to get autocomplete for plugin methods
- * type ProductRepoWithPlugins = ProductRepo & MongoOperationsMethods<IProduct>;
- *
- * const repo = new ProductRepo(ProductModel, [
- *   methodRegistryPlugin(),
- *   mongoOperationsPlugin(),
- * ]) as ProductRepoWithPlugins;
- *
- * // Now TypeScript provides autocomplete and type checking!
- * await repo.increment(productId, 'views', 1);
- * await repo.upsert({ sku: 'ABC' }, { name: 'Product', price: 99 });
- * await repo.pushToArray(productId, 'tags', 'featured');
- * ```
- */
-declare function mongoOperationsPlugin(): Plugin;
-/**
- * Type interface for repositories using mongoOperationsPlugin
- *
- * Use this interface to get TypeScript autocomplete and type safety
- * for the methods added by mongoOperationsPlugin.
- *
- * @example
- * ```typescript
- * import { Repository, mongoOperationsPlugin, methodRegistryPlugin } from '@classytic/mongokit';
- * import type { MongoOperationsMethods } from '@classytic/mongokit';
- *
- * // Without type safety (base is flexible)
- * class ProductRepo extends Repository<IProduct> {
- *   // Can add anything - fully flexible
- * }
- *
- * // With type safety for plugin methods
- * class ProductRepo extends Repository<IProduct> implements MongoOperationsMethods<IProduct> {
- *   // TypeScript knows about upsert, increment, decrement, etc.
- * }
- *
- * const repo = new ProductRepo(ProductModel, [
- *   methodRegistryPlugin(),
- *   mongoOperationsPlugin(),
- * ]);
- *
- * // Now TypeScript provides autocomplete and type checking
- * await repo.increment(productId, 'views', 1);
- * await repo.upsert({ sku: 'ABC' }, { name: 'Product' });
- * ```
- */
-interface MongoOperationsMethods<TDoc> {
-    /**
-     * Update existing document or insert new one
-     * @param query - Query to find document
-     * @param data - Data to update or insert
-     * @param options - Operation options (session, etc.)
-     * @returns Created or updated document
-     */
-    upsert(query: Record<string, unknown>, data: Record<string, unknown>, options?: Record<string, unknown>): Promise<TDoc>;
-    /**
-     * Atomically increment numeric field
-     * @param id - Document ID
-     * @param field - Field name to increment
-     * @param value - Value to increment by (default: 1)
-     * @param options - Operation options (session, etc.)
-     * @returns Updated document
-     */
-    increment(id: string | ObjectId, field: string, value?: number, options?: Record<string, unknown>): Promise<TDoc>;
-    /**
-     * Atomically decrement numeric field
-     * @param id - Document ID
-     * @param field - Field name to decrement
-     * @param value - Value to decrement by (default: 1)
-     * @param options - Operation options (session, etc.)
-     * @returns Updated document
-     */
-    decrement(id: string | ObjectId, field: string, value?: number, options?: Record<string, unknown>): Promise<TDoc>;
-    /**
-     * Push value to array field
-     * @param id - Document ID
-     * @param field - Array field name
-     * @param value - Value to push
-     * @param options - Operation options (session, etc.)
-     * @returns Updated document
-     */
-    pushToArray(id: string | ObjectId, field: string, value: unknown, options?: Record<string, unknown>): Promise<TDoc>;
-    /**
-     * Remove value from array field
-     * @param id - Document ID
-     * @param field - Array field name
-     * @param value - Value to remove
-     * @param options - Operation options (session, etc.)
-     * @returns Updated document
-     */
-    pullFromArray(id: string | ObjectId, field: string, value: unknown, options?: Record<string, unknown>): Promise<TDoc>;
-    /**
-     * Add value to array only if not already present (unique)
-     * @param id - Document ID
-     * @param field - Array field name
-     * @param value - Value to add
-     * @param options - Operation options (session, etc.)
-     * @returns Updated document
-     */
-    addToSet(id: string | ObjectId, field: string, value: unknown, options?: Record<string, unknown>): Promise<TDoc>;
-    /**
-     * Set field value (alias for update with $set)
-     * @param id - Document ID
-     * @param field - Field name
-     * @param value - Value to set
-     * @param options - Operation options (session, etc.)
-     * @returns Updated document
-     */
-    setField(id: string | ObjectId, field: string, value: unknown, options?: Record<string, unknown>): Promise<TDoc>;
-    /**
-     * Unset (remove) field from document
-     * @param id - Document ID
-     * @param fields - Field name or array of field names to remove
-     * @param options - Operation options (session, etc.)
-     * @returns Updated document
-     */
-    unsetField(id: string | ObjectId, fields: string | string[], options?: Record<string, unknown>): Promise<TDoc>;
-    /**
-     * Rename field in document
-     * @param id - Document ID
-     * @param oldName - Current field name
-     * @param newName - New field name
-     * @param options - Operation options (session, etc.)
-     * @returns Updated document
-     */
-    renameField(id: string | ObjectId, oldName: string, newName: string, options?: Record<string, unknown>): Promise<TDoc>;
-    /**
-     * Multiply numeric field by value
-     * @param id - Document ID
-     * @param field - Field name
-     * @param multiplier - Multiplier value
-     * @param options - Operation options (session, etc.)
-     * @returns Updated document
-     */
-    multiplyField(id: string | ObjectId, field: string, multiplier: number, options?: Record<string, unknown>): Promise<TDoc>;
-    /**
-     * Set field to minimum value (only if current value is greater)
-     * @param id - Document ID
-     * @param field - Field name
-     * @param value - Minimum value
-     * @param options - Operation options (session, etc.)
-     * @returns Updated document
-     */
-    setMin(id: string | ObjectId, field: string, value: unknown, options?: Record<string, unknown>): Promise<TDoc>;
-    /**
-     * Set field to maximum value (only if current value is less)
-     * @param id - Document ID
-     * @param field - Field name
-     * @param value - Maximum value
-     * @param options - Operation options (session, etc.)
-     * @returns Updated document
-     */
-    setMax(id: string | ObjectId, field: string, value: unknown, options?: Record<string, unknown>): Promise<TDoc>;
-}
-
-/**
- * Batch Operations Plugin
- * Adds bulk update/delete operations with proper event emission
- */
-
-/**
- * Batch operations plugin
- *
- * @example
- * const repo = new Repository(Model, [
- *   methodRegistryPlugin(),
- *   batchOperationsPlugin(),
- * ]);
- *
- * await repo.updateMany({ status: 'pending' }, { status: 'active' });
- * await repo.deleteMany({ status: 'deleted' });
- */
-declare function batchOperationsPlugin(): Plugin;
-/**
- * Type interface for repositories using batchOperationsPlugin
- *
- * @example
- * ```typescript
- * import { Repository, methodRegistryPlugin, batchOperationsPlugin } from '@classytic/mongokit';
- * import type { BatchOperationsMethods } from '@classytic/mongokit';
- *
- * class ProductRepo extends Repository<IProduct> {}
- *
- * type ProductRepoWithBatch = ProductRepo & BatchOperationsMethods;
- *
- * const repo = new ProductRepo(ProductModel, [
- *   methodRegistryPlugin(),
- *   batchOperationsPlugin(),
- * ]) as ProductRepoWithBatch;
- *
- * // TypeScript autocomplete works!
- * await repo.updateMany({ status: 'pending' }, { status: 'active' });
- * await repo.deleteMany({ status: 'archived' });
- * ```
- */
-interface BatchOperationsMethods {
-    /**
-     * Update multiple documents matching the query
-     * @param query - Query to match documents
-     * @param data - Update data
-     * @param options - Operation options
-     * @returns Update result with matchedCount, modifiedCount, etc.
-     */
-    updateMany(query: Record<string, unknown>, data: Record<string, unknown>, options?: {
-        session?: ClientSession;
-        updatePipeline?: boolean;
-    }): Promise<{
-        acknowledged: boolean;
-        matchedCount: number;
-        modifiedCount: number;
-        upsertedCount: number;
-        upsertedId: unknown;
-    }>;
-    /**
-     * Delete multiple documents matching the query
-     * @param query - Query to match documents
-     * @param options - Operation options
-     * @returns Delete result with deletedCount
-     */
-    deleteMany(query: Record<string, unknown>, options?: Record<string, unknown>): Promise<{
-        acknowledged: boolean;
-        deletedCount: number;
-    }>;
-}
-
-/**
- * Aggregate Helpers Plugin
- * Adds common aggregation helper methods
- */
-
-/**
- * Aggregate helpers plugin
- *
- * @example
- * const repo = new Repository(Model, [
- *   methodRegistryPlugin(),
- *   aggregateHelpersPlugin(),
- * ]);
- *
- * const groups = await repo.groupBy('category');
- * const total = await repo.sum('amount', { status: 'completed' });
- */
-declare function aggregateHelpersPlugin(): Plugin;
-/**
- * Type interface for repositories using aggregateHelpersPlugin
- *
- * @example
- * ```typescript
- * import { Repository, methodRegistryPlugin, aggregateHelpersPlugin } from '@classytic/mongokit';
- * import type { AggregateHelpersMethods } from '@classytic/mongokit';
- *
- * class OrderRepo extends Repository<IOrder> {}
- *
- * type OrderRepoWithAggregates = OrderRepo & AggregateHelpersMethods;
- *
- * const repo = new OrderRepo(OrderModel, [
- *   methodRegistryPlugin(),
- *   aggregateHelpersPlugin(),
- * ]) as OrderRepoWithAggregates;
- *
- * // TypeScript autocomplete works!
- * const groups = await repo.groupBy('status');
- * const total = await repo.sum('amount', { status: 'completed' });
- * const avg = await repo.average('amount');
- * ```
- */
-interface AggregateHelpersMethods {
-    /**
-     * Group documents by field value and count occurrences
-     * @param field - Field to group by
-     * @param options - Operation options
-     * @returns Array of groups with _id and count
-     */
-    groupBy(field: string, options?: {
-        limit?: number;
-        session?: unknown;
-    }): Promise<Array<{
-        _id: unknown;
-        count: number;
-    }>>;
-    /**
-     * Calculate sum of field values
-     * @param field - Field to sum
-     * @param query - Filter query
-     * @param options - Operation options
-     * @returns Sum of field values
-     */
-    sum(field: string, query?: Record<string, unknown>, options?: Record<string, unknown>): Promise<number>;
-    /**
-     * Calculate average of field values
-     * @param field - Field to average
-     * @param query - Filter query
-     * @param options - Operation options
-     * @returns Average of field values
-     */
-    average(field: string, query?: Record<string, unknown>, options?: Record<string, unknown>): Promise<number>;
-    /**
-     * Get minimum field value
-     * @param field - Field to get minimum from
-     * @param query - Filter query
-     * @param options - Operation options
-     * @returns Minimum field value
-     */
-    min(field: string, query?: Record<string, unknown>, options?: Record<string, unknown>): Promise<number>;
-    /**
-     * Get maximum field value
-     * @param field - Field to get maximum from
-     * @param query - Filter query
-     * @param options - Operation options
-     * @returns Maximum field value
-     */
-    max(field: string, query?: Record<string, unknown>, options?: Record<string, unknown>): Promise<number>;
-}
-
-/**
- * Subdocument Plugin
- * Adds subdocument array operations
- */
-
-/**
- * Subdocument plugin for managing nested arrays
- *
- * @example
- * const repo = new Repository(Model, [
- *   methodRegistryPlugin(),
- *   subdocumentPlugin(),
- * ]);
- *
- * await repo.addSubdocument(parentId, 'items', { name: 'Item 1' });
- * await repo.updateSubdocument(parentId, 'items', itemId, { name: 'Updated Item' });
- */
-declare function subdocumentPlugin(): Plugin;
-/**
- * Type interface for repositories using subdocumentPlugin
- *
- * @example
- * ```typescript
- * import { Repository, methodRegistryPlugin, subdocumentPlugin } from '@classytic/mongokit';
- * import type { SubdocumentMethods } from '@classytic/mongokit';
- *
- * class OrderRepo extends Repository<IOrder> {}
- *
- * type OrderRepoWithSubdocs = OrderRepo & SubdocumentMethods<IOrder>;
- *
- * const repo = new OrderRepo(OrderModel, [
- *   methodRegistryPlugin(),
- *   subdocumentPlugin(),
- * ]) as OrderRepoWithSubdocs;
- *
- * // TypeScript autocomplete works!
- * await repo.addSubdocument(orderId, 'items', { productId: '123', quantity: 2 });
- * await repo.updateSubdocument(orderId, 'items', itemId, { quantity: 5 });
- * await repo.deleteSubdocument(orderId, 'items', itemId);
- * ```
- */
-interface SubdocumentMethods<TDoc> {
-    /**
-     * Add subdocument to array field
-     * @param parentId - Parent document ID
-     * @param arrayPath - Path to array field (e.g., 'items', 'addresses')
-     * @param subData - Subdocument data
-     * @param options - Operation options
-     * @returns Updated parent document
-     */
-    addSubdocument(parentId: string | ObjectId, arrayPath: string, subData: Record<string, unknown>, options?: Record<string, unknown>): Promise<TDoc>;
-    /**
-     * Get subdocument from array field
-     * @param parentId - Parent document ID
-     * @param arrayPath - Path to array field
-     * @param subId - Subdocument ID
-     * @param options - Operation options
-     * @returns Subdocument
-     */
-    getSubdocument(parentId: string | ObjectId, arrayPath: string, subId: string | ObjectId, options?: {
-        lean?: boolean;
-        session?: unknown;
-    }): Promise<Record<string, unknown>>;
-    /**
-     * Update subdocument in array field
-     * @param parentId - Parent document ID
-     * @param arrayPath - Path to array field
-     * @param subId - Subdocument ID
-     * @param updateData - Update data
-     * @param options - Operation options
-     * @returns Updated parent document
-     */
-    updateSubdocument(parentId: string | ObjectId, arrayPath: string, subId: string | ObjectId, updateData: Record<string, unknown>, options?: {
-        session?: unknown;
-    }): Promise<TDoc>;
-    /**
-     * Delete subdocument from array field
-     * @param parentId - Parent document ID
-     * @param arrayPath - Path to array field
-     * @param subId - Subdocument ID
-     * @param options - Operation options
-     * @returns Updated parent document
-     */
-    deleteSubdocument(parentId: string | ObjectId, arrayPath: string, subId: string | ObjectId, options?: Record<string, unknown>): Promise<TDoc>;
-}
-
-/**
- * Cache Plugin
- *
- * Optional caching layer for MongoKit with automatic invalidation.
- * Bring-your-own cache adapter (Redis, Memcached, in-memory, etc.)
- *
- * Features:
- * - Cache-aside (read-through) pattern with configurable TTLs
- * - Automatic invalidation on create/update/delete
- * - Collection version tags for efficient list cache invalidation
- * - Manual invalidation methods for microservice scenarios
- * - Skip cache per-operation with `skipCache: true`
- *
- * @example
- * ```typescript
- * import { Repository, cachePlugin } from '@classytic/mongokit';
- * import Redis from 'ioredis';
- *
- * const redis = new Redis();
- *
- * const userRepo = new Repository(UserModel, [
- *   cachePlugin({
- *     adapter: {
- *       async get(key) { return JSON.parse(await redis.get(key) || 'null'); },
- *       async set(key, value, ttl) { await redis.setex(key, ttl, JSON.stringify(value)); },
- *       async del(key) { await redis.del(key); },
- *       async clear(pattern) {
- *         const keys = await redis.keys(pattern || '*');
- *         if (keys.length) await redis.del(...keys);
- *       }
- *     },
- *     ttl: 60, // 1 minute default
- *   })
- * ]);
- *
- * // Reads check cache first
- * const user = await userRepo.getById(id); // cached
- *
- * // Skip cache for fresh data
- * const fresh = await userRepo.getById(id, { skipCache: true });
- *
- * // Mutations auto-invalidate
- * await userRepo.update(id, { name: 'New Name' }); // invalidates cache
- *
- * // Manual invalidation for microservice sync
- * await userRepo.invalidateCache(id); // invalidate single doc
- * await userRepo.invalidateAllCache(); // invalidate all for this model
- * ```
- */
-
-/**
- * Cache plugin factory
- *
- * @param options - Cache configuration
- * @returns Plugin instance
- */
-declare function cachePlugin(options: CacheOptions): Plugin;
-/**
- * TypeScript interface for cache plugin methods
- *
- * @example
- * ```typescript
- * import type { CacheMethods } from '@classytic/mongokit';
- *
- * type ProductRepoWithCache = ProductRepo & CacheMethods;
- *
- * const productRepo = new ProductRepo(ProductModel, [
- *   methodRegistryPlugin(),
- *   cachePlugin({ adapter: redisAdapter, ttl: 60 }),
- * ]) as ProductRepoWithCache;
- *
- * // TypeScript autocomplete for cache methods
- * await productRepo.invalidateCache(productId);
- * await productRepo.invalidateListCache();
- * await productRepo.invalidateAllCache();
- * const stats = productRepo.getCacheStats();
- * productRepo.resetCacheStats();
- * ```
- */
-interface CacheMethods {
-    /**
-     * Invalidate cache for a specific document
-     * Use when document was updated outside this service
-     * @param id - Document ID to invalidate
-     */
-    invalidateCache(id: string): Promise<void>;
-    /**
-     * Invalidate all list caches for this model
-     * Use when bulk changes happened outside this service
-     */
-    invalidateListCache(): Promise<void>;
-    /**
-     * Invalidate ALL cache entries for this model
-     * Nuclear option - use sparingly
-     */
-    invalidateAllCache(): Promise<void>;
-    /**
-     * Get cache statistics for monitoring
-     * @returns Cache statistics (hits, misses, sets, invalidations)
-     */
-    getCacheStats(): CacheStats;
-    /**
-     * Reset cache statistics
-     */
-    resetCacheStats(): void;
-}
-
-/**
- * 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;
-
-/**
- * Multi-Tenant Plugin
- *
- * Automatically injects tenant isolation filters into all queries.
- * Ensures data isolation by adding organizationId (or custom tenant field)
- * to every read and write operation.
- *
- * @example
- * ```typescript
- * // Basic — scopes every operation by organizationId from context
- * const repo = new Repository(Invoice, [
- *   multiTenantPlugin({ tenantField: 'organizationId' }),
- * ]);
- *
- * const invoices = await repo.getAll(
- *   { filters: { status: 'paid' } },
- *   { organizationId: 'org_123' }
- * );
- * // Actual query: { status: 'paid', organizationId: 'org_123' }
- *
- * // Super admin bypass — skip scoping based on context
- * const repo = new Repository(Invoice, [
- *   multiTenantPlugin({
- *     tenantField: 'organizationId',
- *     skipWhen: (context) => context.role === 'superadmin',
- *   }),
- * ]);
- *
- * // Admin sees all orgs
- * await repo.getAll({ page: 1, limit: 10 }, { role: 'superadmin' });
- *
- * // Automatic context — resolve tenant from AsyncLocalStorage
- * const repo = new Repository(Invoice, [
- *   multiTenantPlugin({
- *     tenantField: 'organizationId',
- *     resolveContext: () => asyncLocalStorage.getStore()?.tenantId,
- *   }),
- * ]);
- * ```
- */
-
-interface MultiTenantOptions {
-    /** Field name used for tenant isolation (default: 'organizationId') */
-    tenantField?: string;
-    /** Context key to read tenant ID from (default: 'organizationId') */
-    contextKey?: string;
-    /** Throw if tenant ID is missing from context (default: true) */
-    required?: boolean;
-    /** Operations to skip tenant injection (e.g., for admin/system queries) */
-    skipOperations?: string[];
-    /**
-     * Dynamic skip — receives the context and operation name, returns true to
-     * bypass tenant scoping for this call. Use for role-based bypass (e.g.,
-     * super admin) without needing a separate repo instance.
-     *
-     * @example
-     * ```typescript
-     * skipWhen: (context) => context.role === 'superadmin'
-     * ```
-     */
-    skipWhen?: (context: RepositoryContext, operation: string) => boolean;
-    /**
-     * Resolve tenant ID from external source (e.g., AsyncLocalStorage, CLS).
-     * Called when tenant ID is not found in context. If it returns a value,
-     * that value is used as the tenant ID without requiring it in context.
-     *
-     * @example
-     * ```typescript
-     * resolveContext: () => asyncLocalStorage.getStore()?.tenantId
-     * ```
-     */
-    resolveContext?: () => string | undefined;
-}
-declare function multiTenantPlugin(options?: MultiTenantOptions): Plugin;
-
-/**
- * Observability Plugin
- *
- * Adds operation timing, structured metrics, and APM hook points.
- * Works with any monitoring system — just provide an onMetric callback.
- *
- * @example
- * ```typescript
- * const repo = new Repository(User, [
- *   observabilityPlugin({
- *     onMetric: (metric) => {
- *       // Send to DataDog, New Relic, OpenTelemetry, or console
- *       console.log(`${metric.operation} took ${metric.durationMs}ms`);
- *       statsd.histogram('mongokit.operation', metric.durationMs, { op: metric.operation });
- *     },
- *   }),
- * ]);
- * ```
- */
-
-interface OperationMetric {
-    /** Operation name (e.g., 'create', 'getAll', 'update') */
-    operation: string;
-    /** Model/collection name */
-    model: string;
-    /** Duration in milliseconds */
-    durationMs: number;
-    /** Whether the operation succeeded */
-    success: boolean;
-    /** Error message if failed */
-    error?: string;
-    /** Timestamp when the operation started */
-    startedAt: Date;
-    /** User ID if available */
-    userId?: string;
-    /** Organization ID if available */
-    organizationId?: string;
-}
-interface ObservabilityOptions {
-    /** Callback invoked after every operation with timing data */
-    onMetric: (metric: OperationMetric) => void;
-    /** Operations to track (default: all) */
-    operations?: string[];
-    /** Threshold in ms — only report operations slower than this */
-    slowThresholdMs?: number;
-}
-declare function observabilityPlugin(options: ObservabilityOptions): Plugin;
-
-export { type AggregateHelpersMethods, type BatchOperationsMethods, type CacheMethods, type MethodRegistryRepository, type MongoOperationsMethods, type MultiTenantOptions, type ObservabilityOptions, type OperationMetric, type SoftDeleteMethods, type SubdocumentMethods, aggregateHelpersPlugin, auditLogPlugin, autoInject, batchOperationsPlugin, blockIf, cachePlugin, cascadePlugin, fieldFilterPlugin, immutableField, methodRegistryPlugin, mongoOperationsPlugin, multiTenantPlugin, observabilityPlugin, requireField, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validationChainPlugin };