@classytic/mongokit 3.2.2 → 3.2.3

package/README.md

@@ -12,12 +12,12 @@
 - **Zero dependencies** - Only Mongoose as peer dependency
 - **Explicit + smart pagination** - Explicit `mode` control or auto-detection; offset, keyset, and aggregate
 - **Event-driven** - Pre/post hooks for all operations (granular scalability hooks)
-- **16 built-in plugins** - Caching, soft delete, validation, multi-tenant, custom IDs, observability, Elasticsearch, and more
+- **17 built-in plugins** - Caching, soft delete, audit trail, validation, multi-tenant, custom IDs, observability, Elasticsearch, and more
 - **Distributed cache safety** - List cache versions stored in the adapter (Redis) for multi-pod correctness
 - **Search governance** - Text index guard (throws `400` if no index), allowlisted sort/filter fields, ReDoS protection
 - **Vector search** - MongoDB Atlas `$vectorSearch` with auto-embedding and multimodal support
 - **TypeScript first** - Full type safety with discriminated unions
-- **604 passing tests** - Battle-tested and production-ready
+- **592 passing tests** - Battle-tested and production-ready
 
 ## Installation
 
@@ -216,6 +216,7 @@ const repo = new Repository(UserModel, [
 | `multiTenantPlugin(opts)`           | Auto-inject tenant isolation on all operations            |
 | `customIdPlugin(opts)`              | Auto-generate sequential/random IDs with atomic counters  |
 | `elasticSearchPlugin(opts)`         | Delegate text/semantic search to Elasticsearch/OpenSearch |
+| `auditTrailPlugin(opts)`            | DB-persisted audit trail with change tracking and TTL     |
 | `observabilityPlugin(opts)`         | Operation timing, metrics, slow query detection           |
 
 ### Soft Delete
@@ -359,6 +360,126 @@ await repo.update(userId, { name: "New" }, { organizationId: "org_123" });
 // Cross-tenant update/delete is blocked — returns "not found"
 ```
 
+### Audit Trail (DB-Persisted)
+
+The `auditTrailPlugin` persists operation audit entries to a shared MongoDB collection. Unlike `auditLogPlugin` (which logs to an external logger), this stores a queryable audit trail in the database with automatic TTL cleanup.
+
+```typescript
+import {
+  Repository,
+  methodRegistryPlugin,
+  auditTrailPlugin,
+} from "@classytic/mongokit";
+
+const repo = new Repository(JobModel, [
+  methodRegistryPlugin(),
+  auditTrailPlugin({
+    operations: ["create", "update", "delete"], // Which ops to track
+    trackChanges: true, // Field-level before/after diff on updates
+    trackDocument: false, // Full doc snapshot on create (heavy)
+    ttlDays: 90, // Auto-purge after 90 days (MongoDB TTL index)
+    excludeFields: ["password", "token"], // Redact sensitive fields
+    metadata: (context) => ({
+      // Custom metadata per entry
+      ip: context.req?.ip,
+      userAgent: context.req?.headers?.["user-agent"],
+    }),
+  }),
+]);
+
+// Query audit trail for a specific document (requires methodRegistryPlugin)
+const trail = await repo.getAuditTrail(documentId, {
+  page: 1,
+  limit: 20,
+  operation: "update", // Optional filter
+});
+// → { docs, page, limit, total, pages, hasNext, hasPrev }
+```
+
+**What gets stored:**
+
+```javascript
+{
+  model: 'Job',
+  operation: 'update',
+  documentId: ObjectId('...'),
+  userId: ObjectId('...'),
+  orgId: ObjectId('...'),
+  changes: {
+    title: { from: 'Old Title', to: 'New Title' },
+    salary: { from: 50000, to: 65000 },
+  },
+  metadata: { ip: '192.168.1.1' },
+  timestamp: ISODate('2026-02-26T...'),
+}
+```
+
+**Standalone queries** (admin dashboards, audit APIs — no repo needed):
+
+```typescript
+import { AuditTrailQuery } from "@classytic/mongokit";
+
+const auditQuery = new AuditTrailQuery(); // 'audit_trails' collection
+
+// All audits for an org
+const orgAudits = await auditQuery.getOrgTrail(orgId);
+
+// All actions by a user
+const userAudits = await auditQuery.getUserTrail(userId);
+
+// History of a specific document
+const docHistory = await auditQuery.getDocumentTrail("Job", jobId);
+
+// Custom query with date range
+const recent = await auditQuery.query({
+  orgId,
+  operation: "delete",
+  from: new Date("2025-01-01"),
+  to: new Date(),
+  page: 1,
+  limit: 50,
+});
+
+// Direct model access for anything custom
+const model = auditQuery.getModel();
+const deleteCount = await model.countDocuments({ operation: "delete" });
+```
+
+**Key design decisions:**
+
+- **Fire & forget** — audit writes are async and never block or fail the main operation
+- **Shared collection** — one `audit_trails` collection for all models (filtered by `model` field)
+- **TTL index** — MongoDB auto-deletes old entries, no cron needed
+- **Change diff** — compares before/after on updates, stores only changed fields
+
+**Plugin options:**
+
+| Option          | Default                          | Description                            |
+| --------------- | -------------------------------- | -------------------------------------- |
+| `operations`    | `['create', 'update', 'delete']` | Which operations to audit              |
+| `trackChanges`  | `true`                           | Store before/after diff on updates     |
+| `trackDocument` | `false`                          | Store full document snapshot on create |
+| `ttlDays`       | `undefined` (keep forever)       | Auto-purge after N days                |
+| `collectionName`| `'audit_trails'`                 | MongoDB collection name                |
+| `excludeFields` | `[]`                             | Fields to redact from diffs/snapshots  |
+| `metadata`      | `undefined`                      | Callback to inject custom metadata     |
+
+**TypeScript type safety:**
+
+```typescript
+import type { AuditTrailMethods } from "@classytic/mongokit";
+
+type JobRepoWithAudit = JobRepo & AuditTrailMethods;
+
+const repo = new JobRepo(JobModel, [
+  methodRegistryPlugin(),
+  auditTrailPlugin({ ttlDays: 90 }),
+]) as JobRepoWithAudit;
+
+// Full autocomplete for getAuditTrail
+const trail = await repo.getAuditTrail(jobId, { operation: "update" });
+```
+
 ### Observability
 
 ```javascript
@@ -715,7 +836,7 @@ await repo.restore(id);
 await repo.invalidateCache(id);
 ```
 
-**Individual plugin types:** `MongoOperationsMethods<T>`, `BatchOperationsMethods`, `AggregateHelpersMethods`, `SubdocumentMethods<T>`, `SoftDeleteMethods<T>`, `CacheMethods`
+**Individual plugin types:** `MongoOperationsMethods<T>`, `BatchOperationsMethods`, `AggregateHelpersMethods`, `SubdocumentMethods<T>`, `SoftDeleteMethods<T>`, `CacheMethods`, `AuditTrailMethods`
 
 ## Event System
 
@@ -1126,7 +1247,7 @@ Extending Repository works exactly the same with Mongoose 8 and 9. The package:
 - Uses its own event system (not Mongoose middleware)
 - Defines its own `FilterQuery` type (unaffected by Mongoose 9 rename)
 - Properly gates update pipelines (safe for Mongoose 9's stricter defaults)
-- All 604 tests pass on Mongoose 9
+- All 597 tests pass on Mongoose 9
 
 ## License
 

package/dist/{custom-id.plugin-BzZI4gnE.d.mts → custom-id.plugin-BmK0SjR9.d.mts}

@@ -732,6 +732,152 @@ interface ObservabilityOptions {
 }
 declare function observabilityPlugin(options: ObservabilityOptions): Plugin;
 //#endregion
+//#region src/plugins/audit-trail.plugin.d.ts
+interface AuditTrailOptions {
+  /** Operations to track (default: ['create', 'update', 'delete']) */
+  operations?: AuditOperation[];
+  /** Store field-level before/after diff on updates (default: true) */
+  trackChanges?: boolean;
+  /** Store full document snapshot on create (default: false — can be heavy) */
+  trackDocument?: boolean;
+  /** Auto-purge after N days via MongoDB TTL index (default: undefined — keep forever) */
+  ttlDays?: number;
+  /** MongoDB collection name (default: 'audit_trails') */
+  collectionName?: string;
+  /**
+   * Extract custom metadata from the repository context.
+   * Returned object is stored on the audit entry as `metadata`.
+   */
+  metadata?: (context: RepositoryContext) => Record<string, unknown>;
+  /**
+   * Fields to exclude from change tracking (e.g., passwords, tokens).
+   * These fields are redacted in the `changes` diff.
+   */
+  excludeFields?: string[];
+}
+type AuditOperation = 'create' | 'update' | 'delete';
+interface AuditEntry {
+  model: string;
+  operation: AuditOperation;
+  documentId: unknown;
+  userId?: unknown;
+  orgId?: unknown;
+  changes?: Record<string, {
+    from: unknown;
+    to: unknown;
+  }>;
+  document?: Record<string, unknown>;
+  metadata?: Record<string, unknown>;
+  timestamp: Date;
+}
+declare function auditTrailPlugin(options?: AuditTrailOptions): Plugin;
+interface AuditQueryOptions {
+  model?: string;
+  documentId?: string | ObjectId;
+  userId?: string | ObjectId;
+  orgId?: string | ObjectId;
+  operation?: AuditOperation;
+  from?: Date;
+  to?: Date;
+  page?: number;
+  limit?: number;
+}
+interface AuditQueryResult {
+  docs: AuditEntry[];
+  page: number;
+  limit: number;
+  total: number;
+  pages: number;
+  hasNext: boolean;
+  hasPrev: boolean;
+}
+/**
+ * Standalone audit trail query utility.
+ * Use this to query audits across all models — e.g., admin dashboards, audit APIs.
+ *
+ * @example
+ * ```typescript
+ * import { AuditTrailQuery } from '@classytic/mongokit';
+ *
+ * const auditQuery = new AuditTrailQuery(); // defaults to 'audit_trails' collection
+ *
+ * // All audits for an org
+ * const orgAudits = await auditQuery.query({ orgId: '...' });
+ *
+ * // All updates by a user
+ * const userUpdates = await auditQuery.query({
+ *   userId: '...',
+ *   operation: 'update',
+ * });
+ *
+ * // All audits for a specific document
+ * const docHistory = await auditQuery.query({
+ *   model: 'Job',
+ *   documentId: '...',
+ * });
+ *
+ * // Date range
+ * const recent = await auditQuery.query({
+ *   from: new Date('2025-01-01'),
+ *   to: new Date(),
+ *   page: 1,
+ *   limit: 50,
+ * });
+ *
+ * // Direct model access for custom queries
+ * const model = auditQuery.getModel();
+ * const count = await model.countDocuments({ operation: 'delete' });
+ * ```
+ */
+declare class AuditTrailQuery {
+  private model;
+  constructor(collectionName?: string, ttlDays?: number);
+  /**
+   * Get the underlying Mongoose model for custom queries
+   */
+  getModel(): mongoose.Model<AuditEntry>;
+  /**
+   * Query audit entries with filters and pagination
+   */
+  query(options?: AuditQueryOptions): Promise<AuditQueryResult>;
+  /**
+   * Get audit trail for a specific document
+   */
+  getDocumentTrail(model: string, documentId: string | ObjectId, options?: {
+    page?: number;
+    limit?: number;
+    operation?: AuditOperation;
+  }): Promise<AuditQueryResult>;
+  /**
+   * Get all audits for a user
+   */
+  getUserTrail(userId: string | ObjectId, options?: {
+    page?: number;
+    limit?: number;
+    operation?: AuditOperation;
+    orgId?: string | ObjectId;
+  }): Promise<AuditQueryResult>;
+  /**
+   * Get all audits for an organization
+   */
+  getOrgTrail(orgId: string | ObjectId, options?: {
+    page?: number;
+    limit?: number;
+    operation?: AuditOperation;
+    model?: string;
+  }): Promise<AuditQueryResult>;
+}
+interface AuditTrailMethods {
+  /**
+   * Get paginated audit trail for a document
+   */
+  getAuditTrail(documentId: string | ObjectId, options?: {
+    page?: number;
+    limit?: number;
+    operation?: AuditOperation;
+  }): Promise<AuditQueryResult>;
+}
+//#endregion
 //#region src/plugins/elastic.plugin.d.ts
 interface ElasticSearchOptions {
   /** Elasticsearch or OpenSearch client instance */
@@ -890,4 +1036,4 @@ declare function prefixedId(options: PrefixedIdOptions): IdGenerator;
  */
 declare function customIdPlugin(options: CustomIdOptions): Plugin;
 //#endregion
-export { blockIf as A, timestampPlugin as B, AggregateHelpersMethods as C, MongoOperationsMethods as D, batchOperationsPlugin as E, MethodRegistryRepository as F, methodRegistryPlugin as I, SoftDeleteMethods as L, requireField as M, uniqueField as N, mongoOperationsPlugin as O, validationChainPlugin as P, softDeletePlugin as R, subdocumentPlugin as S, BatchOperationsMethods as T, fieldFilterPlugin as V, multiTenantPlugin as _, SequentialIdOptions as a, cachePlugin as b, getNextSequence as c, ElasticSearchOptions as d, elasticSearchPlugin as f, MultiTenantOptions as g, observabilityPlugin as h, PrefixedIdOptions as i, immutableField as j, autoInject as k, prefixedId as l, OperationMetric as m, DateSequentialIdOptions as n, customIdPlugin as o, ObservabilityOptions as p, IdGenerator as r, dateSequentialId as s, CustomIdOptions as t, sequentialId as u, cascadePlugin as v, aggregateHelpersPlugin as w, SubdocumentMethods as x, CacheMethods as y, auditLogPlugin as z };
+export { subdocumentPlugin as A, requireField as B, observabilityPlugin as C, CacheMethods as D, cascadePlugin as E, MongoOperationsMethods as F, SoftDeleteMethods as G, validationChainPlugin as H, mongoOperationsPlugin as I, timestampPlugin as J, softDeletePlugin as K, autoInject as L, aggregateHelpersPlugin as M, BatchOperationsMethods as N, cachePlugin as O, batchOperationsPlugin as P, blockIf as R, OperationMetric as S, multiTenantPlugin as T, MethodRegistryRepository as U, uniqueField as V, methodRegistryPlugin as W, fieldFilterPlugin as Y, AuditTrailMethods as _, SequentialIdOptions as a, auditTrailPlugin as b, getNextSequence as c, ElasticSearchOptions as d, elasticSearchPlugin as f, AuditQueryResult as g, AuditQueryOptions as h, PrefixedIdOptions as i, AggregateHelpersMethods as j, SubdocumentMethods as k, prefixedId as l, AuditOperation as m, DateSequentialIdOptions as n, customIdPlugin as o, AuditEntry as p, auditLogPlugin as q, IdGenerator as r, dateSequentialId as s, CustomIdOptions as t, sequentialId as u, AuditTrailOptions as v, MultiTenantOptions as w, ObservabilityOptions as x, AuditTrailQuery as y, immutableField as z };

package/dist/{custom-id.plugin-B_zIs6gE.mjs → custom-id.plugin-m0VW6yYm.mjs}

@@ -1487,6 +1487,357 @@ function observabilityPlugin(options) {
 	};
 }
 
+//#endregion
+//#region src/plugins/audit-trail.plugin.ts
+/**
+* Audit Trail Plugin
+*
+* Persists operation audit entries to a MongoDB collection.
+* Fire-and-forget: writes happen async and never block or fail the main operation.
+*
+* Features:
+* - Tracks create, update, delete operations
+* - Field-level change tracking (before/after diff on updates)
+* - TTL auto-cleanup via MongoDB TTL index
+* - Custom metadata per entry (IP, user-agent, etc.)
+* - Shared `audit_trails` collection across all models
+*
+* @example
+* ```typescript
+* const repo = new Repository(Job, [
+*   auditTrailPlugin({
+*     operations: ['create', 'update', 'delete'],
+*     trackChanges: true,
+*     ttlDays: 90,
+*     metadata: (context) => ({
+*       ip: context.req?.ip,
+*     }),
+*   }),
+* ]);
+* ```
+*/
+const modelCache = /* @__PURE__ */ new Map();
+function getAuditModel(collectionName, ttlDays) {
+	const existing = modelCache.get(collectionName);
+	if (existing) return existing;
+	const schema = new mongoose.Schema({
+		model: {
+			type: String,
+			required: true,
+			index: true
+		},
+		operation: {
+			type: String,
+			required: true,
+			enum: [
+				"create",
+				"update",
+				"delete"
+			]
+		},
+		documentId: {
+			type: mongoose.Schema.Types.Mixed,
+			required: true,
+			index: true
+		},
+		userId: {
+			type: mongoose.Schema.Types.Mixed,
+			index: true
+		},
+		orgId: {
+			type: mongoose.Schema.Types.Mixed,
+			index: true
+		},
+		changes: { type: mongoose.Schema.Types.Mixed },
+		document: { type: mongoose.Schema.Types.Mixed },
+		metadata: { type: mongoose.Schema.Types.Mixed },
+		timestamp: {
+			type: Date,
+			default: Date.now,
+			index: true
+		}
+	}, {
+		collection: collectionName,
+		versionKey: false
+	});
+	schema.index({
+		model: 1,
+		documentId: 1,
+		timestamp: -1
+	});
+	schema.index({
+		orgId: 1,
+		userId: 1,
+		timestamp: -1
+	});
+	if (ttlDays !== void 0 && ttlDays > 0) {
+		const ttlSeconds = ttlDays * 24 * 60 * 60;
+		schema.index({ timestamp: 1 }, { expireAfterSeconds: ttlSeconds });
+	}
+	const modelName = `AuditTrail_${collectionName}`;
+	const model = mongoose.models[modelName] || mongoose.model(modelName, schema);
+	modelCache.set(collectionName, model);
+	return model;
+}
+/** Compute field-level diff between previous and updated document */
+function computeChanges(prev, next, excludeFields) {
+	const changes = {};
+	const exclude = new Set(excludeFields);
+	for (const key of Object.keys(next)) {
+		if (exclude.has(key)) continue;
+		if (key === "_id" || key === "__v" || key === "updatedAt") continue;
+		const prevVal = prev[key];
+		const nextVal = next[key];
+		if (!deepEqual(prevVal, nextVal)) changes[key] = {
+			from: prevVal,
+			to: nextVal
+		};
+	}
+	return Object.keys(changes).length > 0 ? changes : void 0;
+}
+/** Simple deep equality check for audit diffing */
+function deepEqual(a, b) {
+	if (a === b) return true;
+	if (a == null && b == null) return true;
+	if (a == null || b == null) return false;
+	if (typeof a === "object" && typeof b === "object") {
+		const aStr = a.toString?.();
+		const bStr = b.toString?.();
+		if (aStr && bStr && aStr === bStr) return true;
+	}
+	if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+	try {
+		return JSON.stringify(a) === JSON.stringify(b);
+	} catch {
+		return false;
+	}
+}
+/** Extract user ID from context */
+function getUserId(context) {
+	return context.user?._id || context.user?.id;
+}
+/** Fire-and-forget: write audit entry, never throw */
+function writeAudit(AuditModel, entry) {
+	Promise.resolve().then(() => {
+		AuditModel.create({
+			...entry,
+			timestamp: /* @__PURE__ */ new Date()
+		}).catch((err) => {
+			warn(`[auditTrailPlugin] Failed to write audit entry: ${err.message}`);
+		});
+	});
+}
+const snapshots = /* @__PURE__ */ new WeakMap();
+function auditTrailPlugin(options = {}) {
+	const { operations = [
+		"create",
+		"update",
+		"delete"
+	], trackChanges = true, trackDocument = false, ttlDays, collectionName = "audit_trails", metadata, excludeFields = [] } = options;
+	const opsSet = new Set(operations);
+	return {
+		name: "auditTrail",
+		apply(repo) {
+			const AuditModel = getAuditModel(collectionName, ttlDays);
+			if (opsSet.has("create")) repo.on("after:create", ({ context, result }) => {
+				const doc = toPlainObject(result);
+				writeAudit(AuditModel, {
+					model: context.model || repo.model,
+					operation: "create",
+					documentId: doc?._id,
+					userId: getUserId(context),
+					orgId: context.organizationId,
+					document: trackDocument ? sanitizeDoc(doc, excludeFields) : void 0,
+					metadata: metadata?.(context)
+				});
+			});
+			if (opsSet.has("update")) {
+				if (trackChanges) repo.on("before:update", async (context) => {
+					if (!context.id) return;
+					try {
+						const prev = await repo.Model.findById(context.id).lean();
+						if (prev) snapshots.set(context, prev);
+					} catch (err) {
+						warn(`[auditTrailPlugin] Failed to snapshot before update: ${err.message}`);
+					}
+				});
+				repo.on("after:update", ({ context, result }) => {
+					const doc = result;
+					let changes;
+					if (trackChanges) {
+						const prev = snapshots.get(context);
+						if (prev && context.data) changes = computeChanges(prev, context.data, excludeFields);
+						snapshots.delete(context);
+					}
+					writeAudit(AuditModel, {
+						model: context.model || repo.model,
+						operation: "update",
+						documentId: context.id || doc?._id,
+						userId: getUserId(context),
+						orgId: context.organizationId,
+						changes,
+						metadata: metadata?.(context)
+					});
+				});
+			}
+			if (opsSet.has("delete")) repo.on("after:delete", ({ context }) => {
+				writeAudit(AuditModel, {
+					model: context.model || repo.model,
+					operation: "delete",
+					documentId: context.id,
+					userId: getUserId(context),
+					orgId: context.organizationId,
+					metadata: metadata?.(context)
+				});
+			});
+			if (typeof repo.registerMethod === "function")
+ /**
+			* Get audit trail for a specific document
+			*/
+			repo.registerMethod("getAuditTrail", async function(documentId, queryOptions = {}) {
+				const { page = 1, limit = 20, operation } = queryOptions;
+				const skip = (page - 1) * limit;
+				const filter = {
+					model: this.model,
+					documentId
+				};
+				if (operation) filter.operation = operation;
+				const [docs, total] = await Promise.all([AuditModel.find(filter).sort({ timestamp: -1 }).skip(skip).limit(limit).lean(), AuditModel.countDocuments(filter)]);
+				return {
+					docs,
+					page,
+					limit,
+					total,
+					pages: Math.ceil(total / limit),
+					hasNext: page < Math.ceil(total / limit),
+					hasPrev: page > 1
+				};
+			});
+		}
+	};
+}
+/** Convert Mongoose document to plain object */
+function toPlainObject(doc) {
+	if (!doc) return {};
+	if (typeof doc.toObject === "function") return doc.toObject();
+	return doc;
+}
+/** Remove excluded fields from a document snapshot */
+function sanitizeDoc(doc, excludeFields) {
+	if (excludeFields.length === 0) return doc;
+	const result = { ...doc };
+	for (const field of excludeFields) delete result[field];
+	return result;
+}
+/**
+* Standalone audit trail query utility.
+* Use this to query audits across all models — e.g., admin dashboards, audit APIs.
+*
+* @example
+* ```typescript
+* import { AuditTrailQuery } from '@classytic/mongokit';
+*
+* const auditQuery = new AuditTrailQuery(); // defaults to 'audit_trails' collection
+*
+* // All audits for an org
+* const orgAudits = await auditQuery.query({ orgId: '...' });
+*
+* // All updates by a user
+* const userUpdates = await auditQuery.query({
+*   userId: '...',
+*   operation: 'update',
+* });
+*
+* // All audits for a specific document
+* const docHistory = await auditQuery.query({
+*   model: 'Job',
+*   documentId: '...',
+* });
+*
+* // Date range
+* const recent = await auditQuery.query({
+*   from: new Date('2025-01-01'),
+*   to: new Date(),
+*   page: 1,
+*   limit: 50,
+* });
+*
+* // Direct model access for custom queries
+* const model = auditQuery.getModel();
+* const count = await model.countDocuments({ operation: 'delete' });
+* ```
+*/
+var AuditTrailQuery = class {
+	model;
+	constructor(collectionName = "audit_trails", ttlDays) {
+		this.model = getAuditModel(collectionName, ttlDays);
+	}
+	/**
+	* Get the underlying Mongoose model for custom queries
+	*/
+	getModel() {
+		return this.model;
+	}
+	/**
+	* Query audit entries with filters and pagination
+	*/
+	async query(options = {}) {
+		const { page = 1, limit = 20 } = options;
+		const skip = (page - 1) * limit;
+		const filter = {};
+		if (options.model) filter.model = options.model;
+		if (options.documentId) filter.documentId = options.documentId;
+		if (options.userId) filter.userId = options.userId;
+		if (options.orgId) filter.orgId = options.orgId;
+		if (options.operation) filter.operation = options.operation;
+		if (options.from || options.to) {
+			const dateFilter = {};
+			if (options.from) dateFilter.$gte = options.from;
+			if (options.to) dateFilter.$lte = options.to;
+			filter.timestamp = dateFilter;
+		}
+		const [docs, total] = await Promise.all([this.model.find(filter).sort({ timestamp: -1 }).skip(skip).limit(limit).lean(), this.model.countDocuments(filter)]);
+		const pages = Math.ceil(total / limit);
+		return {
+			docs,
+			page,
+			limit,
+			total,
+			pages,
+			hasNext: page < pages,
+			hasPrev: page > 1
+		};
+	}
+	/**
+	* Get audit trail for a specific document
+	*/
+	async getDocumentTrail(model, documentId, options = {}) {
+		return this.query({
+			model,
+			documentId,
+			...options
+		});
+	}
+	/**
+	* Get all audits for a user
+	*/
+	async getUserTrail(userId, options = {}) {
+		return this.query({
+			userId,
+			...options
+		});
+	}
+	/**
+	* Get all audits for an organization
+	*/
+	async getOrgTrail(orgId, options = {}) {
+		return this.query({
+			orgId,
+			...options
+		});
+	}
+};
+
 //#endregion
 //#region src/plugins/elastic.plugin.ts
 function elasticSearchPlugin(options) {
@@ -1815,4 +2166,4 @@ function customIdPlugin(options) {
 }
 
 //#endregion
-export { auditLogPlugin as C, softDeletePlugin as S, fieldFilterPlugin as T, immutableField as _, sequentialId as a, validationChainPlugin as b, multiTenantPlugin as c, subdocumentPlugin as d, aggregateHelpersPlugin as f, blockIf as g, autoInject as h, prefixedId as i, cascadePlugin as l, mongoOperationsPlugin as m, dateSequentialId as n, elasticSearchPlugin as o, batchOperationsPlugin as p, getNextSequence as r, observabilityPlugin as s, customIdPlugin as t, cachePlugin as u, requireField as v, timestampPlugin as w, methodRegistryPlugin as x, uniqueField as y };
+export { methodRegistryPlugin as C, fieldFilterPlugin as D, timestampPlugin as E, validationChainPlugin as S, auditLogPlugin as T, autoInject as _, sequentialId as a, requireField as b, auditTrailPlugin as c, cascadePlugin as d, cachePlugin as f, mongoOperationsPlugin as g, batchOperationsPlugin as h, prefixedId as i, observabilityPlugin as l, aggregateHelpersPlugin as m, dateSequentialId as n, elasticSearchPlugin as o, subdocumentPlugin as p, getNextSequence as r, AuditTrailQuery as s, customIdPlugin as t, multiTenantPlugin as u, blockIf as v, softDeletePlugin as w, uniqueField as x, immutableField as y };

package/dist/index.d.mts

@@ -2,7 +2,7 @@ import { $ as SchemaBuilderOptions, A as KeysetPaginationOptions, B as Paginatio
 import "./aggregate-CCHI7F51.mjs";
 import { t as index_d_exports } from "./actions/index.mjs";
 import { PaginationEngine } from "./pagination/PaginationEngine.mjs";
-import { A as blockIf, B as timestampPlugin, C as AggregateHelpersMethods, D as MongoOperationsMethods, E as batchOperationsPlugin, I as methodRegistryPlugin, L as SoftDeleteMethods, M as requireField, N as uniqueField, O as mongoOperationsPlugin, P as validationChainPlugin, R as softDeletePlugin, S as subdocumentPlugin, T as BatchOperationsMethods, V as fieldFilterPlugin, _ as multiTenantPlugin, a as SequentialIdOptions, b as cachePlugin, c as getNextSequence, d as ElasticSearchOptions, f as elasticSearchPlugin, g as MultiTenantOptions, h as observabilityPlugin, i as PrefixedIdOptions, j as immutableField, k as autoInject, l as prefixedId, m as OperationMetric, n as DateSequentialIdOptions, o as customIdPlugin, p as ObservabilityOptions, r as IdGenerator, s as dateSequentialId, t as CustomIdOptions, u as sequentialId, v as cascadePlugin, w as aggregateHelpersPlugin, x as SubdocumentMethods, y as CacheMethods, z as auditLogPlugin } from "./custom-id.plugin-BzZI4gnE.mjs";
+import { A as subdocumentPlugin, B as requireField, C as observabilityPlugin, D as CacheMethods, E as cascadePlugin, F as MongoOperationsMethods, G as SoftDeleteMethods, H as validationChainPlugin, I as mongoOperationsPlugin, J as timestampPlugin, K as softDeletePlugin, L as autoInject, M as aggregateHelpersPlugin, N as BatchOperationsMethods, O as cachePlugin, P as batchOperationsPlugin, R as blockIf, S as OperationMetric, T as multiTenantPlugin, V as uniqueField, W as methodRegistryPlugin, Y as fieldFilterPlugin, _ as AuditTrailMethods, a as SequentialIdOptions, b as auditTrailPlugin, c as getNextSequence, d as ElasticSearchOptions, f as elasticSearchPlugin, g as AuditQueryResult, h as AuditQueryOptions, i as PrefixedIdOptions, j as AggregateHelpersMethods, k as SubdocumentMethods, l as prefixedId, m as AuditOperation, n as DateSequentialIdOptions, o as customIdPlugin, p as AuditEntry, q as auditLogPlugin, r as IdGenerator, s as dateSequentialId, t as CustomIdOptions, u as sequentialId, v as AuditTrailOptions, w as MultiTenantOptions, x as ObservabilityOptions, y as AuditTrailQuery, z as immutableField } from "./custom-id.plugin-BmK0SjR9.mjs";
 import { a as isFieldUpdateAllowed, c as configureLogger, d as filterResponseData, f as getFieldsForUser, i as getSystemManagedFields, l as createError, n as buildCrudSchemasFromMongooseSchema, o as validateUpdateBody, p as getMongooseProjection, r as getImmutableFields, s as createMemoryCache, t as buildCrudSchemasFromModel, u as createFieldPreset } from "./mongooseToJsonSchema-Wbvjfwkn.mjs";
 import * as mongoose$1 from "mongoose";
 import { ClientSession, Expression, Model, PipelineStage, PopulateOptions } from "mongoose";
@@ -841,6 +841,15 @@ interface QueryParserOptions {
   allowedFilterFields?: string[];
   /** Allowed fields for sorting. If set, ignores unknown fields. */
   allowedSortFields?: string[];
+  /**
+   * Whitelist of allowed filter operators.
+   * When set, only these operators can be used in filters.
+   * When undefined, all built-in operators are allowed.
+   * Values are human-readable keys: 'eq', 'ne', 'gt', 'gte', 'lt', 'lte', 'in', 'nin',
+   * 'like', 'contains', 'regex', 'exists', 'size', 'type'
+   * @example ['eq', 'ne', 'gt', 'gte', 'lt', 'lte', 'in']
+   */
+  allowedOperators?: string[];
 }
 /**
  * Modern Query Parser
@@ -872,6 +881,34 @@ declare class QueryParser {
    * ```
    */
   parse(query: Record<string, unknown> | null | undefined): ParsedQuery;
+  /**
+   * Generate OpenAPI-compatible JSON Schema for query parameters.
+   * Arc's defineResource() auto-detects this method and uses it
+   * to document list endpoint query parameters in OpenAPI/Swagger.
+   *
+   * The schema respects parser configuration:
+   * - `allowedOperators`: only documents allowed operators
+   * - `allowedFilterFields`: generates explicit field[op] entries
+   * - `enableLookups` / `enableAggregations`: includes/excludes lookup/aggregate params
+   * - `maxLimit` / `maxSearchLength`: reflected in schema constraints
+   */
+  getQuerySchema(): {
+    type: "object";
+    properties: Record<string, unknown>;
+    required?: string[];
+  };
+  /**
+   * Get the JSON Schema type for a filter operator
+   */
+  private _getOperatorSchemaType;
+  /**
+   * Get a human-readable description for a filter operator
+   */
+  private _getOperatorDescription;
+  /**
+   * Build a summary description of all available filter operators
+   */
+  private _buildOperatorDescription;
   /**
    * Parse lookup configurations from URL parameters
    *
@@ -1009,4 +1046,4 @@ declare class QueryParser {
  */
 declare function createRepository<TDoc>(Model: mongoose$1.Model<TDoc, any, any, any>, plugins?: PluginType[], paginationConfig?: PaginationConfig, options?: RepositoryOptions): Repository<TDoc>;
 //#endregion
-export { type AggregateHelpersMethods, type AggregatePaginationOptions, type AggregatePaginationResult, AggregationBuilder, type AllPluginMethods, type AnyDocument, type AnyModel, type BatchOperationsMethods, type CacheAdapter, type CacheMethods, type CacheOperationOptions, type CacheOptions, type CacheStats, type CascadeOptions, type CascadeRelation, type CreateInput, type CreateOptions, type CrudSchemas, type CustomIdOptions, type DateSequentialIdOptions, type DecodedCursor, type DeepPartial, type DeleteResult, type ElasticSearchOptions, type EventHandlers, type EventPayload, type EventPhase, type FieldPreset, type FieldRules, type FilterQuery, type GroupResult, type HookMode, type HttpError, type IController, type IControllerResponse, type IRequestContext, type IResponseFormatter, type IdGenerator, type InferDocument, type InferRawDoc, type JsonSchema, type KeysOfType, type KeysetPaginationOptions, type KeysetPaginationResult, type Logger, LookupBuilder, type LookupOptions, type MinMaxResult, type MongoOperationsMethods, type MultiTenantOptions, type NonNullableFields, type ObjectId, type ObservabilityOptions, type OffsetPaginationOptions, type OffsetPaginationResult, type OperationMetric, type OperationOptions, type PaginationConfig, PaginationEngine, type PaginationResult, type ParsedQuery, type PartialBy, type Plugin, type PluginFunction, type PluginType, type PopulateOption, type PopulateSpec, type PrefixedIdOptions, QueryParser, type QueryParserOptions, type ReadPreferenceType, Repository, Repository as default, type RepositoryContext, type RepositoryEvent, type RepositoryInstance, type RepositoryOperation, type RepositoryOptions, type RequiredBy, type SchemaBuilderOptions, type SearchMode, type SelectSpec, type SequentialIdOptions, type SoftDeleteFilterMode, type SoftDeleteMethods, type SoftDeleteOptions, type SoftDeleteRepository, type SortDirection, type SortSpec, type Strict, type SubdocumentMethods, type UpdateInput, type UpdateManyResult, type UpdateOptions, type UpdateWithValidationResult, type UserContext, type ValidationChainOptions, type ValidationResult, type ValidatorDefinition, type WithPlugins, type WithTransactionOptions, index_d_exports as actions, aggregateHelpersPlugin, auditLogPlugin, autoInject, batchOperationsPlugin, blockIf, buildCrudSchemasFromModel, buildCrudSchemasFromMongooseSchema, cachePlugin, cascadePlugin, configureLogger, createError, createFieldPreset, createMemoryCache, createRepository, customIdPlugin, dateSequentialId, elasticSearchPlugin, fieldFilterPlugin, filterResponseData, getFieldsForUser, getImmutableFields, getMongooseProjection, getNextSequence, getSystemManagedFields, immutableField, isFieldUpdateAllowed, methodRegistryPlugin, mongoOperationsPlugin, multiTenantPlugin, observabilityPlugin, prefixedId, requireField, sequentialId, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validateUpdateBody, validationChainPlugin };
+export { type AggregateHelpersMethods, type AggregatePaginationOptions, type AggregatePaginationResult, AggregationBuilder, type AllPluginMethods, type AnyDocument, type AnyModel, type AuditEntry, type AuditOperation, type AuditQueryOptions, type AuditQueryResult, type AuditTrailMethods, type AuditTrailOptions, AuditTrailQuery, type BatchOperationsMethods, type CacheAdapter, type CacheMethods, type CacheOperationOptions, type CacheOptions, type CacheStats, type CascadeOptions, type CascadeRelation, type CreateInput, type CreateOptions, type CrudSchemas, type CustomIdOptions, type DateSequentialIdOptions, type DecodedCursor, type DeepPartial, type DeleteResult, type ElasticSearchOptions, type EventHandlers, type EventPayload, type EventPhase, type FieldPreset, type FieldRules, type FilterQuery, type GroupResult, type HookMode, type HttpError, type IController, type IControllerResponse, type IRequestContext, type IResponseFormatter, type IdGenerator, type InferDocument, type InferRawDoc, type JsonSchema, type KeysOfType, type KeysetPaginationOptions, type KeysetPaginationResult, type Logger, LookupBuilder, type LookupOptions, type MinMaxResult, type MongoOperationsMethods, type MultiTenantOptions, type NonNullableFields, type ObjectId, type ObservabilityOptions, type OffsetPaginationOptions, type OffsetPaginationResult, type OperationMetric, type OperationOptions, type PaginationConfig, PaginationEngine, type PaginationResult, type ParsedQuery, type PartialBy, type Plugin, type PluginFunction, type PluginType, type PopulateOption, type PopulateSpec, type PrefixedIdOptions, QueryParser, type QueryParserOptions, type ReadPreferenceType, Repository, Repository as default, type RepositoryContext, type RepositoryEvent, type RepositoryInstance, type RepositoryOperation, type RepositoryOptions, type RequiredBy, type SchemaBuilderOptions, type SearchMode, type SelectSpec, type SequentialIdOptions, type SoftDeleteFilterMode, type SoftDeleteMethods, type SoftDeleteOptions, type SoftDeleteRepository, type SortDirection, type SortSpec, type Strict, type SubdocumentMethods, type UpdateInput, type UpdateManyResult, type UpdateOptions, type UpdateWithValidationResult, type UserContext, type ValidationChainOptions, type ValidationResult, type ValidatorDefinition, type WithPlugins, type WithTransactionOptions, index_d_exports as actions, aggregateHelpersPlugin, auditLogPlugin, auditTrailPlugin, autoInject, batchOperationsPlugin, blockIf, buildCrudSchemasFromModel, buildCrudSchemasFromMongooseSchema, cachePlugin, cascadePlugin, configureLogger, createError, createFieldPreset, createMemoryCache, createRepository, customIdPlugin, dateSequentialId, elasticSearchPlugin, fieldFilterPlugin, filterResponseData, getFieldsForUser, getImmutableFields, getMongooseProjection, getNextSequence, getSystemManagedFields, immutableField, isFieldUpdateAllowed, methodRegistryPlugin, mongoOperationsPlugin, multiTenantPlugin, observabilityPlugin, prefixedId, requireField, sequentialId, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validateUpdateBody, validationChainPlugin };

package/dist/index.mjs

@@ -3,7 +3,7 @@ import { n as createMany, t as create } from "./create-BuO6xt0v.mjs";
 import { a as deleteById, d as getById, f as getByQuery, i as LookupBuilder, l as count, p as getOrCreate, r as distinct, s as update, t as aggregate, u as exists } from "./aggregate-BAi4Do-X.mjs";
 import { PaginationEngine } from "./pagination/PaginationEngine.mjs";
 import { c as filterResponseData, l as getFieldsForUser, s as createFieldPreset, u as getMongooseProjection } from "./cache-keys-C8Z9B5sw.mjs";
-import { C as auditLogPlugin, S as softDeletePlugin, T as fieldFilterPlugin, _ as immutableField, a as sequentialId, b as validationChainPlugin, c as multiTenantPlugin, d as subdocumentPlugin, f as aggregateHelpersPlugin, g as blockIf, h as autoInject, i as prefixedId, l as cascadePlugin, m as mongoOperationsPlugin, n as dateSequentialId, o as elasticSearchPlugin, p as batchOperationsPlugin, r as getNextSequence, s as observabilityPlugin, t as customIdPlugin, u as cachePlugin, v as requireField, w as timestampPlugin, x as methodRegistryPlugin, y as uniqueField } from "./custom-id.plugin-B_zIs6gE.mjs";
+import { C as methodRegistryPlugin, D as fieldFilterPlugin, E as timestampPlugin, S as validationChainPlugin, T as auditLogPlugin, _ as autoInject, a as sequentialId, b as requireField, c as auditTrailPlugin, d as cascadePlugin, f as cachePlugin, g as mongoOperationsPlugin, h as batchOperationsPlugin, i as prefixedId, l as observabilityPlugin, m as aggregateHelpersPlugin, n as dateSequentialId, o as elasticSearchPlugin, p as subdocumentPlugin, r as getNextSequence, s as AuditTrailQuery, t as customIdPlugin, u as multiTenantPlugin, v as blockIf, w as softDeletePlugin, x as uniqueField, y as immutableField } from "./custom-id.plugin-m0VW6yYm.mjs";
 import { a as isFieldUpdateAllowed, i as getSystemManagedFields, n as buildCrudSchemasFromMongooseSchema, o as validateUpdateBody, r as getImmutableFields, s as createMemoryCache, t as buildCrudSchemasFromModel } from "./mongooseToJsonSchema-COdDEkIJ.mjs";
 import { t as actions_exports } from "./actions/index.mjs";
 import mongoose from "mongoose";
@@ -1266,7 +1266,8 @@ var QueryParser = class {
 			searchFields: options.searchFields,
 			allowedLookupCollections: options.allowedLookupCollections,
 			allowedFilterFields: options.allowedFilterFields,
-			allowedSortFields: options.allowedSortFields
+			allowedSortFields: options.allowedSortFields,
+			allowedOperators: options.allowedOperators
 		};
 		if (this.options.searchMode === "regex" && (!this.options.searchFields || this.options.searchFields.length === 0)) {
 			warn("[mongokit] searchMode \"regex\" requires searchFields to be specified. Falling back to \"text\" mode.");
@@ -1336,6 +1337,143 @@ var QueryParser = class {
 		return parsed;
 	}
 	/**
+	* Generate OpenAPI-compatible JSON Schema for query parameters.
+	* Arc's defineResource() auto-detects this method and uses it
+	* to document list endpoint query parameters in OpenAPI/Swagger.
+	*
+	* The schema respects parser configuration:
+	* - `allowedOperators`: only documents allowed operators
+	* - `allowedFilterFields`: generates explicit field[op] entries
+	* - `enableLookups` / `enableAggregations`: includes/excludes lookup/aggregate params
+	* - `maxLimit` / `maxSearchLength`: reflected in schema constraints
+	*/
+	getQuerySchema() {
+		const properties = {
+			page: {
+				type: "integer",
+				description: "Page number for offset pagination",
+				default: 1,
+				minimum: 1
+			},
+			limit: {
+				type: "integer",
+				description: "Number of items per page",
+				default: 20,
+				minimum: 1,
+				maximum: this.options.maxLimit
+			},
+			sort: {
+				type: "string",
+				description: "Sort fields (comma-separated). Prefix with - for descending. Example: -createdAt,name"
+			},
+			search: {
+				type: "string",
+				description: this.options.searchMode === "regex" ? `Search across fields${this.options.searchFields ? ` (${this.options.searchFields.join(", ")})` : ""} using case-insensitive regex` : "Full-text search query (requires text index)",
+				maxLength: this.options.maxSearchLength
+			},
+			select: {
+				type: "string",
+				description: "Fields to include/exclude (comma-separated). Prefix with - to exclude. Example: name,email,-password"
+			},
+			populate: {
+				type: "string",
+				description: "Fields to populate/join (comma-separated). Example: author,category"
+			},
+			after: {
+				type: "string",
+				description: "Cursor value for keyset pagination"
+			}
+		};
+		if (this.options.enableLookups) properties["lookup"] = {
+			type: "object",
+			description: "Custom field lookups ($lookup). Example: lookup[department]=slug or lookup[department][localField]=deptId&lookup[department][foreignField]=_id"
+		};
+		if (this.options.enableAggregations) properties["aggregate"] = {
+			type: "object",
+			description: "Aggregation pipeline stages. Supports: group, match, sort, project. Example: aggregate[group][_id]=$status"
+		};
+		const availableOperators = this.options.allowedOperators ? Object.entries(this.operators).filter(([key]) => this.options.allowedOperators.includes(key)) : Object.entries(this.operators);
+		if (this.options.allowedFilterFields && this.options.allowedFilterFields.length > 0) for (const field of this.options.allowedFilterFields) {
+			properties[field] = {
+				type: "string",
+				description: `Filter by ${field} (exact match)`
+			};
+			for (const [op, mongoOp] of availableOperators) {
+				if (op === "eq") continue;
+				properties[`${field}[${op}]`] = {
+					type: this._getOperatorSchemaType(op),
+					description: this._getOperatorDescription(op, field, mongoOp)
+				};
+			}
+		}
+		properties["_filterOperators"] = {
+			type: "string",
+			description: this._buildOperatorDescription(availableOperators),
+			"x-internal": true
+		};
+		return {
+			type: "object",
+			properties
+		};
+	}
+	/**
+	* Get the JSON Schema type for a filter operator
+	*/
+	_getOperatorSchemaType(op) {
+		if ([
+			"gt",
+			"gte",
+			"lt",
+			"lte",
+			"size"
+		].includes(op)) return "number";
+		if (["exists"].includes(op)) return "boolean";
+		return "string";
+	}
+	/**
+	* Get a human-readable description for a filter operator
+	*/
+	_getOperatorDescription(op, field, mongoOp) {
+		return {
+			ne: `${field} not equal to value (${mongoOp})`,
+			gt: `${field} greater than value (${mongoOp})`,
+			gte: `${field} greater than or equal to value (${mongoOp})`,
+			lt: `${field} less than value (${mongoOp})`,
+			lte: `${field} less than or equal to value (${mongoOp})`,
+			in: `${field} in comma-separated list (${mongoOp}). Example: value1,value2`,
+			nin: `${field} not in comma-separated list (${mongoOp})`,
+			like: `${field} matches pattern (case-insensitive regex)`,
+			contains: `${field} contains substring (case-insensitive regex)`,
+			regex: `${field} matches regex pattern (${mongoOp})`,
+			exists: `Field ${field} exists (true/false)`,
+			size: `Array field ${field} has exactly N elements (${mongoOp})`,
+			type: `Field ${field} is of BSON type (${mongoOp})`
+		}[op] || `Filter ${field} with ${mongoOp}`;
+	}
+	/**
+	* Build a summary description of all available filter operators
+	*/
+	_buildOperatorDescription(operators) {
+		const lines = ["Available filter operators (use as field[operator]=value):"];
+		for (const [op, mongoOp] of operators) lines.push(`  ${op} → ${mongoOp}: ${{
+			eq: "Equal (default when no operator specified)",
+			ne: "Not equal",
+			gt: "Greater than",
+			gte: "Greater than or equal",
+			lt: "Less than",
+			lte: "Less than or equal",
+			in: "In list (comma-separated values)",
+			nin: "Not in list",
+			like: "Pattern match (case-insensitive)",
+			contains: "Contains substring (case-insensitive)",
+			regex: "Regex pattern",
+			exists: "Field exists (true/false)",
+			size: "Array size equals",
+			type: "BSON type check"
+		}[op] || op}`);
+		return lines.join("\n");
+	}
+	/**
 	* Parse lookup configurations from URL parameters
 	*
 	* Supported formats:
@@ -1608,6 +1746,10 @@ var QueryParser = class {
 	_handleOperatorSyntax(filters, regexFields, operatorMatch, value) {
 		const [, field, operator] = operatorMatch;
 		if (value === "" || value === null || value === void 0) return;
+		if (this.options.allowedOperators && !this.options.allowedOperators.includes(operator.toLowerCase())) {
+			warn(`[mongokit] Operator not in allowlist: ${operator}`);
+			return;
+		}
 		if (operator.toLowerCase() === "options" && regexFields[field]) {
 			const fieldValue = filters[field];
 			if (typeof fieldValue === "object" && fieldValue !== null && "$regex" in fieldValue) if (typeof value === "string" && /^[imsx]+$/.test(value)) fieldValue.$options = value;
@@ -1667,6 +1809,10 @@ var QueryParser = class {
 				parsedFilters[field].between = value;
 				continue;
 			}
+			if (this.options.allowedOperators && !this.options.allowedOperators.includes(operator)) {
+				warn(`[mongokit] Operator not in allowlist: ${operator}`);
+				continue;
+			}
 			if (this.operators[operator]) {
 				const mongoOperator = this.operators[operator];
 				let processedValue;
@@ -1903,4 +2049,4 @@ function createRepository(Model, plugins = [], paginationConfig = {}, options =
 var src_default = Repository;
 
 //#endregion
-export { AggregationBuilder, LookupBuilder, PaginationEngine, QueryParser, Repository, actions_exports as actions, aggregateHelpersPlugin, auditLogPlugin, autoInject, batchOperationsPlugin, blockIf, buildCrudSchemasFromModel, buildCrudSchemasFromMongooseSchema, cachePlugin, cascadePlugin, configureLogger, createError, createFieldPreset, createMemoryCache, createRepository, customIdPlugin, dateSequentialId, src_default as default, elasticSearchPlugin, fieldFilterPlugin, filterResponseData, getFieldsForUser, getImmutableFields, getMongooseProjection, getNextSequence, getSystemManagedFields, immutableField, isFieldUpdateAllowed, methodRegistryPlugin, mongoOperationsPlugin, multiTenantPlugin, observabilityPlugin, prefixedId, requireField, sequentialId, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validateUpdateBody, validationChainPlugin };
+export { AggregationBuilder, AuditTrailQuery, LookupBuilder, PaginationEngine, QueryParser, Repository, actions_exports as actions, aggregateHelpersPlugin, auditLogPlugin, auditTrailPlugin, autoInject, batchOperationsPlugin, blockIf, buildCrudSchemasFromModel, buildCrudSchemasFromMongooseSchema, cachePlugin, cascadePlugin, configureLogger, createError, createFieldPreset, createMemoryCache, createRepository, customIdPlugin, dateSequentialId, src_default as default, elasticSearchPlugin, fieldFilterPlugin, filterResponseData, getFieldsForUser, getImmutableFields, getMongooseProjection, getNextSequence, getSystemManagedFields, immutableField, isFieldUpdateAllowed, methodRegistryPlugin, mongoOperationsPlugin, multiTenantPlugin, observabilityPlugin, prefixedId, requireField, sequentialId, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validateUpdateBody, validationChainPlugin };

package/dist/plugins/index.d.mts

@@ -1,3 +1,3 @@
 import "../types-D-gploPr.mjs";
-import { A as blockIf, B as timestampPlugin, C as AggregateHelpersMethods, D as MongoOperationsMethods, E as batchOperationsPlugin, F as MethodRegistryRepository, I as methodRegistryPlugin, L as SoftDeleteMethods, M as requireField, N as uniqueField, O as mongoOperationsPlugin, P as validationChainPlugin, R as softDeletePlugin, S as subdocumentPlugin, T as BatchOperationsMethods, V as fieldFilterPlugin, _ as multiTenantPlugin, a as SequentialIdOptions, b as cachePlugin, c as getNextSequence, d as ElasticSearchOptions, f as elasticSearchPlugin, g as MultiTenantOptions, h as observabilityPlugin, i as PrefixedIdOptions, j as immutableField, k as autoInject, l as prefixedId, m as OperationMetric, n as DateSequentialIdOptions, o as customIdPlugin, p as ObservabilityOptions, r as IdGenerator, s as dateSequentialId, t as CustomIdOptions, u as sequentialId, v as cascadePlugin, w as aggregateHelpersPlugin, x as SubdocumentMethods, y as CacheMethods, z as auditLogPlugin } from "../custom-id.plugin-BzZI4gnE.mjs";
-export { type AggregateHelpersMethods, type BatchOperationsMethods, type CacheMethods, type CustomIdOptions, type DateSequentialIdOptions, type ElasticSearchOptions, type IdGenerator, type MethodRegistryRepository, type MongoOperationsMethods, type MultiTenantOptions, type ObservabilityOptions, type OperationMetric, type PrefixedIdOptions, type SequentialIdOptions, type SoftDeleteMethods, type SubdocumentMethods, aggregateHelpersPlugin, auditLogPlugin, autoInject, batchOperationsPlugin, blockIf, cachePlugin, cascadePlugin, customIdPlugin, dateSequentialId, elasticSearchPlugin, fieldFilterPlugin, getNextSequence, immutableField, methodRegistryPlugin, mongoOperationsPlugin, multiTenantPlugin, observabilityPlugin, prefixedId, requireField, sequentialId, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validationChainPlugin };
+import { A as subdocumentPlugin, B as requireField, C as observabilityPlugin, D as CacheMethods, E as cascadePlugin, F as MongoOperationsMethods, G as SoftDeleteMethods, H as validationChainPlugin, I as mongoOperationsPlugin, J as timestampPlugin, K as softDeletePlugin, L as autoInject, M as aggregateHelpersPlugin, N as BatchOperationsMethods, O as cachePlugin, P as batchOperationsPlugin, R as blockIf, S as OperationMetric, T as multiTenantPlugin, U as MethodRegistryRepository, V as uniqueField, W as methodRegistryPlugin, Y as fieldFilterPlugin, _ as AuditTrailMethods, a as SequentialIdOptions, b as auditTrailPlugin, c as getNextSequence, d as ElasticSearchOptions, f as elasticSearchPlugin, g as AuditQueryResult, h as AuditQueryOptions, i as PrefixedIdOptions, j as AggregateHelpersMethods, k as SubdocumentMethods, l as prefixedId, m as AuditOperation, n as DateSequentialIdOptions, o as customIdPlugin, p as AuditEntry, q as auditLogPlugin, r as IdGenerator, s as dateSequentialId, t as CustomIdOptions, u as sequentialId, v as AuditTrailOptions, w as MultiTenantOptions, x as ObservabilityOptions, y as AuditTrailQuery, z as immutableField } from "../custom-id.plugin-BmK0SjR9.mjs";
+export { type AggregateHelpersMethods, type AuditEntry, type AuditOperation, type AuditQueryOptions, type AuditQueryResult, type AuditTrailMethods, type AuditTrailOptions, AuditTrailQuery, type BatchOperationsMethods, type CacheMethods, type CustomIdOptions, type DateSequentialIdOptions, type ElasticSearchOptions, type IdGenerator, type MethodRegistryRepository, type MongoOperationsMethods, type MultiTenantOptions, type ObservabilityOptions, type OperationMetric, type PrefixedIdOptions, type SequentialIdOptions, type SoftDeleteMethods, type SubdocumentMethods, aggregateHelpersPlugin, auditLogPlugin, auditTrailPlugin, autoInject, batchOperationsPlugin, blockIf, cachePlugin, cascadePlugin, customIdPlugin, dateSequentialId, elasticSearchPlugin, fieldFilterPlugin, getNextSequence, immutableField, methodRegistryPlugin, mongoOperationsPlugin, multiTenantPlugin, observabilityPlugin, prefixedId, requireField, sequentialId, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validationChainPlugin };

package/dist/plugins/index.mjs

@@ -1,3 +1,3 @@
-import { C as auditLogPlugin, S as softDeletePlugin, T as fieldFilterPlugin, _ as immutableField, a as sequentialId, b as validationChainPlugin, c as multiTenantPlugin, d as subdocumentPlugin, f as aggregateHelpersPlugin, g as blockIf, h as autoInject, i as prefixedId, l as cascadePlugin, m as mongoOperationsPlugin, n as dateSequentialId, o as elasticSearchPlugin, p as batchOperationsPlugin, r as getNextSequence, s as observabilityPlugin, t as customIdPlugin, u as cachePlugin, v as requireField, w as timestampPlugin, x as methodRegistryPlugin, y as uniqueField } from "../custom-id.plugin-B_zIs6gE.mjs";
+import { C as methodRegistryPlugin, D as fieldFilterPlugin, E as timestampPlugin, S as validationChainPlugin, T as auditLogPlugin, _ as autoInject, a as sequentialId, b as requireField, c as auditTrailPlugin, d as cascadePlugin, f as cachePlugin, g as mongoOperationsPlugin, h as batchOperationsPlugin, i as prefixedId, l as observabilityPlugin, m as aggregateHelpersPlugin, n as dateSequentialId, o as elasticSearchPlugin, p as subdocumentPlugin, r as getNextSequence, s as AuditTrailQuery, t as customIdPlugin, u as multiTenantPlugin, v as blockIf, w as softDeletePlugin, x as uniqueField, y as immutableField } from "../custom-id.plugin-m0VW6yYm.mjs";
 
-export { aggregateHelpersPlugin, auditLogPlugin, autoInject, batchOperationsPlugin, blockIf, cachePlugin, cascadePlugin, customIdPlugin, dateSequentialId, elasticSearchPlugin, fieldFilterPlugin, getNextSequence, immutableField, methodRegistryPlugin, mongoOperationsPlugin, multiTenantPlugin, observabilityPlugin, prefixedId, requireField, sequentialId, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validationChainPlugin };
+export { AuditTrailQuery, aggregateHelpersPlugin, auditLogPlugin, auditTrailPlugin, autoInject, batchOperationsPlugin, blockIf, cachePlugin, cascadePlugin, customIdPlugin, dateSequentialId, elasticSearchPlugin, fieldFilterPlugin, getNextSequence, immutableField, methodRegistryPlugin, mongoOperationsPlugin, multiTenantPlugin, observabilityPlugin, prefixedId, requireField, sequentialId, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validationChainPlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@classytic/mongokit",
-  "version": "3.2.2",
+  "version": "3.2.3",
   "description": "Production-grade MongoDB repositories with zero dependencies - smart pagination, events, and plugins",
   "type": "module",
   "sideEffects": false,
@@ -93,10 +93,10 @@
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
     "typecheck": "tsc --noEmit",
-    "prepublishOnly": "npm run build && npm run typecheck && npm test",
+    "prepublishOnly": "npm run build && npm run typecheck && npm test",
     "publish:dry": "npm publish --dry-run --access public",
     "publish:npm": "npm publish --access public",
-    "release": "npm run build && npm run typecheck && npm test && npm publish --access public",
+    "release": "npm run build && npm run typecheck && npm test && npm publish --access public",
     "release:patch": "npm version patch && npm run release",
     "release:minor": "npm version minor && npm run release",
     "release:major": "npm version major && npm run release"