@classytic/mongokit 3.3.1 → 3.4.0

package/dist/{cache-keys-CzFwVnLy.mjs → field-selection-CalOB7yM.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 };

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

@@ -1,7 +1,95 @@
-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-pVY0w1Pp.mjs";
+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 { ClientSession, Model, PipelineStage } from "mongoose";
 
-//#region src/actions/create.d.ts
+//#region src/actions/aggregate.d.ts
+declare namespace aggregate_d_exports {
+  export { aggregate, aggregatePaginate, average, countBy, distinct, facet, groupBy, lookup, minMax, sum, unwind };
+}
+/**
+ * Execute aggregation pipeline
+ */
+declare function aggregate<TResult = unknown>(Model: Model<any>, pipeline: PipelineStage[], options?: {
+  session?: ClientSession;
+}): Promise<TResult[]>;
+/**
+ * Aggregate with pagination using native MongoDB $facet
+ * WARNING: $facet results must be <16MB. For larger results (limit >1000),
+ * consider using Repository.aggregatePaginate() or splitting into separate queries.
+ */
+declare function aggregatePaginate<TDoc = AnyDocument>(Model: Model<TDoc>, pipeline: PipelineStage[], options?: {
+  page?: number;
+  limit?: number;
+  session?: ClientSession;
+}): Promise<{
+  docs: TDoc[];
+  total: number;
+  page: number;
+  limit: number;
+  pages: number;
+  hasNext: boolean;
+  hasPrev: boolean;
+}>;
+/**
+ * Group documents by field value
+ */
+declare function groupBy(Model: Model<any>, field: string, options?: {
+  limit?: number;
+  session?: ClientSession;
+}): Promise<GroupResult[]>;
+/**
+ * Count by field values
+ */
+declare function countBy(Model: Model<any>, field: string, query?: Record<string, unknown>, options?: {
+  session?: ClientSession;
+}): Promise<GroupResult[]>;
+/**
+ * Lookup (join) with another collection
+ *
+ * MongoDB $lookup has two mutually exclusive forms:
+ * 1. Simple form: { from, localField, foreignField, as }
+ * 2. Pipeline form: { from, let, pipeline, as }
+ *
+ * This function automatically selects the appropriate form based on parameters.
+ */
+declare function lookup<TDoc = AnyDocument>(Model: Model<TDoc>, lookupOptions: LookupOptions): Promise<TDoc[]>;
+/**
+ * Unwind array field
+ */
+declare function unwind<TDoc = AnyDocument>(Model: Model<TDoc>, field: string, options?: {
+  preserveEmpty?: boolean;
+  session?: ClientSession;
+}): Promise<TDoc[]>;
+/**
+ * Facet search (multiple aggregations in one query)
+ */
+declare function facet<TResult = Record<string, unknown[]>>(Model: Model<any>, facets: Record<string, PipelineStage[]>, options?: {
+  session?: ClientSession;
+}): Promise<TResult[]>;
+/**
+ * Get distinct values
+ */
+declare function distinct<T = unknown>(Model: Model<any>, field: string, query?: Record<string, unknown>, options?: {
+  session?: ClientSession;
+  readPreference?: string;
+}): Promise<T[]>;
+/**
+ * Calculate sum
+ */
+declare function sum(Model: Model<any>, field: string, query?: Record<string, unknown>, options?: {
+  session?: ClientSession;
+}): Promise<number>;
+/**
+ * Calculate average
+ */
+declare function average(Model: Model<any>, field: string, query?: Record<string, unknown>, options?: {
+  session?: ClientSession;
+}): Promise<number>;
+/**
+ * Min/Max
+ */
+declare function minMax(Model: Model<any>, field: string, query?: Record<string, unknown>, options?: {
+  session?: ClientSession;
+}): Promise<MinMaxResult>;
 declare namespace create_d_exports {
   export { create, createDefault, createMany, upsert };
 }
@@ -24,6 +112,42 @@ declare function upsert<TDoc = AnyDocument>(Model: Model<TDoc>, query: Record<st
   session?: ClientSession;
   updatePipeline?: boolean;
 }): Promise<TDoc | null>;
