@classytic/mongokit 3.3.2 → 3.4.1

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

@@ -1,412 +1,5 @@
-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);
-}
-/**
-* Upsert (create or update)
-*/
-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
-});
-/**
-* 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 } : {},
-		...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;
-}
-/**
-* 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);
-}
-/**
-* 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 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)
-	};
-}
-/**
-* 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 } : {},
-		...options.arrayFilters ? { arrayFilters: options.arrayFilters } : {}
-	});
-	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 } : {},
-		...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;
-}
-/**
-* 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",
-		id: String(id)
-	};
-}
-/**
-* 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 = {}) {
-	const document = await Model.findOneAndDelete(query).session(options.session ?? null);
-	if (!document && options.throwOnNotFound !== false) throw createError(404, "Document not found");
-	return {
-		success: true,
-		message: "Deleted successfully",
-		...document ? { id: String(document._id) } : {}
-	};
-}
-/**
-* 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",
-		id: String(id),
-		soft: true
-	};
-}
-/**
-* 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",
-		id: String(id)
-	};
-}
-
-//#endregion
+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 = [
@@ -417,12 +10,14 @@ const BLOCKED_PIPELINE_STAGES = [
 	"$currentOp",
 	"$listSessions"
 ];
-/** Operators that can enable arbitrary code execution */
+/** Operators that can enable arbitrary code execution.
+* Note: $expr is intentionally NOT blocked — it's needed for pipeline-form
+* $lookup correlations (let + $match.$expr) and is a comparison operator,
+* not a code execution vector like $where/$function/$accumulator. */
 const DANGEROUS_OPERATORS = [
 	"$where",
 	"$function",
-	"$accumulator",
-	"$expr"
+	"$accumulator"
 ];
 /**
 * Fluent builder for MongoDB $lookup aggregation stage
@@ -498,6 +93,14 @@ var LookupBuilder = class LookupBuilder {
 		return this;
 	}
 	/**
+	* Control pipeline sanitization (default: true)
+	* Set to false for auto-generated pipelines that are known safe
+	*/
+	sanitize(enabled) {
+		this.options.sanitize = enabled;
+		return this;
+	}
+	/**
 	* Build the $lookup aggregation stage(s)
 	* Returns an array of pipeline stages including $lookup and optional $unwind
 	*
@@ -529,10 +132,16 @@ var LookupBuilder = class LookupBuilder {
 			} };
 		} else {
 			const safePipeline = this.options.sanitize !== false ? LookupBuilder.sanitizePipeline(pipeline) : pipeline;
+			let effectiveLet = letVars;
+			let effectivePipeline = safePipeline;
+			if (localField && foreignField && !letVars) {
+				effectiveLet = { lookupJoinVal: `$${localField}` };
+				effectivePipeline = [{ $match: { $expr: { $eq: [`$${foreignField}`, "$$lookupJoinVal"] } } }, ...safePipeline];
+			}
 			lookupStage = { $lookup: {
 				from,
-				...letVars && { let: letVars },
-				pipeline: safePipeline,
+				...effectiveLet && { let: effectiveLet },
+				pipeline: effectivePipeline,
 				as: outputField
 			} };
 		}
@@ -581,8 +190,29 @@ var LookupBuilder = class LookupBuilder {
 			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);
+			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 joinStage = { $match: { $expr: { $eq: [`$${lookup.foreignField}`, "$$lookupJoinVal"] } } };
+				const existing = lookup.pipeline || [];
+				builder.pipeline([
+					joinStage,
+					...existing,
+					{ $project: projection }
+				]);
+				builder.let({
+					lookupJoinVal: `$${lookup.localField}`,
+					...lookup.let || {}
+				});
+				builder.sanitize(false);
+			} else if (lookup.pipeline) {
+				builder.pipeline(lookup.pipeline);
+				if (lookup.let) builder.let(lookup.let);
+			} else if (lookup.let) builder.let(lookup.let);
 			return builder.build();
 		});
 	}
@@ -600,7 +230,7 @@ var LookupBuilder = class LookupBuilder {
 	* ```
 	*/
 	static nested(lookups) {
-		return lookups.flatMap((lookup, index) => {
+		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);
@@ -649,187 +279,567 @@ var LookupBuilder = class LookupBuilder {
 		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
+//#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 });
+	const builder = new LookupBuilder(from).localField(localField).foreignField(foreignField).as(as || from);
+	if (lookupOptions.single) builder.single(lookupOptions.single);
+	if (pipeline.length > 0) builder.pipeline(pipeline);
+	if (letVars) builder.let(letVars);
+	if (lookupOptions.sanitize === false) builder.sanitize(false);
+	aggPipeline.push(...builder.build());
+	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 = {}) {
+	const q = Model.distinct(field, query).session(options.session ?? null);
+	if (options.readPreference) q.read(options.readPreference);
+	return q;
+}
+/**
+* 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
+//#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);
+}
+/**
+* Upsert (create or update)
+*/
+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({
+	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",
+		id: String(id)
+	};
+}
+/**
+* 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 = {}) {
+	const document = await Model.findOneAndDelete(query).session(options.session ?? null);
+	if (!document && options.throwOnNotFound !== false) throw createError(404, "Document not found");
+	return {
+		success: true,
+		message: "Deleted successfully",
+		...document ? { id: String(document._id) } : {}
+	};
+}
+/**
+* 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",
+		id: String(id),
+		soft: true
+	};
+}
+/**
+* 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",
+		id: String(id)
+	};
+}
+//#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
 });
 /**
-* Execute aggregation pipeline
+* 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 } : {}
+	});
+}
+/**
+* Count documents matching query
 */
-async function aggregate(Model, pipeline, options = {}) {
-	const aggregation = Model.aggregate(pipeline);
-	if (options.session) aggregation.session(options.session);
-	return aggregation.exec();
+async function count(Model, query = {}, options = {}) {
+	const q = Model.countDocuments(query).session(options.session ?? null);
+	if (options.readPreference) q.read(options.readPreference);
+	return q;
 }
 /**
-* 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.
+* Check if document exists
 */
-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
-	};
+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.");
 }
 /**
-* Group documents by field value
+* Parse populate specification into consistent format
 */
-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);
+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];
 }
 /**
-* Count by field values
+* Update by ID
 */
-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 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;
 }
 /**
-* 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 query constraints (optimized)
+* Returns null if constraints not met (not an error)
 */
-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);
+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);
 }
 /**
-* Unwind array field
+* Update with validation (smart optimization)
+* 1-query on success, 2-queries for detailed errors
 */
-async function unwind(Model, field, options = {}) {
-	return aggregate(Model, [{ $unwind: {
-		path: `$${field}`,
-		preserveNullAndEmptyArrays: options.preserveEmpty !== false
-	} }], { session: options.session });
+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)
+	};
 }
 /**
-* 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 };