@classytic/mongokit 3.3.2 → 3.4.0

package/dist/{aggregate-BClp040M.mjs → update-DXwVh6M1.mjs}

@@ -1,327 +1,488 @@
-import { t as __exportAll } from "./chunk-DQk6qfdC.mjs";
-import { i as createError, r as warn } from "./logger-D8ily-PP.mjs";
-
-//#region src/actions/create.ts
-var create_exports = /* @__PURE__ */ __exportAll({
-	create: () => create,
-	createDefault: () => createDefault,
-	createMany: () => createMany,
-	upsert: () => upsert
-});
-/**
-* Create single document
-*/
-async function create(Model, data, options = {}) {
-	const document = new Model(data);
-	await document.save({ session: options.session });
-	return document;
-}
-/**
-* Create multiple documents
-*/
-async function createMany(Model, dataArray, options = {}) {
-	return Model.insertMany(dataArray, {
-		session: options.session,
-		ordered: options.ordered !== false
-	});
-}
-/**
-* Create with defaults (useful for initialization)
-*/
-async function createDefault(Model, overrides = {}, options = {}) {
-	const defaults = {};
-	Model.schema.eachPath((path, schemaType) => {
-		const schemaOptions = schemaType.options;
-		if (schemaOptions.default !== void 0 && path !== "_id") defaults[path] = typeof schemaOptions.default === "function" ? schemaOptions.default() : schemaOptions.default;
-	});
-	return create(Model, {
-		...defaults,
-		...overrides
-	}, options);
-}
+import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
+import { a as warn, t as createError } from "./error-Bpbi_NKo.mjs";
+//#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"
+];
 /**
-* Upsert (create or update)
+* Fluent builder for MongoDB $lookup aggregation stage
+* Optimized for custom field joins at scale
 */
-async function upsert(Model, query, data, options = {}) {
-	return Model.findOneAndUpdate(query, { $setOnInsert: data }, {
-		upsert: true,
-		returnDocument: "after",
-		runValidators: true,
-		session: options.session,
-		...options.updatePipeline !== void 0 ? { updatePipeline: options.updatePipeline } : {}
-	});
-}
-
-//#endregion
-//#region src/actions/read.ts
-var read_exports = /* @__PURE__ */ __exportAll({
-	count: () => count,
-	exists: () => exists,
-	getAll: () => getAll,
-	getById: () => getById,
-	getByQuery: () => getByQuery,
-	getOrCreate: () => getOrCreate,
-	tryGetByQuery: () => tryGetByQuery
+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.select) {
+				let projection;
+				if (typeof lookup.select === "string") {
+					projection = {};
+					for (const field of lookup.select.split(",").map((f) => f.trim())) if (field.startsWith("-")) projection[field.substring(1)] = 0;
+					else projection[field] = 1;
+				} else projection = lookup.select;
+				const selectPipeline = [{ $project: projection }];
+				const existing = lookup.pipeline || [];
+				builder.pipeline([...existing, ...selectPipeline]);
+			} else 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
 });
 /**
-* 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)
+* Execute aggregation pipeline
 */
-async function tryGetByQuery(Model, query, options = {}) {
-	return getByQuery(Model, query, {
-		...options,
-		throwOnNotFound: false
-	});
+async function aggregate(Model, pipeline, options = {}) {
+	const aggregation = Model.aggregate(pipeline);
+	if (options.session) aggregation.session(options.session);
+	return aggregation.exec();
 }
 /**
-* Get all documents (basic query without pagination)
-* For pagination, use Repository.paginate() or Repository.stream()
+* 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 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();
+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
+	};
 }
 /**
-* Get or create document (upsert)
+* Group documents by field value
 */
-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 } : {}
-	});
+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 documents matching query
+* Count by field values
 */
-async function count(Model, query = {}, options = {}) {
-	const q = Model.countDocuments(query).session(options.session ?? null);
-	if (options.readPreference) q.read(options.readPreference);
-	return q;
+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);
 }
 /**
-* Check if document exists
+* 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 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.");
+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);
 }
 /**
-* Parse populate specification into consistent format
+* Unwind array field
 */
