@classytic/mongokit 3.2.1 → 3.2.2

package/dist/aggregate-BAi4Do-X.mjs

@@ -0,0 +1,767 @@
+import { t as __exportAll } from "./chunk-DQk6qfdC.mjs";
+import { i as createError, r as warn } from "./logger-D8ily-PP.mjs";
+
+//#region src/actions/read.ts
+var read_exports = /* @__PURE__ */ __exportAll({
+	count: () => count,
+	exists: () => exists,
+	getAll: () => getAll,
+	getById: () => getById,
+	getByQuery: () => getByQuery,
+	getOrCreate: () => getOrCreate,
+	tryGetByQuery: () => tryGetByQuery
+});
+/**
+* Parse populate specification into consistent format
+*/
+function parsePopulate$1(populate) {
+	if (!populate) return [];
+	if (typeof populate === "string") return populate.split(",").map((p) => p.trim());
+	if (Array.isArray(populate)) return populate.map((p) => typeof p === "string" ? p.trim() : p);
+	return [populate];
+}
+/**
+* Get document by ID
+*
+* @param Model - Mongoose model
+* @param id - Document ID
+* @param options - Query options
+* @returns Document or null
+* @throws Error if document not found and throwOnNotFound is true
+*/
+async function getById(Model, id, options = {}) {
+	const query = options.query ? Model.findOne({
+		_id: id,
+		...options.query
+	}) : Model.findById(id);
+	if (options.select) query.select(options.select);
+	if (options.populate) query.populate(parsePopulate$1(options.populate));
+	if (options.lean) query.lean();
+	if (options.session) query.session(options.session);
+	if (options.readPreference) query.read(options.readPreference);
+	const document = await query.exec();
+	if (!document && options.throwOnNotFound !== false) throw createError(404, "Document not found");
+	return document;
+}
+/**
+* Get document by query
+*
+* @param Model - Mongoose model
+* @param query - MongoDB query
+* @param options - Query options
+* @returns Document or null
+* @throws Error if document not found and throwOnNotFound is true
+*/
+async function getByQuery(Model, query, options = {}) {
+	const mongoQuery = Model.findOne(query);
+	if (options.select) mongoQuery.select(options.select);
+	if (options.populate) mongoQuery.populate(parsePopulate$1(options.populate));
+	if (options.lean) mongoQuery.lean();
+	if (options.session) mongoQuery.session(options.session);
+	if (options.readPreference) mongoQuery.read(options.readPreference);
+	const document = await mongoQuery.exec();
+	if (!document && options.throwOnNotFound !== false) throw createError(404, "Document not found");
+	return document;
+}
+/**
+* Get document by query without throwing (returns null if not found)
+*/
+async function tryGetByQuery(Model, query, options = {}) {
+	return getByQuery(Model, query, {
+		...options,
+		throwOnNotFound: false
+	});
+}
+/**
+* Get all documents (basic query without pagination)
+* For pagination, use Repository.paginate() or Repository.stream()
+*/
+async function getAll(Model, query = {}, options = {}) {
+	let mongoQuery = Model.find(query);
+	if (options.select) mongoQuery = mongoQuery.select(options.select);
+	if (options.populate) mongoQuery = mongoQuery.populate(parsePopulate$1(options.populate));
+	if (options.sort) mongoQuery = mongoQuery.sort(options.sort);
+	if (options.limit) mongoQuery = mongoQuery.limit(options.limit);
+	if (options.skip) mongoQuery = mongoQuery.skip(options.skip);
+	mongoQuery = mongoQuery.lean(options.lean !== false);
+	if (options.session) mongoQuery = mongoQuery.session(options.session);
+	if (options.readPreference) mongoQuery = mongoQuery.read(options.readPreference);
+	return mongoQuery.exec();
+}
+/**
+* Get or create document (upsert)
+*/
+async function getOrCreate(Model, query, createData, options = {}) {
+	return Model.findOneAndUpdate(query, { $setOnInsert: createData }, {
+		upsert: true,
+		returnDocument: "after",
+		runValidators: true,
+		session: options.session,
+		...options.updatePipeline !== void 0 ? { updatePipeline: options.updatePipeline } : {}
+	});
+}
+/**
+* Count documents matching query
+*/
+async function count(Model, query = {}, options = {}) {
+	const q = Model.countDocuments(query).session(options.session ?? null);
+	if (options.readPreference) q.read(options.readPreference);
+	return q;
+}
+/**
+* Check if document exists
+*/
+async function exists(Model, query, options = {}) {
+	const q = Model.exists(query).session(options.session ?? null);
+	if (options.readPreference) q.read(options.readPreference);
+	return q;
+}
+
+//#endregion
+//#region src/actions/update.ts
+var update_exports = /* @__PURE__ */ __exportAll({
+	increment: () => increment,
+	pullFromArray: () => pullFromArray,
+	pushToArray: () => pushToArray,
+	update: () => update,
+	updateByQuery: () => updateByQuery,
+	updateMany: () => updateMany,
+	updateWithConstraints: () => updateWithConstraints,
+	updateWithValidation: () => updateWithValidation
+});
+function assertUpdatePipelineAllowed(update, updatePipeline) {
+	if (Array.isArray(update) && updatePipeline !== true) throw createError(400, "Update pipelines (array updates) are disabled by default; pass `{ updatePipeline: true }` to explicitly allow pipeline-style updates.");
+}
+/**
+* Parse populate specification into consistent format
+*/
+function parsePopulate(populate) {
+	if (!populate) return [];
+	if (typeof populate === "string") return populate.split(",").map((p) => p.trim());
+	if (Array.isArray(populate)) return populate.map((p) => typeof p === "string" ? p.trim() : p);
+	return [populate];
+}
+/**
+* Update by ID
+*/
+async function update(Model, id, data, options = {}) {
+	assertUpdatePipelineAllowed(data, options.updatePipeline);
+	const query = {
+		_id: id,
+		...options.query
+	};
+	const document = await Model.findOneAndUpdate(query, data, {
+		returnDocument: "after",
+		runValidators: true,
+		session: options.session,
+		...options.updatePipeline !== void 0 ? { updatePipeline: options.updatePipeline } : {}
+	}).select(options.select || "").populate(parsePopulate(options.populate)).lean(options.lean ?? false);
+	if (!document) throw createError(404, "Document not found");
+	return document;
+}
+/**
+* Update with query constraints (optimized)
+* Returns null if constraints not met (not an error)
+*/
+async function updateWithConstraints(Model, id, data, constraints = {}, options = {}) {
+	assertUpdatePipelineAllowed(data, options.updatePipeline);
+	const query = {
+		_id: id,
+		...constraints
+	};
+	return await Model.findOneAndUpdate(query, data, {
+		returnDocument: "after",
+		runValidators: true,
+		session: options.session,
+		...options.updatePipeline !== void 0 ? { updatePipeline: options.updatePipeline } : {}
+	}).select(options.select || "").populate(parsePopulate(options.populate)).lean(options.lean ?? false);
+}
+/**
+* Update with validation (smart optimization)
+* 1-query on success, 2-queries for detailed errors
+*/
+async function updateWithValidation(Model, id, data, validationOptions = {}, options = {}) {
+	const { buildConstraints, validateUpdate } = validationOptions;
+	assertUpdatePipelineAllowed(data, options.updatePipeline);
+	if (buildConstraints) {
+		const document = await updateWithConstraints(Model, id, data, buildConstraints(data), options);
+		if (document) return {
+			success: true,
+			data: document
+		};
+	}
+	const existing = await Model.findById(id).select(options.select || "").lean();
+	if (!existing) return {
+		success: false,
+		error: {
+			code: 404,
+			message: "Document not found"
+		}
+	};
+	if (validateUpdate) {
+		const validation = validateUpdate(existing, data);
+		if (!validation.valid) return {
+			success: false,
+			error: {
+				code: 403,
+				message: validation.message || "Update not allowed",
+				violations: validation.violations
+			}
+		};
+	}
+	return {
+		success: true,
+		data: await update(Model, id, data, options)
+	};
+}
+/**
+* Update many documents
+*/
+async function updateMany(Model, query, data, options = {}) {
+	assertUpdatePipelineAllowed(data, options.updatePipeline);
+	const result = await Model.updateMany(query, data, {
+		runValidators: true,
+		session: options.session,
+		...options.updatePipeline !== void 0 ? { updatePipeline: options.updatePipeline } : {}
+	});
+	return {
+		matchedCount: result.matchedCount,
+		modifiedCount: result.modifiedCount
+	};
+}
+/**
+* Update by query
+*/
+async function updateByQuery(Model, query, data, options = {}) {
+	assertUpdatePipelineAllowed(data, options.updatePipeline);
+	const document = await Model.findOneAndUpdate(query, data, {
+		returnDocument: "after",
+		runValidators: true,
+		session: options.session,
+		...options.updatePipeline !== void 0 ? { updatePipeline: options.updatePipeline } : {}
+	}).select(options.select || "").populate(parsePopulate(options.populate)).lean(options.lean ?? false);
+	if (!document && options.throwOnNotFound !== false) throw createError(404, "Document not found");
+	return document;
+}
+/**
+* Increment field
+*/
+async function increment(Model, id, field, value = 1, options = {}) {
+	return update(Model, id, { $inc: { [field]: value } }, options);
+}
+/**
+* Push to array
+*/
+async function pushToArray(Model, id, field, value, options = {}) {
+	return update(Model, id, { $push: { [field]: value } }, options);
+}
+/**
+* Pull from array
+*/
+async function pullFromArray(Model, id, field, value, options = {}) {
+	return update(Model, id, { $pull: { [field]: value } }, options);
+}
+
+//#endregion
+//#region src/actions/delete.ts
+var delete_exports = /* @__PURE__ */ __exportAll({
+	deleteById: () => deleteById,
+	deleteByQuery: () => deleteByQuery,
+	deleteMany: () => deleteMany,
+	restore: () => restore,
+	softDelete: () => softDelete
+});
+/**
+* Delete by ID
+*/
+async function deleteById(Model, id, options = {}) {
+	const query = {
+		_id: id,
+		...options.query
+	};
+	if (!await Model.findOneAndDelete(query).session(options.session ?? null)) throw createError(404, "Document not found");
+	return {
+		success: true,
+		message: "Deleted successfully"
+	};
+}
+/**
+* Delete many documents
+*/
+async function deleteMany(Model, query, options = {}) {
+	return {
+		success: true,
+		count: (await Model.deleteMany(query).session(options.session ?? null)).deletedCount,
+		message: "Deleted successfully"
+	};
+}
+/**
+* Delete by query
+*/
+async function deleteByQuery(Model, query, options = {}) {
+	if (!await Model.findOneAndDelete(query).session(options.session ?? null) && options.throwOnNotFound !== false) throw createError(404, "Document not found");
+	return {
+		success: true,
+		message: "Deleted successfully"
+	};
+}
+/**
+* Soft delete (set deleted flag)
+*/
+async function softDelete(Model, id, options = {}) {
+	if (!await Model.findByIdAndUpdate(id, {
+		deleted: true,
+		deletedAt: /* @__PURE__ */ new Date(),
+		deletedBy: options.userId
+	}, {
+		returnDocument: "after",
+		session: options.session
+	})) throw createError(404, "Document not found");
+	return {
+		success: true,
+		message: "Soft deleted successfully"
+	};
+}
+/**
+* Restore soft deleted document
+*/
+async function restore(Model, id, options = {}) {
+	if (!await Model.findByIdAndUpdate(id, {
+		deleted: false,
+		deletedAt: null,
+		deletedBy: null
+	}, {
+		returnDocument: "after",
+		session: options.session
+	})) throw createError(404, "Document not found");
+	return {
+		success: true,
+		message: "Restored successfully"
+	};
+}
+
+//#endregion
+//#region src/query/LookupBuilder.ts
+/** Stages that are never valid inside a $lookup pipeline */
+const BLOCKED_PIPELINE_STAGES = [
+	"$out",
+	"$merge",
+	"$unionWith",
+	"$collStats",
+	"$currentOp",
+	"$listSessions"
+];
+/** Operators that can enable arbitrary code execution */
+const DANGEROUS_OPERATORS = [
+	"$where",
+	"$function",
+	"$accumulator",
+	"$expr"
+];
+/**
+* Fluent builder for MongoDB $lookup aggregation stage
+* Optimized for custom field joins at scale
+*/
+var LookupBuilder = class LookupBuilder {
+	options = {};
+	constructor(from) {
+		if (from) this.options.from = from;
+	}
+	/**
+	* Set the collection to join with
+	*/
+	from(collection) {
+		this.options.from = collection;
+		return this;
+	}
+	/**
+	* Set the local field (source collection)
+	* IMPORTANT: This field should be indexed for optimal performance
+	*/
+	localField(field) {
+		this.options.localField = field;
+		return this;
+	}
+	/**
+	* Set the foreign field (target collection)
+	* IMPORTANT: This field should be indexed (preferably unique) for optimal performance
+	*/
+	foreignField(field) {
+		this.options.foreignField = field;
+		return this;
+	}
+	/**
+	* Set the output field name
+	* Defaults to the collection name if not specified
+	*/
+	as(fieldName) {
+		this.options.as = fieldName;
+		return this;
+	}
+	/**
+	* Mark this lookup as returning a single document
+	* Automatically unwraps the array result to a single object or null
+	*/
+	single(isSingle = true) {
+		this.options.single = isSingle;
+		return this;
+	}
+	/**
+	* Add a pipeline to filter/transform joined documents
+	* Useful for filtering, sorting, or limiting joined results
+	*
+	* @example
+	* ```typescript
+	* lookup.pipeline([
+	*   { $match: { status: 'active' } },
+	*   { $sort: { priority: -1 } },
+	*   { $limit: 5 }
+	* ]);
+	* ```
+	*/
+	pipeline(stages) {
+		this.options.pipeline = stages;
+		return this;
+	}
+	/**
+	* Set let variables for use in pipeline
+	* Allows referencing local document fields in the pipeline
+	*/
+	let(variables) {
+		this.options.let = variables;
+		return this;
+	}
+	/**
+	* Build the $lookup aggregation stage(s)
+	* Returns an array of pipeline stages including $lookup and optional $unwind
+	*
+	* IMPORTANT: MongoDB $lookup has two mutually exclusive forms:
+	* 1. Simple form: { from, localField, foreignField, as }
+	* 2. Pipeline form: { from, let, pipeline, as }
+	*
+	* When pipeline or let is specified, we use the pipeline form.
+	* Otherwise, we use the simpler localField/foreignField form.
+	*/
+	build() {
+		const { from, localField, foreignField, as, single, pipeline, let: letVars } = this.options;
+		if (!from) throw new Error("LookupBuilder: \"from\" collection is required");
+		const outputField = as || from;
+		const stages = [];
+		const usePipelineForm = pipeline || letVars;
+		let lookupStage;
+		if (usePipelineForm) if (!pipeline || pipeline.length === 0) {
+			if (!localField || !foreignField) throw new Error("LookupBuilder: When using pipeline form without a custom pipeline, both localField and foreignField are required to auto-generate the pipeline");
+			const autoPipeline = [{ $match: { $expr: { $eq: [`$${foreignField}`, `$$${localField}`] } } }];
+			lookupStage = { $lookup: {
+				from,
+				let: {
+					[localField]: `$${localField}`,
+					...letVars || {}
+				},
+				pipeline: autoPipeline,
+				as: outputField
+			} };
+		} else {
+			const safePipeline = this.options.sanitize !== false ? LookupBuilder.sanitizePipeline(pipeline) : pipeline;
+			lookupStage = { $lookup: {
+				from,
+				...letVars && { let: letVars },
+				pipeline: safePipeline,
+				as: outputField
+			} };
+		}
+		else {
+			if (!localField || !foreignField) throw new Error("LookupBuilder: localField and foreignField are required for simple lookup");
+			lookupStage = { $lookup: {
+				from,
+				localField,
+				foreignField,
+				as: outputField
+			} };
+		}
+		stages.push(lookupStage);
+		if (single) stages.push({ $unwind: {
+			path: `$${outputField}`,
+			preserveNullAndEmptyArrays: true
+		} });
+		return stages;
+	}
+	/**
+	* Build and return only the $lookup stage (without $unwind)
+	* Useful when you want to handle unwrapping yourself
+	*/
+	buildLookupOnly() {
+		return this.build()[0];
+	}
+	/**
+	* Static helper: Create a simple lookup in one line
+	*/
+	static simple(from, localField, foreignField, options = {}) {
+		return new LookupBuilder(from).localField(localField).foreignField(foreignField).as(options.as || from).single(options.single || false).build();
+	}
+	/**
+	* Static helper: Create multiple lookups at once
+	*
+	* @example
+	* ```typescript
+	* const pipeline = LookupBuilder.multiple([
+	*   { from: 'departments', localField: 'deptSlug', foreignField: 'slug', single: true },
+	*   { from: 'managers', localField: 'managerId', foreignField: '_id', single: true }
+	* ]);
+	* ```
+	*/
+	static multiple(lookups) {
+		return lookups.flatMap((lookup) => {
+			const builder = new LookupBuilder(lookup.from).localField(lookup.localField).foreignField(lookup.foreignField);
+			if (lookup.as) builder.as(lookup.as);
+			if (lookup.single) builder.single(lookup.single);
+			if (lookup.pipeline) builder.pipeline(lookup.pipeline);
+			if (lookup.let) builder.let(lookup.let);
+			return builder.build();
+		});
+	}
+	/**
+	* Static helper: Create a nested lookup (lookup within lookup)
+	* Useful for multi-level joins like Order -> Product -> Category
+	*
+	* @example
+	* ```typescript
+	* // Join orders with products, then products with categories
+	* const pipeline = LookupBuilder.nested([
+	*   { from: 'products', localField: 'productSku', foreignField: 'sku', as: 'product', single: true },
+	*   { from: 'categories', localField: 'product.categorySlug', foreignField: 'slug', as: 'product.category', single: true }
+	* ]);
+	* ```
+	*/
+	static nested(lookups) {
+		return lookups.flatMap((lookup, index) => {
+			const builder = new LookupBuilder(lookup.from).localField(lookup.localField).foreignField(lookup.foreignField);
+			if (lookup.as) builder.as(lookup.as);
+			if (lookup.single !== void 0) builder.single(lookup.single);
+			if (lookup.pipeline) builder.pipeline(lookup.pipeline);
+			if (lookup.let) builder.let(lookup.let);
+			return builder.build();
+		});
+	}
+	/**
+	* Sanitize pipeline stages by blocking dangerous stages and operators.
+	* Used internally by build() and available for external use (e.g., aggregate.ts).
+	*/
+	static sanitizePipeline(stages) {
+		const sanitized = [];
+		for (const stage of stages) {
+			if (!stage || typeof stage !== "object") continue;
+			const entries = Object.entries(stage);
+			if (entries.length !== 1) continue;
+			const [op, config] = entries[0];
+			if (BLOCKED_PIPELINE_STAGES.includes(op)) {
+				warn(`[mongokit] Blocked dangerous pipeline stage in lookup: ${op}`);
+				continue;
+			}
+			if ((op === "$match" || op === "$addFields" || op === "$set") && typeof config === "object" && config !== null) sanitized.push({ [op]: LookupBuilder._sanitizeDeep(config) });
+			else sanitized.push(stage);
+		}
+		return sanitized;
+	}
+	/**
+	* Recursively remove dangerous operators from an expression object.
+	*/
+	static _sanitizeDeep(config) {
+		const sanitized = {};
+		for (const [key, value] of Object.entries(config)) {
+			if (DANGEROUS_OPERATORS.includes(key)) {
+				warn(`[mongokit] Blocked dangerous operator in lookup pipeline: ${key}`);
+				continue;
+			}
+			if (value && typeof value === "object" && !Array.isArray(value)) sanitized[key] = LookupBuilder._sanitizeDeep(value);
+			else if (Array.isArray(value)) sanitized[key] = value.map((item) => {
+				if (item && typeof item === "object" && !Array.isArray(item)) return LookupBuilder._sanitizeDeep(item);
+				return item;
+			});
+			else sanitized[key] = value;
+		}
+		return sanitized;
+	}
+};
+
+//#endregion
+//#region src/actions/aggregate.ts
+var aggregate_exports = /* @__PURE__ */ __exportAll({
+	aggregate: () => aggregate,
+	aggregatePaginate: () => aggregatePaginate,
+	average: () => average,
+	countBy: () => countBy,
+	distinct: () => distinct,
+	facet: () => facet,
+	groupBy: () => groupBy,
+	lookup: () => lookup,
+	minMax: () => minMax,
+	sum: () => sum,
+	unwind: () => unwind
+});
+/**
+* Execute aggregation pipeline
+*/
+async function aggregate(Model, pipeline, options = {}) {
+	const aggregation = Model.aggregate(pipeline);
+	if (options.session) aggregation.session(options.session);
+	return aggregation.exec();
+}
+/**
+* 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.
+*/
+async function aggregatePaginate(Model, pipeline, options = {}) {
+	const page = parseInt(String(options.page || 1), 10);
+	const limit = parseInt(String(options.limit || 10), 10);
+	const skip = (page - 1) * limit;
+	if (limit > 1e3) warn(`[mongokit] Large aggregation limit (${limit}). $facet results must be <16MB. Consider using Repository.aggregatePaginate() for safer handling of large datasets.`);
+	const facetPipeline = [...pipeline, { $facet: {
+		docs: [{ $skip: skip }, { $limit: limit }],
+		total: [{ $count: "count" }]
+	} }];
+	const aggregation = Model.aggregate(facetPipeline);
+	if (options.session) aggregation.session(options.session);
+	const [result] = await aggregation.exec();
+	const docs = result.docs || [];
+	const total = result.total[0]?.count || 0;
+	const pages = Math.ceil(total / limit);
+	return {
+		docs,
+		total,
+		page,
+		limit,
+		pages,
+		hasNext: page < pages,
+		hasPrev: page > 1
+	};
+}
+/**
+* Group documents by field value
+*/
+async function groupBy(Model, field, options = {}) {
+	const pipeline = [{ $group: {
+		_id: `$${field}`,
+		count: { $sum: 1 }
+	} }, { $sort: { count: -1 } }];
+	if (options.limit) pipeline.push({ $limit: options.limit });
+	return aggregate(Model, pipeline, options);
+}
+/**
+* Count by field values
+*/
+async function countBy(Model, field, query = {}, options = {}) {
+	const pipeline = [];
+	if (Object.keys(query).length > 0) pipeline.push({ $match: query });
+	pipeline.push({ $group: {
+		_id: `$${field}`,
+		count: { $sum: 1 }
+	} }, { $sort: { count: -1 } });
+	return aggregate(Model, pipeline, options);
+}
+/**
+* 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.
+*/
+async function lookup(Model, lookupOptions) {
+	const { from, localField, foreignField, as, pipeline = [], let: letVars, query = {}, options = {} } = lookupOptions;
+	const aggPipeline = [];
+	if (Object.keys(query).length > 0) aggPipeline.push({ $match: query });
+	if (pipeline.length > 0 || letVars) if (pipeline.length === 0 && localField && foreignField) {
+		const autoPipeline = [{ $match: { $expr: { $eq: [`$${foreignField}`, `$$${localField}`] } } }];
+		aggPipeline.push({ $lookup: {
+			from,
+			let: {
+				[localField]: `$${localField}`,
+				...letVars || {}
+			},
+			pipeline: autoPipeline,
+			as
+		} });
+	} else {
+		const safePipeline = lookupOptions.sanitize !== false ? LookupBuilder.sanitizePipeline(pipeline) : pipeline;
+		aggPipeline.push({ $lookup: {
+			from,
+			...letVars && { let: letVars },
+			pipeline: safePipeline,
+			as
+		} });
+	}
+	else aggPipeline.push({ $lookup: {
+		from,
+		localField,
+		foreignField,
+		as
+	} });
+	return aggregate(Model, aggPipeline, options);
+}
+/**
+* Unwind array field
+*/
+async function unwind(Model, field, options = {}) {
+	return aggregate(Model, [{ $unwind: {
+		path: `$${field}`,
+		preserveNullAndEmptyArrays: options.preserveEmpty !== false
+	} }], { session: options.session });
+}
+/**
+* Facet search (multiple aggregations in one query)
+*/
+async function facet(Model, facets, options = {}) {
+	return aggregate(Model, [{ $facet: facets }], options);
+}
+/**
+* Get distinct values
+*/
+async function distinct(Model, field, query = {}, options = {}) {
+	return Model.distinct(field, query).session(options.session ?? null);
+}
+/**
+* Calculate sum
+*/
+async function sum(Model, field, query = {}, options = {}) {
+	const pipeline = [];
+	if (Object.keys(query).length > 0) pipeline.push({ $match: query });
+	pipeline.push({ $group: {
+		_id: null,
+		total: { $sum: `$${field}` }
+	} });
+	return (await aggregate(Model, pipeline, options))[0]?.total || 0;
+}
+/**
+* Calculate average
+*/
+async function average(Model, field, query = {}, options = {}) {
+	const pipeline = [];
+	if (Object.keys(query).length > 0) pipeline.push({ $match: query });
+	pipeline.push({ $group: {
+		_id: null,
+		average: { $avg: `$${field}` }
+	} });
+	return (await aggregate(Model, pipeline, options))[0]?.average || 0;
+}
+/**
+* Min/Max
+*/
+async function minMax(Model, field, query = {}, options = {}) {
+	const pipeline = [];
+	if (Object.keys(query).length > 0) pipeline.push({ $match: query });
+	pipeline.push({ $group: {
+		_id: null,
+		min: { $min: `$${field}` },
+		max: { $max: `$${field}` }
+	} });
+	return (await aggregate(Model, pipeline, options))[0] || {
+		min: null,
+		max: null
+	};
+}
+
+//#endregion
+export { deleteById as a, update_exports as c, getById as d, getByQuery as f, LookupBuilder as i, count as l, read_exports as m, aggregate_exports as n, delete_exports as o, getOrCreate as p, distinct as r, update as s, aggregate as t, exists as u };