@classytic/mongokit 3.39.0 → 3.40.0

package/dist/{PaginationEngine-DQ7beTCR.mjs → PaginationEngine-Dvl8jcRY.mjs}

@@ -602,6 +602,20 @@ function classifyFilterFields(filters) {
 	};
 }
 /**
+* The ESR index to recommend for a keyset query: equality → sort (incl. the `_id`
+* tiebreaker) → range, each field ONCE. A filtered field that is also a sort key
+* takes its sort position — Mongo rejects an index naming a key twice.
+*/
+function recommendKeysetIndex(filters, sort) {
+	const { equality, range } = classifyFilterFields(filters);
+	const notSorted = (f) => !Object.hasOwn(sort, f);
+	return [
+		...equality.filter(notSorted).map((f) => [f, 1]),
+		...Object.entries(sort),
+		...range.filter(notSorted).map((f) => [f, 1])
+	];
+}
+/**
 * Read a Mongoose schema's declared indexes, defensively.
 * Returns an empty array on any introspection failure.
 */
@@ -641,8 +655,9 @@ function readSchemaIndexes(Model) {
 function hasCompatibleKeysetIndex(indexes, filterFields, sort) {
 	const sortKeys = Object.keys(sort);
 	if (sortKeys.length === 0) return true;
-	const filterSet = new Set(filterFields);
-	const prefixLen = filterFields.length;
+	const prefixFields = filterFields.filter((f) => !Object.hasOwn(sort, f));
+	const filterSet = new Set(prefixFields);
+	const prefixLen = prefixFields.length;
 	for (const [spec] of indexes) {
 		if (!spec || typeof spec !== "object") continue;
 		const entries = Object.entries(spec);
@@ -909,9 +924,9 @@ var PaginationEngine = class {
 		if (readPreference) query = query.read(readPreference);
 		const hasFilters = Object.keys(filters).length > 0;
 		const useEstimated = this.config.useEstimatedCount && !hasFilters;
-		let countPromise;
-		if ((countStrategy === "estimated" || useEstimated) && !hasFilters) countPromise = this.Model.estimatedDocumentCount();
-		else if (countStrategy === "none") countPromise = Promise.resolve(0);
+		let runCount;
+		if ((countStrategy === "estimated" || useEstimated) && !hasFilters && !session) runCount = () => Promise.resolve(this.Model.estimatedDocumentCount());
+		else if (countStrategy === "none") runCount = () => Promise.resolve(0);
 		else if (countStrategy === "capped") {
 			/**
 			* `.limit(n)` on a count is MongoDB's own ceiling — the server stops
@@ -921,19 +936,21 @@ var PaginationEngine = class {
 			*/
 			const cappedTarget = countFilters ?? filters;
 			const cappedQuery = this.Model.countDocuments(cappedTarget).limit(resolveCountLimit(countLimit)).session(session ?? null);
+			if (collation) cappedQuery.collation(collation);
 			if (hint) cappedQuery.hint(hint);
 			if (maxTimeMS) cappedQuery.maxTimeMS(maxTimeMS);
 			if (readPreference) cappedQuery.read(readPreference);
-			countPromise = cappedQuery.exec();
+			runCount = () => cappedQuery.exec();
 		} else {
 			const countTarget = countFilters ?? filters;
 			const countQuery = this.Model.countDocuments(countTarget).session(session ?? null);
+			if (collation) countQuery.collation(collation);
 			if (hint) countQuery.hint(hint);
 			if (maxTimeMS) countQuery.maxTimeMS(maxTimeMS);
 			if (readPreference) countQuery.read(readPreference);
-			countPromise = countQuery.exec();
+			runCount = () => countQuery.exec();
 		}
-		const [data, total] = await Promise.all([query.exec(), countPromise]);
+		const [data, total] = session ? [await query.exec(), await runCount()] : await Promise.all([query.exec(), runCount()]);
 		const totalPages = countStrategy === "none" ? 0 : calculateTotalPages(total, sanitizedLimit);
 		/**
 		* A capped count that came back AT its ceiling is a floor, not a total.
@@ -1025,13 +1042,9 @@ var PaginationEngine = class {
 		const effectiveSortFields = sortFieldsForMessage(normalizedSort);
 		if (process.env.NODE_ENV !== "test" && filterKeys.length > 0 && effectiveSortFields.length > 0) {
 			const indexes = this._getSchemaIndexes();
-			const { equality, range } = classifyFilterFields(filters);
+			const { equality } = classifyFilterFields(filters);
 			if (!(hasCompatibleKeysetIndex(indexes, filterKeys, normalizedSort) || equality.length !== filterKeys.length && hasCompatibleKeysetIndex(indexes, equality, normalizedSort))) {
-				const indexFields = [
-					...equality.map((f) => `${f}: 1`),
-					...Object.keys(normalizedSort).map((f) => `${f}: ${normalizedSort[f]}`),
-					...range.map((f) => `${f}: 1`)
-				];
+				const indexFields = recommendKeysetIndex(filters, normalizedSort).map(([f, dir]) => `${f}: ${dir}`);
 				warn(`[mongokit] Keyset pagination with filters [${filterKeys.join(", ")}] and sort [${effectiveSortFields.join(", ")}] has no matching schema-declared compound index. Without one, the tiebreaker forces a BLOCKING SORT over every matching row, on every page. Declare: { ${indexFields.join(", ")} }. (Collection-level indexes created outside the schema are not visible here.)`);
 			}
 		}
@@ -1084,7 +1097,8 @@ var PaginationEngine = class {
 			hasMore,
 			next: hasMore ? mint(data[data.length - 1]) : null,
 			prev: hasPrev ? mint(data[0]) : null,
-			hasPrev
+			hasPrev,
+			end: mint(data[data.length - 1])
 		};
 	}
 	/**
@@ -1149,11 +1163,13 @@ var PaginationEngine = class {
 			{ $limit: resolveCountLimit(countLimit) },
 			{ $count: "count" }
 		] : [...pipeline, { $count: "count" }];
-		const [dataRows, countRows] = await Promise.all([run([
+		const runData = () => run([
 			...pipeline,
 			{ $skip: skip },
 			{ $limit: fetchLimit }
-		]), countStrategy === "none" ? Promise.resolve([]) : run(countStages)]);
+		]);
+		const runCount = () => countStrategy === "none" ? Promise.resolve([]) : run(countStages);
+		const [dataRows, countRows] = session ? [await runData(), await runCount()] : await Promise.all([runData(), runCount()]);
 		const data = dataRows;
 		const total = countRows[0]?.count || 0;
 		const totalPages = countStrategy === "none" ? 0 : calculateTotalPages(total, sanitizedLimit);