@classytic/mongokit 3.4.0 → 3.4.2

package/README.md

@@ -17,7 +17,7 @@
 - **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
-- **940+ passing tests** - Battle-tested and production-ready
+- **1090+ passing tests** - Battle-tested and production-ready
 
 ## Installation
 
@@ -25,7 +25,7 @@
 npm install @classytic/mongokit mongoose
 ```
 
-> Supports Mongoose `^9.0.0`
+> Requires Mongoose `^9.0.0` | Node.js `>=22`
 
 ## Quick Start
 
@@ -1059,7 +1059,7 @@ GET /posts?populate[author][populate][department][select]=name  # Nested
 
 **Security features:**
 
-- Blocks `$where`, `$function`, `$accumulator`, `$expr` operators
+- Blocks `$where`, `$function`, `$accumulator` operators (`$expr` allowed for `$lookup` correlation)
 - ReDoS protection for regex patterns
 - Max filter depth enforcement
 - Collection allowlists for lookups
@@ -1377,7 +1377,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 940+ tests pass on Mongoose 9
+- All 1090+ tests pass on Mongoose 9
 
 ## License
 

package/dist/{PaginationEngine-PLyDhrO7.mjs → PaginationEngine-nY04eGUM.mjs}

@@ -1,183 +1,6 @@
 import { a as warn, t as createError } from "./error-Bpbi_NKo.mjs";
-import mongoose from "mongoose";
-//#region src/pagination/utils/cursor.ts
-/**
-* Cursor Utilities
-*
-* Encoding and decoding of cursor tokens for keyset pagination.
-* Cursors are base64-encoded JSON containing position data and metadata.
-*/
-/**
-* Encodes document values and sort metadata into a base64 cursor token
-*
-* @param doc - Document to extract cursor values from
-* @param primaryField - Primary sort field name
-* @param sort - Normalized sort specification
-* @param version - Cursor version for forward compatibility
-* @returns Base64-encoded cursor token
-*/
-function encodeCursor(doc, primaryField, sort, version = 1) {
-	const primaryValue = doc[primaryField];
-	const idValue = doc._id;
-	const payload = {
-		v: serializeValue(primaryValue),
-		t: getValueType(primaryValue),
-		id: serializeValue(idValue),
-		idType: getValueType(idValue),
-		sort,
-		ver: version
-	};
-	return Buffer.from(JSON.stringify(payload)).toString("base64");
-}
-/**
-* Decodes a cursor token back into document values and sort metadata
-*
-* @param token - Base64-encoded cursor token
-* @returns Decoded cursor data
-* @throws Error if token is invalid or malformed
-*/
-function decodeCursor(token) {
-	let json;
-	try {
-		json = Buffer.from(token, "base64").toString("utf-8");
-	} catch {
-		throw new Error("Invalid cursor token: not valid base64");
-	}
-	let payload;
-	try {
-		payload = JSON.parse(json);
-	} catch {
-		throw new Error("Invalid cursor token: not valid JSON");
-	}
-	if (!payload || typeof payload !== "object" || !("v" in payload) || !("t" in payload) || !("id" in payload) || !("idType" in payload) || !payload.sort || typeof payload.sort !== "object" || typeof payload.ver !== "number") throw new Error("Invalid cursor token: malformed payload structure");
-	const VALID_TYPES = [
-		"date",
-		"objectid",
-		"boolean",
-		"number",
-		"string",
-		"null",
-		"unknown"
-	];
-	if (!VALID_TYPES.includes(payload.t) || !VALID_TYPES.includes(payload.idType)) throw new Error("Invalid cursor token: unrecognized value type");
-	try {
-		return {
-			value: rehydrateValue(payload.v, payload.t),
-			id: rehydrateValue(payload.id, payload.idType),
-			sort: payload.sort,
-			version: payload.ver
-		};
-	} catch {
-		throw new Error("Invalid cursor token: failed to rehydrate values");
-	}
-}
-/**
-* Validates that cursor sort matches current query sort
-*
-* @param cursorSort - Sort specification from cursor
-* @param currentSort - Sort specification from query
-* @throws Error if sorts don't match
-*/
-function validateCursorSort(cursorSort, currentSort) {
-	if (JSON.stringify(cursorSort) !== JSON.stringify(currentSort)) throw new Error("Cursor sort does not match current query sort");
-}
-/**
-* Validates cursor version matches expected version
-*
-* @param cursorVersion - Version from cursor
-* @param expectedVersion - Expected version from config
-* @throws Error if versions don't match
-*/
-function validateCursorVersion(cursorVersion, expectedVersion) {
-	if (cursorVersion > expectedVersion) throw new Error(`Cursor version ${cursorVersion} is newer than expected version ${expectedVersion}. Please upgrade.`);
-}
-/**
-* Serializes a value for cursor storage
-*/
-function serializeValue(value) {
-	if (value === null || value === void 0) return null;
-	if (value instanceof Date) return value.toISOString();
-	if (value instanceof mongoose.Types.ObjectId) return value.toString();
-	return value;
-}
-/**
-* Gets the type identifier for a value
-*/
-function getValueType(value) {
-	if (value === null || value === void 0) return "null";
-	if (value instanceof Date) return "date";
-	if (value instanceof mongoose.Types.ObjectId) return "objectid";
-	if (typeof value === "boolean") return "boolean";
-	if (typeof value === "number") return "number";
-	if (typeof value === "string") return "string";
-	return "unknown";
-}
-/**
-* Rehydrates a serialized value back to its original type
-*/
-function rehydrateValue(serialized, type) {
-	if (type === "null" || serialized === null) return null;
-	switch (type) {
-		case "date": return new Date(serialized);
-		case "objectid": return new mongoose.Types.ObjectId(serialized);
-		case "boolean": return serialized === true || serialized === "true";
-		case "number": return Number(serialized);
-		default: return serialized;
-	}
-}
-//#endregion
-//#region src/pagination/utils/filter.ts
-/**
-* Builds MongoDB filter for keyset pagination
-* Creates compound $or condition for proper cursor-based filtering
-*
-* @param baseFilters - Existing query filters
-* @param sort - Normalized sort specification
-* @param cursorValue - Primary field value from cursor
-* @param cursorId - _id value from cursor
-* @returns MongoDB filter with keyset condition
-*
-* @example
-* buildKeysetFilter(
-*   { status: 'active' },
-*   { createdAt: -1, _id: -1 },
-*   new Date('2024-01-01'),
-*   new ObjectId('...')
-* )
-* // Returns:
-* // {
-* //   status: 'active',
-* //   $or: [
-* //     { createdAt: { $lt: Date('2024-01-01') } },
-* //     { createdAt: Date('2024-01-01'), _id: { $lt: ObjectId('...') } }
-* //   ]
-* // }
-*/
-function buildKeysetFilter(baseFilters, sort, cursorValue, cursorId) {
-	const primaryField = Object.keys(sort).find((k) => k !== "_id") || "_id";
-	const direction = sort[primaryField];
-	const operator = direction === 1 ? "$gt" : "$lt";
-	if (cursorValue === null || cursorValue === void 0) if (direction === 1) return {
-		...baseFilters,
-		$or: [{
-			[primaryField]: null,
-			_id: { $gt: cursorId }
-		}, { [primaryField]: { $ne: null } }]
-	};
-	else return {
-		...baseFilters,
-		[primaryField]: null,
-		_id: { $lt: cursorId }
-	};
-	return {
-		...baseFilters,
-		$or: [{ [primaryField]: { [operator]: cursorValue } }, {
-			[primaryField]: cursorValue,
-			_id: { [operator]: cursorId }
-		}]
-	};
-}
-//#endregion
+import { n as encodeCursor, r as resolveCursorFilter } from "./cursor-CHToazHy.mjs";
+import { r as validateKeysetSort, t as getPrimaryField } from "./sort-C-BJEWUZ.mjs";
 //#region src/pagination/utils/limits.ts
 /**
 * Validates and sanitizes limit value
@@ -239,60 +62,29 @@ function calculateTotalPages(total, limit) {
 	return Math.ceil(total / limit);
 }
 //#endregion
-//#region src/pagination/utils/sort.ts
-/**
-* Normalizes sort object to ensure stable key order
-* Primary fields first, _id last (not alphabetical)
-*
-* @param sort - Sort specification
-* @returns Normalized sort with stable key order
-*/
-function normalizeSort(sort) {
-	const normalized = {};
-	Object.keys(sort).forEach((key) => {
-		if (key !== "_id") normalized[key] = sort[key];
-	});
-	if (sort._id !== void 0) normalized._id = sort._id;
-	return normalized;
-}
-/**
-* Validates and normalizes sort for keyset pagination
-* Auto-adds _id tie-breaker if needed
-* Ensures _id direction matches primary field
-*
-* @param sort - Sort specification
-* @returns Validated and normalized sort
-* @throws Error if sort is invalid for keyset pagination
-*/
-function validateKeysetSort(sort) {
-	const keys = Object.keys(sort);
-	if (keys.length === 1 && keys[0] !== "_id") {
-		const field = keys[0];
-		const direction = sort[field];
-		return normalizeSort({
-			[field]: direction,
-			_id: direction
-		});
+//#region src/pagination/PaginationEngine.ts
+function ensureKeysetSelectIncludesCursorFields(select, sort) {
+	if (!select) return select;
+	const requiredFields = new Set([...Object.keys(sort), "_id"]);
+	if (typeof select === "string") {
+		const fields = select.split(/[,\s]+/).map((field) => field.trim()).filter(Boolean);
+		if (fields.length > 0 && fields.every((field) => field.startsWith("-"))) return select;
+		const merged = new Set(fields);
+		for (const field of requiredFields) merged.add(field);
+		return Array.from(merged).join(" ");
 	}
-	if (keys.length === 1 && keys[0] === "_id") return normalizeSort(sort);
-	if (keys.length === 2) {
-		if (!keys.includes("_id")) throw new Error("Keyset pagination requires _id as tie-breaker");
-		if (sort[keys.find((k) => k !== "_id")] !== sort._id) throw new Error("_id direction must match primary field direction");
-		return normalizeSort(sort);
+	if (Array.isArray(select)) {
+		const fields = select.map((field) => field.trim()).filter(Boolean);
+		if (fields.length > 0 && fields.every((field) => field.startsWith("-"))) return select;
+		const merged = new Set(fields);
+		for (const field of requiredFields) merged.add(field);
+		return Array.from(merged);
 	}
-	throw new Error("Keyset pagination only supports single field + _id");
-}
-/**
-* Extracts primary sort field (first non-_id field)
-*
-* @param sort - Sort specification
-* @returns Primary field name
-*/
-function getPrimaryField(sort) {
-	return Object.keys(sort).find((k) => k !== "_id") || "_id";
+	const projection = { ...select };
+	if (!Object.values(projection).some((value) => value === 1)) return select;
+	for (const field of requiredFields) projection[field] = 1;
+	return projection;
 }
-//#endregion
-//#region src/pagination/PaginationEngine.ts
 /**
 * Production-grade pagination engine for MongoDB
 * Supports offset, keyset (cursor), and aggregate pagination
@@ -335,7 +127,7 @@ var PaginationEngine = class {
 	* console.log(result.docs, result.total, result.hasNext);
 	*/
 	async paginate(options = {}) {
-		const { filters = {}, sort = { _id: -1 }, page = 1, limit = this.config.defaultLimit, select, populate = [], lean = true, session, hint, maxTimeMS, countStrategy = "exact", readPreference } = options;
+		const { filters = {}, sort = { _id: -1 }, page = 1, limit = this.config.defaultLimit, select, populate = [], lean = true, session, hint, maxTimeMS, countStrategy = "exact", readPreference, collation } = options;
 		const sanitizedPage = validatePage(page, this.config);
 		const sanitizedLimit = validateLimit(limit, this.config);
 		const skip = calculateSkip(sanitizedPage, sanitizedLimit);
@@ -344,6 +136,7 @@ var PaginationEngine = class {
 		if (select) query = query.select(select);
 		if (populate && (Array.isArray(populate) ? populate.length : populate)) query = query.populate(populate);
 		query = query.sort(sort).skip(skip).limit(fetchLimit).lean(lean);
+		if (collation) query = query.collation(collation);
 		if (session) query = query.session(session);
 		if (hint) query = query.hint(hint);
 		if (maxTimeMS) query = query.maxTimeMS(maxTimeMS);
@@ -351,14 +144,15 @@ var PaginationEngine = class {
 		const hasFilters = Object.keys(filters).length > 0;
 		const useEstimated = this.config.useEstimatedCount && !hasFilters;
 		let countPromise;
-		if (countStrategy === "estimated" || useEstimated && countStrategy !== "exact") countPromise = this.Model.estimatedDocumentCount();
-		else if (countStrategy === "exact") {
+		if ((countStrategy === "estimated" || useEstimated) && !hasFilters) countPromise = this.Model.estimatedDocumentCount();
+		else if (countStrategy === "none") countPromise = Promise.resolve(0);
+		else {
 			const countQuery = this.Model.countDocuments(filters).session(session ?? null);
 			if (hint) countQuery.hint(hint);
 			if (maxTimeMS) countQuery.maxTimeMS(maxTimeMS);
 			if (readPreference) countQuery.read(readPreference);
 			countPromise = countQuery.exec();
-		} else countPromise = Promise.resolve(0);
+		}
 		const [docs, total] = await Promise.all([query.exec(), countPromise]);
 		const totalPages = countStrategy === "none" ? 0 : calculateTotalPages(total, sanitizedLimit);
 		let hasNext;
@@ -402,7 +196,7 @@ var PaginationEngine = class {
 	* });
 	*/
 	async stream(options) {
-		const { filters = {}, sort, after, limit = this.config.defaultLimit, select, populate = [], lean = true, session, hint, maxTimeMS, readPreference } = options;
+		const { filters = {}, sort, after, limit = this.config.defaultLimit, select, populate = [], lean = true, session, hint, maxTimeMS, readPreference, collation } = options;
 		if (!sort) throw createError(400, "sort is required for keyset pagination");
 		const sanitizedLimit = validateLimit(limit, this.config);
 		const normalizedSort = validateKeysetSort(sort);
@@ -413,16 +207,13 @@ var PaginationEngine = class {
 			warn(`[mongokit] Keyset pagination with filters [${filterKeys.join(", ")}] and sort [${sortFields.join(", ")}] requires a compound index for O(1) performance. Ensure index exists: { ${indexFields.join(", ")} }`);
 		}
 		let query = { ...filters };
-		if (after) {
-			const cursor = decodeCursor(after);
-			validateCursorVersion(cursor.version, this.config.cursorVersion);
-			validateCursorSort(cursor.sort, normalizedSort);
-			query = buildKeysetFilter(query, normalizedSort, cursor.value, cursor.id);
-		}
+		if (after) query = resolveCursorFilter(after, normalizedSort, this.config.cursorVersion, query);
+		const effectiveSelect = ensureKeysetSelectIncludesCursorFields(select, normalizedSort);
 		let mongoQuery = this.Model.find(query);
-		if (select) mongoQuery = mongoQuery.select(select);
+		if (effectiveSelect) mongoQuery = mongoQuery.select(effectiveSelect);
 		if (populate && (Array.isArray(populate) ? populate.length : populate)) mongoQuery = mongoQuery.populate(populate);
 		mongoQuery = mongoQuery.sort(normalizedSort).limit(sanitizedLimit + 1).lean(lean);
+		if (collation) mongoQuery = mongoQuery.collation(collation);
 		if (session) mongoQuery = mongoQuery.session(session);
 		if (hint) mongoQuery = mongoQuery.hint(hint);
 		if (maxTimeMS) mongoQuery = mongoQuery.maxTimeMS(maxTimeMS);

package/dist/actions/index.d.mts

@@ -1,2 +1,2 @@
-import { a as create_d_exports, i as delete_d_exports, n as update_d_exports, o as aggregate_d_exports, r as read_d_exports } from "../index-Df3ernpC.mjs";
+import { a as create_d_exports, i as delete_d_exports, n as update_d_exports, o as aggregate_d_exports, r as read_d_exports } from "../index-BuoZIZ15.mjs";
 export { aggregate_d_exports as aggregate, create_d_exports as create, delete_d_exports as deleteActions, read_d_exports as read, update_d_exports as update };

package/dist/actions/index.mjs

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "../chunk-CfYAbeIz.mjs";
-import { c as read_exports, h as aggregate_exports, n as update_exports, p as create_exports, u as delete_exports } from "../update-DXwVh6M1.mjs";
+import { c as read_exports, h as aggregate_exports, n as update_exports, p as create_exports, u as delete_exports } from "../update-DGKMmBgG.mjs";
 //#region src/actions/index.ts
 var actions_exports = /* @__PURE__ */ __exportAll({
 	aggregate: () => aggregate_exports,

package/dist/ai/index.d.mts

@@ -1,4 +1,4 @@
-import { H as Plugin } from "../types-BlCwDszq.mjs";
+import { U as Plugin } from "../types-COINbsdL.mjs";
 import { ClientSession, PipelineStage } from "mongoose";
 
 //#region src/ai/types.d.ts

package/dist/ai/index.mjs

@@ -175,9 +175,10 @@ function vectorPlugin(options) {
 				});
 				repo.on("before:update", async (context) => {
 					if (!context.data) return;
+					const contextData = context.data;
 					const fieldsToEmbed = fields.filter((field) => {
 						const allFields = [...field.sourceFields ?? [], ...field.mediaFields ?? []];
-						return allFields.length > 0 && allFields.some((f) => f in context.data);
+						return allFields.length > 0 && contextData && allFields.some((f) => f in contextData);
 					});
 					if (!fieldsToEmbed.length) return;
 					const existing = await repo.Model.findById(context.id).lean().session(context.session ?? null);

package/dist/cursor-CHToazHy.mjs

@@ -0,0 +1,250 @@
+import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
+import mongoose from "mongoose";
+//#region src/pagination/utils/filter.ts
+/**
+* Builds MongoDB filter for keyset pagination
+* Creates compound $or condition for proper cursor-based filtering
+*
+* @param baseFilters - Existing query filters
+* @param sort - Normalized sort specification
+* @param cursorValue - Primary field value from cursor
+* @param cursorId - _id value from cursor
+* @returns MongoDB filter with keyset condition
+*
+* @example
+* buildKeysetFilter(
+*   { status: 'active' },
+*   { createdAt: -1, _id: -1 },
+*   new Date('2024-01-01'),
+*   new ObjectId('...')
+* )
+* // Returns:
+* // {
+* //   status: 'active',
+* //   $or: [
+* //     { createdAt: { $lt: Date('2024-01-01') } },
+* //     { createdAt: Date('2024-01-01'), _id: { $lt: ObjectId('...') } }
+* //   ]
+* // }
+*/
+function buildKeysetFilter(baseFilters, sort, cursorValue, cursorId, cursorValues) {
+	const sortFields = Object.keys(sort).filter((k) => k !== "_id");
+	if (sortFields.length <= 1 && !cursorValues) {
+		const primaryField = sortFields[0] || "_id";
+		const direction = sort[primaryField];
+		const operator = direction === 1 ? "$gt" : "$lt";
+		if (cursorValue === null || cursorValue === void 0) if (direction === 1) return {
+			...baseFilters,
+			$or: [{
+				[primaryField]: null,
+				_id: { $gt: cursorId }
+			}, { [primaryField]: { $ne: null } }]
+		};
+		else return {
+			...baseFilters,
+			[primaryField]: null,
+			_id: { $lt: cursorId }
+		};
+		return {
+			...baseFilters,
+			$or: [{ [primaryField]: { [operator]: cursorValue } }, {
+				[primaryField]: cursorValue,
+				_id: { [operator]: cursorId }
+			}]
+		};
+	}
+	const values = cursorValues || { [sortFields[0]]: cursorValue };
+	const allFields = [...sortFields, "_id"];
+	const allValues = {
+		...values,
+		_id: cursorId
+	};
+	const orConditions = [];
+	for (let i = 0; i < allFields.length; i++) {
+		const field = allFields[i];
+		const operator = (sort[field] ?? sort[sortFields[0]]) === 1 ? "$gt" : "$lt";
+		const condition = {};
+		for (let j = 0; j < i; j++) condition[allFields[j]] = allValues[allFields[j]];
+		condition[field] = { [operator]: allValues[field] };
+		orConditions.push(condition);
+	}
+	return {
+		...baseFilters,
+		$or: orConditions
+	};
+}
+//#endregion
+//#region src/pagination/utils/cursor.ts
+/**
+* Cursor Utilities
+*
+* Encoding and decoding of cursor tokens for keyset pagination.
+* Cursors are base64-encoded JSON containing position data and metadata.
+*/
+var cursor_exports = /* @__PURE__ */ __exportAll({
+	decodeCursor: () => decodeCursor,
+	encodeCursor: () => encodeCursor,
+	resolveCursorFilter: () => resolveCursorFilter,
+	validateCursorSort: () => validateCursorSort,
+	validateCursorVersion: () => validateCursorVersion
+});
+/**
+* Encodes document values and sort metadata into a base64 cursor token
+*
+* @param doc - Document to extract cursor values from
+* @param primaryField - Primary sort field name
+* @param sort - Normalized sort specification
+* @param version - Cursor version for forward compatibility
+* @returns Base64-encoded cursor token
+*/
+function encodeCursor(doc, primaryField, sort, version = 1) {
+	const primaryValue = doc[primaryField];
+	const idValue = doc._id;
+	const sortFields = Object.keys(sort).filter((k) => k !== "_id");
+	const vals = {};
+	const types = {};
+	for (const field of sortFields) {
+		vals[field] = serializeValue(doc[field]);
+		types[field] = getValueType(doc[field]);
+	}
+	const payload = {
+		v: serializeValue(primaryValue),
+		t: getValueType(primaryValue),
+		id: serializeValue(idValue),
+		idType: getValueType(idValue),
+		sort,
+		ver: version,
+		...sortFields.length > 1 && {
+			vals,
+			types
+		}
+	};
+	return Buffer.from(JSON.stringify(payload)).toString("base64");
+}
+/**
+* Decodes a cursor token back into document values and sort metadata
+*
+* @param token - Base64-encoded cursor token
+* @returns Decoded cursor data
+* @throws Error if token is invalid or malformed
+*/
+function decodeCursor(token) {
+	let json;
+	try {
+		json = Buffer.from(token, "base64").toString("utf-8");
+	} catch {
+		throw new Error("Invalid cursor token: not valid base64");
+	}
+	let payload;
+	try {
+		payload = JSON.parse(json);
+	} catch {
+		throw new Error("Invalid cursor token: not valid JSON");
+	}
+	if (!payload || typeof payload !== "object" || !("v" in payload) || !("t" in payload) || !("id" in payload) || !("idType" in payload) || !payload.sort || typeof payload.sort !== "object" || typeof payload.ver !== "number") throw new Error("Invalid cursor token: malformed payload structure");
+	const VALID_TYPES = [
+		"date",
+		"objectid",
+		"boolean",
+		"number",
+		"string",
+		"null",
+		"unknown"
+	];
+	if (!VALID_TYPES.includes(payload.t) || !VALID_TYPES.includes(payload.idType)) throw new Error("Invalid cursor token: unrecognized value type");
+	try {
+		let values;
+		if (payload.vals && payload.types) {
+			values = {};
+			for (const [field, serialized] of Object.entries(payload.vals)) values[field] = rehydrateValue(serialized, payload.types[field]);
+		}
+		return {
+			value: rehydrateValue(payload.v, payload.t),
+			id: rehydrateValue(payload.id, payload.idType),
+			sort: payload.sort,
+			version: payload.ver,
+			...values && { values }
+		};
+	} catch {
+		throw new Error("Invalid cursor token: failed to rehydrate values");
+	}
+}
+/**
+* Validates that cursor sort matches current query sort
+*
+* @param cursorSort - Sort specification from cursor
+* @param currentSort - Sort specification from query
+* @throws Error if sorts don't match
+*/
+function validateCursorSort(cursorSort, currentSort) {
+	if (JSON.stringify(cursorSort) !== JSON.stringify(currentSort)) throw new Error("Cursor sort does not match current query sort");
+}
+/**
+* Validates cursor version matches expected version
+*
+* @param cursorVersion - Version from cursor
+* @param expectedVersion - Expected version from config
+* @throws Error if versions don't match
+*/
+function validateCursorVersion(cursorVersion, expectedVersion) {
+	if (cursorVersion > expectedVersion) throw new Error(`Cursor version ${cursorVersion} is newer than expected version ${expectedVersion}. Please upgrade.`);
+}
+/**
+* Serializes a value for cursor storage
+*/
+function serializeValue(value) {
+	if (value === null || value === void 0) return null;
+	if (value instanceof Date) return value.toISOString();
+	if (value instanceof mongoose.Types.ObjectId) return value.toString();
+	return value;
+}
+/**
+* Gets the type identifier for a value
+*/
+function getValueType(value) {
+	if (value === null || value === void 0) return "null";
+	if (value instanceof Date) return "date";
+	if (value instanceof mongoose.Types.ObjectId) return "objectid";
+	if (typeof value === "boolean") return "boolean";
+	if (typeof value === "number") return "number";
+	if (typeof value === "string") return "string";
+	return "unknown";
+}
+/**
+* Rehydrates a serialized value back to its original type
+*/
+function rehydrateValue(serialized, type) {
+	if (type === "null" || serialized === null) return null;
+	switch (type) {
+		case "date": return new Date(serialized);
+		case "objectid": return new mongoose.Types.ObjectId(serialized);
+		case "boolean": return serialized === true || serialized === "true";
+		case "number": return Number(serialized);
+		default: return serialized;
+	}
+}
+/**
+* Resolves cursor token into MongoDB query filters.
+* Shared by PaginationEngine.stream() and Repository.lookupPopulate() keyset path.
+*
+* Handles:
+* - Plain 24-char hex ObjectId strings (fallback cursor)
+* - Base64-encoded cursor tokens (standard cursor)
+* - Cursor version and sort validation
+*/
+function resolveCursorFilter(after, sort, cursorVersion, baseFilters = {}) {
+	if (/^[a-f0-9]{24}$/i.test(after)) {
+		const objectId = new mongoose.Types.ObjectId(after);
+		const idOperator = (sort._id || -1) === 1 ? "$gt" : "$lt";
+		return {
+			...baseFilters,
+			_id: { [idOperator]: objectId }
+		};
+	}
+	const cursor = decodeCursor(after);
+	validateCursorVersion(cursor.version, cursorVersion);
+	validateCursorSort(cursor.sort, sort);
+	return buildKeysetFilter(baseFilters, sort, cursor.value, cursor.id, cursor.values);
+}
+//#endregion
+export { encodeCursor as n, resolveCursorFilter as r, cursor_exports as t };

package/dist/{index-Df3ernpC.d.mts → index-BuoZIZ15.d.mts}

@@ -1,4 +1,4 @@
-import { C as GroupResult, F as ObjectId, G as PopulateSpec, K as ReadPreferenceType, N as MinMaxResult, R as OperationOptions, St as LookupOptions, _ as DeleteResult, at as SortSpec, ct as UpdateManyResult, et as SelectSpec, i as AnyDocument, lt as UpdateOptions, p as CreateOptions, ut as UpdateWithValidationResult } from "./types-BlCwDszq.mjs";
+import { Ct as LookupOptions, I as ObjectId, K as PopulateSpec, P as MinMaxResult, dt as UpdateWithValidationResult, i as AnyDocument, lt as UpdateManyResult, m as CreateOptions, ot as SortSpec, q as ReadPreferenceType, tt as SelectSpec, ut as UpdateOptions, v as DeleteResult, w as GroupResult, z as OperationOptions } from "./types-COINbsdL.mjs";
 import { ClientSession, Model, PipelineStage } from "mongoose";
 
 //#region src/actions/aggregate.d.ts