+declare namespace delete_d_exports {
+  export { deleteById, deleteByQuery, deleteMany, restore, softDelete };
+}
+/**
+ * Delete by ID
+ */
+declare function deleteById<TDoc = AnyDocument>(Model: Model<TDoc>, id: string | ObjectId, options?: {
+  session?: ClientSession;
+  query?: Record<string, unknown>;
+}): Promise<DeleteResult>;
+/**
+ * Delete many documents
+ */
+declare function deleteMany<TDoc = AnyDocument>(Model: Model<TDoc>, query: Record<string, unknown>, options?: {
+  session?: ClientSession;
+}): Promise<DeleteResult>;
+/**
+ * Delete by query
+ */
+declare function deleteByQuery(Model: Model<any>, query: Record<string, unknown>, options?: {
+  session?: ClientSession;
+  throwOnNotFound?: boolean;
+}): Promise<DeleteResult>;
+/**
+ * Soft delete (set deleted flag)
+ */
+declare function softDelete<TDoc = AnyDocument>(Model: Model<TDoc>, id: string | ObjectId, options?: {
+  session?: ClientSession;
+  userId?: string;
+}): Promise<DeleteResult>;
+/**
+ * Restore soft deleted document
+ */
+declare function restore<TDoc = AnyDocument>(Model: Model<TDoc>, id: string | ObjectId, options?: {
+  session?: ClientSession;
+}): Promise<DeleteResult>;
 declare namespace read_d_exports {
   export { count, exists, getAll, getById, getByQuery, getOrCreate, tryGetByQuery };
 }
