@classytic/mongokit 3.3.2 → 3.4.1

package/dist/{limits-s1-d8rWb.mjs → cursor-CHToazHy.mjs}

@@ -1,12 +1,93 @@
+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
 *
@@ -19,13 +100,24 @@ import mongoose from "mongoose";
 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
+		ver: version,
+		...sortFields.length > 1 && {
+			vals,
+			types
+		}
 	};
 	return Buffer.from(JSON.stringify(payload)).toString("base64");
 }
@@ -61,11 +153,17 @@ function decodeCursor(token) {
 	];
 	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
+			version: payload.ver,
+			...values && { values }
 		};
 	} catch {
 		throw new Error("Invalid cursor token: failed to rehydrate values");
@@ -125,175 +223,28 @@ function rehydrateValue(serialized, type) {
 		default: return serialized;
 	}
 }
-
-//#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
+* Resolves cursor token into MongoDB query filters.
+* Shared by PaginationEngine.stream() and Repository.lookupPopulate() keyset path.
 *
-* @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
-		});
-	}
-	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);
+* 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 }
+		};
 	}
-	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";
-}
-
-//#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
-//#region src/pagination/utils/limits.ts
-/**
-* Validates and sanitizes limit value
-* Parses strings to numbers and prevents NaN bugs
-*
-* @param limit - Requested limit
-* @param config - Pagination configuration
-* @returns Sanitized limit between 1 and maxLimit
-*/
-function validateLimit(limit, config) {
-	const parsed = Number(limit);
-	if (!Number.isFinite(parsed) || parsed < 1) return config.defaultLimit || 10;
-	return Math.min(Math.floor(parsed), config.maxLimit || 100);
-}
-/**
-* Validates and sanitizes page number
-* Parses strings to numbers and prevents NaN bugs
-*
-* @param page - Requested page (1-indexed)
-* @param config - Pagination configuration
-* @returns Sanitized page number >= 1
-* @throws Error if page exceeds maxPage
-*/
-function validatePage(page, config) {
-	const parsed = Number(page);
-	if (!Number.isFinite(parsed) || parsed < 1) return 1;
-	const sanitized = Math.floor(parsed);
-	if (sanitized > (config.maxPage || 1e4)) throw new Error(`Page ${sanitized} exceeds maximum ${config.maxPage || 1e4}`);
-	return sanitized;
-}
-/**
-* Checks if page number should trigger deep pagination warning
-*
-* @param page - Current page number
-* @param threshold - Warning threshold
-* @returns True if warning should be shown
-*/
-function shouldWarnDeepPagination(page, threshold) {
-	return page > threshold;
-}
-/**
-* Calculates number of documents to skip for offset pagination
-*
-* @param page - Page number (1-indexed)
-* @param limit - Documents per page
-* @returns Number of documents to skip
-*/
-function calculateSkip(page, limit) {
-	return (page - 1) * limit;
-}
-/**
-* Calculates total number of pages
-*
-* @param total - Total document count
-* @param limit - Documents per page
-* @returns Total number of pages
-*/
-function calculateTotalPages(total, limit) {
-	return Math.ceil(total / limit);
+	const cursor = decodeCursor(after);
+	validateCursorVersion(cursor.version, cursorVersion);
+	validateCursorSort(cursor.sort, sort);
+	return buildKeysetFilter(baseFilters, sort, cursor.value, cursor.id, cursor.values);
 }
-
 //#endregion
-export { validatePage as a, validateKeysetSort as c, validateCursorSort as d, validateCursorVersion as f, validateLimit as i, decodeCursor as l, calculateTotalPages as n, buildKeysetFilter as o, shouldWarnDeepPagination as r, getPrimaryField as s, calculateSkip as t, encodeCursor as u };
+export { encodeCursor as n, resolveCursorFilter as r, cursor_exports as t };

package/dist/{logger-D8ily-PP.mjs → error-Bpbi_NKo.mjs}