-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];
+async function unwind(Model, field, options = {}) {
+	return aggregate(Model, [{ $unwind: {
+		path: `$${field}`,
+		preserveNullAndEmptyArrays: options.preserveEmpty !== false
+	} }], { session: options.session });
 }
 /**
-* Update by ID
+* Facet search (multiple aggregations in one query)
 */
-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 } : {},
-		...options.arrayFilters ? { arrayFilters: options.arrayFilters } : {}
-	}).select(options.select || "").populate(parsePopulate(options.populate)).lean(options.lean ?? false);
-	if (!document) throw createError(404, "Document not found");
-	return document;
+async function facet(Model, facets, options = {}) {
+	return aggregate(Model, [{ $facet: facets }], options);
 }
 /**
-* 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 } : {},
-		...options.arrayFilters ? { arrayFilters: options.arrayFilters } : {}
-	}).select(options.select || "").populate(parsePopulate(options.populate)).lean(options.lean ?? false);
+* Get distinct values
+*/
+async function distinct(Model, field, query = {}, options = {}) {
+	const q = Model.distinct(field, query).session(options.session ?? null);
+	if (options.readPreference) q.read(options.readPreference);
+	return q;
 }
 /**
-* Update with validation (smart optimization)
-* 1-query on success, 2-queries for detailed errors
+* Calculate sum
 */
-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 findQuery = {
-		_id: id,
-		...options.query
-	};
-	const existing = await Model.findOne(findQuery).select(options.select || "").session(options.session ?? null).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)
-	};
+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;
 }
 /**
-* Update many documents
+* Calculate average
 */
-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 } : {},
-		...options.arrayFilters ? { arrayFilters: options.arrayFilters } : {}
-	});
-	return {
-		matchedCount: result.matchedCount,
-		modifiedCount: result.modifiedCount
+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
+//#region src/actions/create.ts
+var create_exports = /* @__PURE__ */ __exportAll({
+	create: () => create,
+	createDefault: () => createDefault,
+	createMany: () => createMany,
+	upsert: () => upsert
+});
 /**
-* Update by query
+* Create single document
 */
-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 } : {},
-		...options.arrayFilters ? { arrayFilters: options.arrayFilters } : {}
-	}).select(options.select || "").populate(parsePopulate(options.populate)).lean(options.lean ?? false);
-	if (!document && options.throwOnNotFound !== false) throw createError(404, "Document not found");
+async function create(Model, data, options = {}) {
+	const document = new Model(data);
+	await document.save({ session: options.session });
 	return document;
 }
 /**
-* Increment field
+* Create multiple documents
 */
-async function increment(Model, id, field, value = 1, options = {}) {
-	return update(Model, id, { $inc: { [field]: value } }, options);
+async function createMany(Model, dataArray, options = {}) {
+	return Model.insertMany(dataArray, {
+		session: options.session,
+		ordered: options.ordered !== false
+	});
 }
 /**
-* Push to array
+* Create with defaults (useful for initialization)
 */
-async function pushToArray(Model, id, field, value, options = {}) {
-	return update(Model, id, { $push: { [field]: value } }, options);
+async function createDefault(Model, overrides = {}, options = {}) {
+	const defaults = {};
+	Model.schema.eachPath((path, schemaType) => {
+		const schemaOptions = schemaType.options;
+		if (schemaOptions.default !== void 0 && path !== "_id") defaults[path] = typeof schemaOptions.default === "function" ? schemaOptions.default() : schemaOptions.default;
+	});
+	return create(Model, {
+		...defaults,
+		...overrides
+	}, options);
 }
 /**
-* Pull from array
+* Upsert (create or update)
 */
-async function pullFromArray(Model, id, field, value, options = {}) {
-	return update(Model, id, { $pull: { [field]: value } }, options);
+async function upsert(Model, query, data, options = {}) {
+	return Model.findOneAndUpdate(query, { $setOnInsert: data }, {
+		upsert: true,
+		returnDocument: "after",
+		runValidators: true,
+		session: options.session,
+		...options.updatePipeline !== void 0 ? { updatePipeline: options.updatePipeline } : {}
+	});
 }
-
 //#endregion
 //#region src/actions/delete.ts
 var delete_exports = /* @__PURE__ */ __exportAll({
@@ -405,431 +566,273 @@ async function restore(Model, id, options = {}) {
 		id: String(id)
 	};
 }
-
 //#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"
-];
+//#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);
+	if (options.lean !== false) mongoQuery = mongoQuery.lean();
+	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 } : {}
+	});
+}
 /**
-* Fluent builder for MongoDB $lookup aggregation stage
-* Optimized for custom field joins at scale
+* Count documents matching query
 */