@@ -50,7 +174,7 @@ declare function getByQuery<TDoc = AnyDocument>(Model: Model<TDoc>, query: Recor
 /**
  * Get document by query without throwing (returns null if not found)
  */
-declare function tryGetByQuery<TDoc = AnyDocument>(Model: Model<TDoc>, query: Record<string, unknown>, options?: Omit<OperationOptions, "throwOnNotFound">): Promise<TDoc | null>;
+declare function tryGetByQuery<TDoc = AnyDocument>(Model: Model<TDoc>, query: Record<string, unknown>, options?: Omit<OperationOptions, 'throwOnNotFound'>): Promise<TDoc | null>;
 /**
  * Get all documents (basic query without pagination)
  * For pagination, use Repository.paginate() or Repository.stream()
@@ -75,14 +199,14 @@ declare function getOrCreate<TDoc = AnyDocument>(Model: Model<TDoc>, query: Reco
 /**
  * Count documents matching query
  */
-declare function count(Model: Model<any>, query?: Record<string, unknown>, options?: {
+declare function count<TDoc = AnyDocument>(Model: Model<TDoc>, query?: Record<string, unknown>, options?: {
   session?: ClientSession;
   readPreference?: ReadPreferenceType;
 }): Promise<number>;
 /**
  * Check if document exists
  */
-declare function exists(Model: Model<any>, query: Record<string, unknown>, options?: {
+declare function exists<TDoc = AnyDocument>(Model: Model<TDoc>, query: Record<string, unknown>, options?: {
   session?: ClientSession;
   readPreference?: ReadPreferenceType;
 }): Promise<{
@@ -143,129 +267,8 @@ declare function pushToArray<TDoc = AnyDocument>(Model: Model<TDoc>, id: string
  * Pull from array
  */
 declare function pullFromArray<TDoc = AnyDocument>(Model: Model<TDoc>, id: string | ObjectId, field: string, value: unknown, options?: UpdateOptions): Promise<TDoc>;
-declare namespace delete_d_exports {
-  export { deleteById, deleteByQuery, deleteMany, restore, softDelete };
+declare namespace index_d_exports {
+  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 };
 }
-/**
- * Delete by ID
- */
-declare function deleteById(Model: Model<any>, id: string | ObjectId, options?: {
-  session?: ClientSession;
-  query?: Record<string, unknown>;
-}): Promise<DeleteResult>;
-/**
- * Delete many documents
- */
-declare function deleteMany(Model: Model<any>, query: Record<string, unknown>, options?: {
-  session?: ClientSession;
-}): Promise<DeleteResult>;
-/**
- * Delete by query
- */
-declare function deleteByQuery(Model: Model<any>, query: Record<string, unknown>, options?: {
-  session?: ClientSession;
-  throwOnNotFound?: boolean;
-}): Promise<DeleteResult>;
-/**
- * Soft delete (set deleted flag)
- */
-declare function softDelete<TDoc = AnyDocument>(Model: Model<TDoc>, id: string | ObjectId, options?: {
-  session?: ClientSession;
-  userId?: string;
-}): Promise<DeleteResult>;
-/**
- * Restore soft deleted document
- */
-declare function restore<TDoc = AnyDocument>(Model: Model<TDoc>, id: string | ObjectId, options?: {
-  session?: ClientSession;
-}): Promise<DeleteResult>;
-declare namespace aggregate_d_exports {
-  export { aggregate, aggregatePaginate, average, countBy, distinct, facet, groupBy, lookup, minMax, sum, unwind };
-}
-/**
- * Execute aggregation pipeline
- */
-declare function aggregate<TResult = unknown>(Model: Model<any>, pipeline: PipelineStage[], options?: {
-  session?: ClientSession;
-}): Promise<TResult[]>;
-/**
- * Aggregate with pagination using native MongoDB $facet
- * WARNING: $facet results must be <16MB. For larger results (limit >1000),
- * consider using Repository.aggregatePaginate() or splitting into separate queries.
- */
-declare function aggregatePaginate<TDoc = AnyDocument>(Model: Model<TDoc>, pipeline: PipelineStage[], options?: {
-  page?: number;
-  limit?: number;
-  session?: ClientSession;
-}): Promise<{
-  docs: TDoc[];
-  total: number;
-  page: number;
-  limit: number;
-  pages: number;
-  hasNext: boolean;
-  hasPrev: boolean;
-}>;
-/**
- * Group documents by field value
- */
-declare function groupBy(Model: Model<any>, field: string, options?: {
-  limit?: number;
-  session?: ClientSession;
-}): Promise<GroupResult[]>;
-/**
- * Count by field values
- */
-declare function countBy(Model: Model<any>, field: string, query?: Record<string, unknown>, options?: {
-  session?: ClientSession;
-}): Promise<GroupResult[]>;
-/**
- * Lookup (join) with another collection
- *
- * MongoDB $lookup has two mutually exclusive forms:
- * 1. Simple form: { from, localField, foreignField, as }
- * 2. Pipeline form: { from, let, pipeline, as }
- *
- * This function automatically selects the appropriate form based on parameters.
- */
-declare function lookup<TDoc = AnyDocument>(Model: Model<TDoc>, lookupOptions: LookupOptions): Promise<TDoc[]>;
-/**
- * Unwind array field
- */
-declare function unwind<TDoc = AnyDocument>(Model: Model<TDoc>, field: string, options?: {
-  preserveEmpty?: boolean;
-  session?: ClientSession;
-}): Promise<TDoc[]>;
-/**
- * Facet search (multiple aggregations in one query)
- */
-declare function facet<TResult = Record<string, unknown[]>>(Model: Model<any>, facets: Record<string, PipelineStage[]>, options?: {
-  session?: ClientSession;
-}): Promise<TResult[]>;
-/**
- * Get distinct values
- */
-declare function distinct<T = unknown>(Model: Model<any>, field: string, query?: Record<string, unknown>, options?: {
-  session?: ClientSession;
-  readPreference?: string;
-}): Promise<T[]>;
-/**
- * Calculate sum
- */
-declare function sum(Model: Model<any>, field: string, query?: Record<string, unknown>, options?: {
-  session?: ClientSession;
-}): Promise<number>;
-/**
- * Calculate average
- */
-declare function average(Model: Model<any>, field: string, query?: Record<string, unknown>, options?: {
-  session?: ClientSession;
-}): Promise<number>;
-/**
- * Min/Max
- */
-declare function minMax(Model: Model<any>, field: string, query?: Record<string, unknown>, options?: {
-  session?: ClientSession;
-}): Promise<MinMaxResult>;
 //#endregion
-export { create_d_exports as a, read_d_exports as i, delete_d_exports as n, update_d_exports as r, aggregate_d_exports as t };
+export { create_d_exports as a, delete_d_exports as i, update_d_exports as n, aggregate_d_exports as o, read_d_exports as r, index_d_exports as t };