@@ -1,23 +1,3 @@
-//#region src/utils/error.ts
-/**
-* Creates an error with HTTP status code
-*
-* @param status - HTTP status code
-* @param message - Error message
-* @returns Error with status property
-* 
-* @example
-* throw createError(404, 'Document not found');
-* throw createError(400, 'Invalid input');
-* throw createError(403, 'Access denied');
-*/
-function createError(status, message) {
-	const error = new Error(message);
-	error.status = status;
-	return error;
-}
-
-//#endregion
 //#region src/utils/logger.ts
 const noop = () => {};
 let current = {
@@ -46,6 +26,38 @@ function warn(message, ...args) {
 function debug(message, ...args) {
 	current.debug(message, ...args);
 }
-
 //#endregion
-export { createError as i, debug as n, warn as r, configureLogger as t };
+//#region src/utils/error.ts
+/**
+* Creates an error with HTTP status code
+*
+* @param status - HTTP status code
+* @param message - Error message
+* @returns Error with status property
+*
+* @example
+* throw createError(404, 'Document not found');
+* throw createError(400, 'Invalid input');
+* throw createError(403, 'Access denied');
+*/
+function createError(status, message) {
+	const error = new Error(message);
+	error.status = status;
+	return error;
+}
+/**
+* Detect and convert a MongoDB E11000 duplicate-key error into
+* a 409 HttpError with an actionable message.
+*
+* Returns `null` when the error is not a duplicate-key error.
+*/
+function parseDuplicateKeyError(error) {
+	if (!error || typeof error !== "object") return null;
+	const mongoErr = error;
+	if (mongoErr.code !== 11e3) return null;
+	const fields = mongoErr.keyPattern ? Object.keys(mongoErr.keyPattern) : [];
+	const values = mongoErr.keyValue ? Object.entries(mongoErr.keyValue).map(([k, v]) => `${k}: ${JSON.stringify(v)}`).join(", ") : "";
+	return createError(409, fields.length ? `Duplicate value for ${fields.join(", ")}${values ? ` (${values})` : ""}` : "Duplicate key error");
+}
+//#endregion
+export { warn as a, debug as i, parseDuplicateKeyError as n, configureLogger as r, createError as t };

package/dist/{cache-keys-CzFwVnLy.mjs → field-selection-reyDRzXf.mjs}

@@ -1,102 +1,3 @@
-//#region src/utils/field-selection.ts
-/**
-* Get allowed fields for a user based on their context
-*
-* @param user - User object from request.user (or null for public)
-* @param preset - Field preset configuration
-* @returns Array of allowed field names
-* 
-* @example
-* const fields = getFieldsForUser(request.user, {
-*   public: ['id', 'name', 'price'],
-*   authenticated: ['description', 'features'],
-*   admin: ['createdAt', 'internalNotes']
-* });
-*/
-function getFieldsForUser(user, preset) {
-	if (!preset) throw new Error("Field preset is required");
-	const fields = [...preset.public || []];
-	if (user) {
-		fields.push(...preset.authenticated || []);
-		const roles = Array.isArray(user.roles) ? user.roles : user.roles ? [user.roles] : [];
-		if (roles.includes("admin") || roles.includes("superadmin")) fields.push(...preset.admin || []);
-	}
-	return [...new Set(fields)];
-}
-/**
-* Get Mongoose projection string for query .select()
-*
-* @param user - User object from request.user
-* @param preset - Field preset configuration
-* @returns Space-separated field names for Mongoose .select()
-*
-* @example
-* const projection = getMongooseProjection(request.user, fieldPresets.gymPlans);
-* const plans = await GymPlan.find({ organizationId }).select(projection).lean();
-*/
-function getMongooseProjection(user, preset) {
-	return getFieldsForUser(user, preset).join(" ");
-}
-/**
-* Filter a single object to include only allowed fields
-*/
-function filterObject(obj, allowedFields) {
-	if (!obj || typeof obj !== "object" || Array.isArray(obj)) return obj;
-	const filtered = {};
-	for (const field of allowedFields) if (field in obj) filtered[field] = obj[field];
-	return filtered;
-}
-/**
-* Filter response data to include only allowed fields
-*
-* Use this for complex responses where Mongoose projections aren't applicable:
-* - Aggregation pipeline results
-* - Data from multiple sources
-* - Custom computed fields
-*
-* For simple DB queries, prefer getMongooseProjection() (10x faster)
-*
-* @param data - Data to filter
-* @param preset - Field preset configuration
-* @param user - User object from request.user
-* @returns Filtered data
-*
-* @example
-* const stats = await calculateComplexStats();
-* const filtered = filterResponseData(stats, fieldPresets.dashboard, request.user);
-* return reply.send(filtered);
-*/
-function filterResponseData(data, preset, user = null) {
-	const allowedFields = getFieldsForUser(user, preset);
-	if (Array.isArray(data)) return data.map((item) => filterObject(item, allowedFields));
-	return filterObject(data, allowedFields);
-}
-/**
-* Helper to create field presets (module-level)
-*
-* Each module should define its own field preset in its own directory.
-* This keeps modules independent and self-contained.
-*
-* @param config - Field configuration
-* @returns Field preset
-*
-* @example
-* // In modules/gym-plan/gym-plan.fields.ts
-* export const gymPlanFieldPreset = createFieldPreset({
-*   public: ['id', 'name', 'price'],
-*   authenticated: ['features', 'description'],
-*   admin: ['createdAt', 'updatedAt', 'internalNotes']
-* });
-*/
-function createFieldPreset(config) {
-	return {
-		public: config.public || [],
-		authenticated: config.authenticated || [],
-		admin: config.admin || []
-	};
-}
-
-//#endregion
 //#region src/utils/cache-keys.ts
 /**
 * Simple hash function for query parameters
@@ -114,8 +15,8 @@ function hashString(str) {
 function stableStringify(obj) {
 	if (obj === null || obj === void 0) return "";
 	if (typeof obj !== "object") return String(obj);
-	if (Array.isArray(obj)) return "[" + obj.map(stableStringify).join(",") + "]";
-	return "{" + Object.keys(obj).sort().map((key) => `${key}:${stableStringify(obj[key])}`).join(",") + "}";
+	if (Array.isArray(obj)) return `[${obj.map(stableStringify).join(",")}]`;
+	return `{${Object.keys(obj).sort().map((key) => `${key}:${stableStringify(obj[key])}`).join(",")}}`;
 }
 /**
 * Generate cache key for getById operations
@@ -143,9 +44,9 @@ function byIdKey(prefix, model, id, options) {
 }
 /**
 * Generate cache key for single-document queries
-* 
+*
 * Format: {prefix}:one:{model}:{queryHash}
-* 
+*
 * @example
 * byQueryKey('mk', 'User', { email: 'john@example.com' })
 * // => 'mk:one:User:a1b2c3d4'
@@ -159,13 +60,13 @@ function byQueryKey(prefix, model, version, query, options) {
 }
 /**
 * Generate cache key for paginated list queries
-* 
+*
 * Format: {prefix}:list:{model}:{version}:{queryHash}
-* 
+*
 * The version component enables efficient bulk invalidation:
 * - On any mutation, bump the version
 * - All list cache keys become invalid without scanning/deleting each
-* 
+*
 * @example
 * listQueryKey('mk', 'User', 1, { filters: { status: 'active' }, page: 1, limit: 20 })
 * // => 'mk:list:User:1:e5f6g7h8'
@@ -190,9 +91,9 @@ function listQueryKey(prefix, model, version, params) {
 }
 /**
 * Generate cache key for collection version tag
-* 
+*
 * Format: {prefix}:ver:{model}
-* 
+*
 * Used to track mutation version for list invalidation
 */
 function versionKey(prefix, model) {
@@ -200,9 +101,9 @@ function versionKey(prefix, model) {
 }
 /**
 * Generate pattern for clearing all cache keys for a model
-* 
+*
 * Format: {prefix}:*:{model}:*
-* 
+*
 * @example
 * modelPattern('mk', 'User')
 * // => 'mk:*:User:*'
@@ -218,6 +119,103 @@ function modelPattern(prefix, model) {
 function listPattern(prefix, model) {
 	return `${prefix}:list:${model}:*`;
 }
-
 //#endregion
-export { modelPattern as a, filterResponseData as c, listQueryKey as i, getFieldsForUser as l, byQueryKey as n, versionKey as o, listPattern as r, createFieldPreset as s, byIdKey as t, getMongooseProjection as u };
+//#region src/utils/field-selection.ts
+/**
+* Get allowed fields for a user based on their context
+*
+* @param user - User object from request.user (or null for public)
+* @param preset - Field preset configuration
+* @returns Array of allowed field names
+*
+* @example
+* const fields = getFieldsForUser(request.user, {
+*   public: ['id', 'name', 'price'],
+*   authenticated: ['description', 'features'],
+*   admin: ['createdAt', 'internalNotes']
+* });
+*/
+function getFieldsForUser(user, preset) {
+	if (!preset) throw new Error("Field preset is required");
+	const fields = [...preset.public || []];
+	if (user) {
+		fields.push(...preset.authenticated || []);
+		const roles = Array.isArray(user.roles) ? user.roles : user.roles ? [user.roles] : [];
+		if (roles.includes("admin") || roles.includes("superadmin")) fields.push(...preset.admin || []);
+	}
+	return [...new Set(fields)];
+}
+/**
+* Get Mongoose projection string for query .select()
+*
+* @param user - User object from request.user
+* @param preset - Field preset configuration
+* @returns Space-separated field names for Mongoose .select()
+*
+* @example
+* const projection = getMongooseProjection(request.user, fieldPresets.gymPlans);
+* const plans = await GymPlan.find({ organizationId }).select(projection).lean();
+*/
+function getMongooseProjection(user, preset) {
+	return getFieldsForUser(user, preset).join(" ");
+}
+/**
+* Filter a single object to include only allowed fields
+*/
+function filterObject(obj, allowedFields) {
+	if (!obj || typeof obj !== "object" || Array.isArray(obj)) return obj;
+	const filtered = {};
+	for (const field of allowedFields) if (field in obj) filtered[field] = obj[field];
+	return filtered;
+}
+/**
+* Filter response data to include only allowed fields
+*
+* Use this for complex responses where Mongoose projections aren't applicable:
+* - Aggregation pipeline results
+* - Data from multiple sources
+* - Custom computed fields
+*
+* For simple DB queries, prefer getMongooseProjection() (10x faster)
+*
+* @param data - Data to filter
+* @param preset - Field preset configuration
+* @param user - User object from request.user
+* @returns Filtered data
+*
+* @example
+* const stats = await calculateComplexStats();
+* const filtered = filterResponseData(stats, fieldPresets.dashboard, request.user);
+* return reply.send(filtered);
+*/
+function filterResponseData(data, preset, user = null) {
+	const allowedFields = getFieldsForUser(user, preset);
+	if (Array.isArray(data)) return data.map((item) => filterObject(item, allowedFields));
+	return filterObject(data, allowedFields);
+}
+/**
+* Helper to create field presets (module-level)
+*
+* Each module should define its own field preset in its own directory.
+* This keeps modules independent and self-contained.
+*
+* @param config - Field configuration
+* @returns Field preset
+*
+* @example
+* // In modules/gym-plan/gym-plan.fields.ts
+* export const gymPlanFieldPreset = createFieldPreset({
+*   public: ['id', 'name', 'price'],
+*   authenticated: ['features', 'description'],
+*   admin: ['createdAt', 'updatedAt', 'internalNotes']
+* });
+*/
+function createFieldPreset(config) {
+	return {
+		public: config.public || [],
+		authenticated: config.authenticated || [],
+		admin: config.admin || []
+	};
+}
+//#endregion
+export { byIdKey as a, listQueryKey as c, getMongooseProjection as i, modelPattern as l, filterResponseData as n, byQueryKey as o, getFieldsForUser as r, listPattern as s, createFieldPreset as t, versionKey as u };