-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;
-	}
-};
-
+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/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
+//#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
 });
-/**
-* Execute aggregation pipeline
-*/
-async function aggregate(Model, pipeline, options = {}) {
-	const aggregation = Model.aggregate(pipeline);
-	if (options.session) aggregation.session(options.session);
-	return aggregation.exec();
+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.");
 }
 /**
-* 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.
+* Parse populate specification into consistent format
 */
-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
-	};
+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];
 }
 /**
-* Group documents by field value
+* Update by ID
 */
-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);
+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 } : {},
+		...options.arrayFilters ? { arrayFilters: options.arrayFilters } : {}
+	}).select(options.select || "").populate(parsePopulate(options.populate)).lean(options.lean ?? false);
+	if (!document) throw createError(404, "Document not found");
+	return document;
 }
 /**
-* Count by field values
+* Update with query constraints (optimized)
+* Returns null if constraints not met (not an error)
 */
-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);
+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 } : {},
+		...options.arrayFilters ? { arrayFilters: options.arrayFilters } : {}
+	}).select(options.select || "").populate(parsePopulate(options.populate)).lean(options.lean ?? false);
 }
 /**
-* 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.
+* Update with validation (smart optimization)
+* 1-query on success, 2-queries for detailed errors
 */
-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
-		} });
+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
+		};
 	}
-	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 });
+	const findQuery = {
+		_id: id,
+		...options.query
+	};
+	const existing = await Model.findOne(findQuery).select(options.select || "").session(options.session ?? null).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)
+	};
 }
 /**
-* Facet search (multiple aggregations in one query)
+* Update many documents
 */
-async function facet(Model, facets, options = {}) {
-	return aggregate(Model, [{ $facet: facets }], options);
+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 } : {},
+		...options.arrayFilters ? { arrayFilters: options.arrayFilters } : {}
+	});
+	return {
+		matchedCount: result.matchedCount,
+		modifiedCount: result.modifiedCount
+	};
 }
 /**
-* Get distinct values
+* Update by query
 */
-async function distinct(Model, field, query = {}, options = {}) {
-	const q = Model.distinct(field, query).session(options.session ?? null);
-	if (options.readPreference) q.read(options.readPreference);
-	return q;
+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 } : {},
+		...options.arrayFilters ? { arrayFilters: options.arrayFilters } : {}
+	}).select(options.select || "").populate(parsePopulate(options.populate)).lean(options.lean ?? false);
+	if (!document && options.throwOnNotFound !== false) throw createError(404, "Document not found");
+	return document;
 }
 /**
-* Calculate sum
+* Increment field
 */
-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;
+async function increment(Model, id, field, value = 1, options = {}) {
+	return update(Model, id, { $inc: { [field]: value } }, options);
 }
 /**
-* Calculate average
+* Push to array
 */
-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;
+async function pushToArray(Model, id, field, value, options = {}) {
+	return update(Model, id, { $push: { [field]: value } }, options);
 }
 /**
-* Min/Max
+* Pull from array
 */
-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
-	};
+async function pullFromArray(Model, id, field, value, options = {}) {
+	return update(Model, id, { $pull: { [field]: value } }, options);
 }
-
 //#endregion
-export { upsert as _, delete_exports as a, count as c, getByQuery as d, getOrCreate as f, create_exports as g, createMany as h, deleteById as i, exists as l, create as m, distinct as n, update as o, read_exports as p, LookupBuilder as r, update_exports as s, aggregate_exports as t, getById as u };
+export { LookupBuilder as _, getById as a, read_exports as c, create as d, createMany as f, distinct as g, aggregate_exports as h, exists as i, deleteById as l, upsert as m, update_exports as n, getByQuery as o, create_exports as p, count as r, getOrCreate as s, update as t, delete_exports as u };