@classytic/mongokit 3.38.1 → 3.40.0

package/dist/{update-jSXp3nu3.mjs → update-DG0fCwRJ.mjs}

@@ -2,6 +2,215 @@ import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import { n as warn } from "./logger-K7dPmu2U.mjs";
 import { t as createError } from "./error-BuByZwKU.mjs";
 import { coerceFilterDates, isFilter } from "@classytic/repo-core/filter";
+//#region src/actions/create.ts
+var create_exports = /* @__PURE__ */ __exportAll({
+	create: () => create,
+	createDefault: () => createDefault,
+	createMany: () => createMany,
+	isCreateManyPartialError: () => isCreateManyPartialError,
+	upsert: () => upsert
+});
+/**
+* Create single document
+*/
+async function create(Model, data, options = {}) {
+	const document = new Model(data);
+	await document.save({ session: options.session });
+	return document;
+}
+/** Narrow a caught error to one carrying a partial-write report. */
+function isCreateManyPartialError(err) {
+	return err instanceof Error && typeof err.partial === "object" && err.partial !== null;
+}
+/** Pull the positional failures out of a driver bulk-write error. */
+function readFailures(err, dataArray) {
+	const raw = err.writeErrors;
+	return (Array.isArray(raw) ? raw : raw ? [raw] : []).map((entry) => {
+		const e = entry;
+		const inner = e.err ?? e;
+		const index = Number(inner.index ?? e.index ?? -1);
+		return {
+			index,
+			doc: dataArray[index] ?? {},
+			...typeof inner.code === "number" ? { code: inner.code } : {},
+			message: String(inner.errmsg ?? inner.message ?? e.message ?? "write failed")
+		};
+	});
+}
+/**
+* Create multiple documents.
+*
+* **A rejection does NOT mean nothing was written.** Neither ordering does:
+* `ordered: true` stops at the first failure and keeps everything before it,
+* `ordered: false` keeps everything valid. Measured on a six-document batch
+* with a conflict in the middle — ordered wrote 3, unordered wrote 5. Only a
+* transaction gives all-or-nothing.
+*
+* So the rejection carries a `partial` report naming what landed and what did
+* not, because the alternative is a caller retrying the whole batch and
+* double-writing everything that had already succeeded. Use it to retry only
+* `failed`, or to reconcile — and prefer a unique index or an idempotency key
+* for anything that will be retried automatically.
+*/
+async function createMany(Model, dataArray, options = {}) {
+	try {
+		return await Model.insertMany(dataArray, {
+			session: options.session,
+			ordered: options.ordered === true
+		});
+	} catch (err) {
+		const inserted = err.insertedDocs;
+		const failed = readFailures(err, dataArray);
+		if (Array.isArray(inserted) || failed.length > 0) err.partial = {
+			inserted: Array.isArray(inserted) ? inserted : [],
+			failed
+		};
+		throw err;
+	}
+}
+/**
+* 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/filter/cast-schema.ts
+/** Operators whose operand is a single scalar to cast. */
+const SCALAR_OPS = /* @__PURE__ */ new Set([
+	"$eq",
+	"$ne",
+	"$gt",
+	"$gte",
+	"$lt",
+	"$lte"
+]);
+/** Operators whose operand is an array of scalars to cast element-wise. */
+const ARRAY_OPS = /* @__PURE__ */ new Set(["$in", "$nin"]);
+/** Logical operators whose operand is an ARRAY of sub-filters. */
+const LOGICAL_ARRAY_OPS$1 = /* @__PURE__ */ new Set([
+	"$and",
+	"$or",
+	"$nor"
+]);
+/** Logical operators whose operand is a SINGLE nested sub-filter. */
+const LOGICAL_OBJECT_OPS = /* @__PURE__ */ new Set(["$not"]);
+function isPlainObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date);
+}
+/**
+* Cast one value through a schema path. Returns the original value when the
+* path is unknown, the value is nullish, or the cast throws — never raises.
+*/
+function castValue(schema, field, value) {
+	if (value === null || value === void 0) return value;
+	if (typeof value === "object" && !(value instanceof Date)) return value;
+	let schemaType;
+	try {
+		schemaType = schema.path(field);
+	} catch {
+		return value;
+	}
+	if (!schemaType || typeof schemaType.cast !== "function") return value;
+	try {
+		return schemaType.cast(value);
+	} catch {
+		return value;
+	}
+}
+/**
+* Cast the operand(s) of a field-level operator object, leaving operators we
+* don't understand (`$regex`, `$exists`, `$size`, `$elemMatch`, …) alone.
+*/
+function castOperatorObject(schema, field, ops) {
+	let changed = false;
+	const out = {};
+	for (const [op, operand] of Object.entries(ops)) if (SCALAR_OPS.has(op)) {
+		const next = castValue(schema, field, operand);
+		out[op] = next;
+		if (next !== operand) changed = true;
+	} else if (ARRAY_OPS.has(op) && Array.isArray(operand)) {
+		const arr = operand.map((entry) => castValue(schema, field, entry));
+		out[op] = arr;
+		if (arr.some((v, i) => v !== operand[i])) changed = true;
+	} else out[op] = operand;
+	return changed ? out : ops;
+}
+/**
+* Cast a record-shape Mongo filter against a Mongoose schema so it is safe to
+* hand to a `$match` stage. Recurses `$and` / `$or` / `$nor` / `$not`, since a
+* policy/tenant scope conjoined with a caller filter nests one level down.
+*
+* Filter IR nodes and non-objects pass through untouched — IR values are built
+* in code (already correctly typed) and carry no schema paths to resolve.
+*
+* @example
+* ```ts
+* // organizationId is an ObjectId column; arc supplies the scope id as a string
+* castFilterToSchema({ organizationId: '6a6a…' }, Order.schema)
+* // → { organizationId: ObjectId('6a6a…') }
+* ```
+*/
+function castFilterToSchema(filter, schema) {
+	if (!isPlainObject(filter)) return filter;
+	if (typeof filter.op === "string") return filter;
+	let changed = false;
+	const out = {};
+	for (const [key, value] of Object.entries(filter)) {
+		if (LOGICAL_ARRAY_OPS$1.has(key) && Array.isArray(value)) {
+			const arr = value.map((entry) => castFilterToSchema(entry, schema));
+			out[key] = arr;
+			if (arr.some((v, i) => v !== value[i])) changed = true;
+			continue;
+		}
+		if (LOGICAL_OBJECT_OPS.has(key) && isPlainObject(value)) {
+			const nested = castFilterToSchema(value, schema);
+			out[key] = nested;
+			if (nested !== value) changed = true;
+			continue;
+		}
+		if (key.startsWith("$")) {
+			out[key] = value;
+			continue;
+		}
+		if (isPlainObject(value)) {
+			const keys = Object.keys(value);
+			if (keys.length > 0 && keys.every((k) => k.startsWith("$"))) {
+				const nextOps = castOperatorObject(schema, key, value);
+				out[key] = nextOps;
+				if (nextOps !== value) changed = true;
+				continue;
+			}
+			out[key] = value;
+			continue;
+		}
+		const next = castValue(schema, key, value);
+		out[key] = next;
+		if (next !== value) changed = true;
+	}
+	return changed ? out : filter;
+}
+//#endregion
 //#region src/filter/compile.ts
 /**
 * Compile a Filter IR node to a MongoDB query object. Returns `{}`
@@ -21,6 +230,12 @@ import { coerceFilterDates, isFilter } from "@classytic/repo-core/filter";
 * handles them"). This set covers every operator the arc aggregation
 * guard accepts in `parseDateRange` and `hasFilterOnField`.
 */
+/**
+* The query-shorthand vocabulary, shared with `compileFilterToMongoExpr` so
+* both filter surfaces recognise the same operator names. Exported because a
+* second private copy is how the two compilers drifted apart in the first
+* place: one accepted `{ f: { eq: 'x' } }` and the other read it as a literal.
+*/
 const SHORTHAND_OPS = /* @__PURE__ */ new Set([
 	"eq",
 	"ne",
@@ -98,7 +313,10 @@ function schemaDateOracle(schema) {
 }
 function compileFilterToMongo(input, schema) {
 	if (!input) return {};
-	if (!isFilter(input)) return coerceFilterDates(expandShorthands(input), schema ? { isDateField: schemaDateOracle(schema) } : void 0);
+	if (!isFilter(input)) {
+		const expanded = expandShorthands(input);
+		return coerceFilterDates(schema ? castFilterToSchema(expanded, schema) : expanded, schema ? { isDateField: schemaDateOracle(schema) } : void 0);
+	}
 	return compile(input);
 }
 function compile(filter) {
@@ -106,7 +324,7 @@ function compile(filter) {
 		case "true": return {};
 		case "false": return { $expr: false };
 		case "eq": return { [filter.field]: filter.value };
-		case "ne": return filter.value === null ? { [filter.field]: { $ne: null } } : { $and: [{ [filter.field]: { $ne: filter.value } }, { [filter.field]: { $ne: null } }] };
+		case "ne": return filter.value === null ? { [filter.field]: { $ne: null } } : { [filter.field]: { $nin: [filter.value, null] } };
 		case "gt": return { [filter.field]: { $gt: filter.value } };
 		case "gte": return { [filter.field]: { $gte: filter.value } };
 		case "lt": return { [filter.field]: { $lt: filter.value } };
@@ -116,7 +334,7 @@ function compile(filter) {
 			return { [filter.field]: { $in: [...filter.values] } };
 		case "nin":
 			if (filter.values.length === 0) return {};
-			return { [filter.field]: { $nin: [...filter.values] } };
+			return { [filter.field]: { $nin: filter.values.includes(null) ? [...filter.values] : [...filter.values, null] } };
 		case "exists": return filter.exists ? { [filter.field]: { $ne: null } } : { [filter.field]: null };
 		case "like": return { [filter.field]: likeToRegex(filter.pattern, filter.caseSensitivity) };
 		/**
@@ -140,10 +358,10 @@ function compile(filter) {
 			$options: filter.flags
 		} : { $regex: filter.pattern } };
 		case "and": {
-			if (filter.children.length === 0) return {};
-			const parts = filter.children.map(compile);
+			const parts = filter.children.map(compile).filter((part) => Object.keys(part).length > 0);
+			if (parts.length === 0) return {};
 			if (parts.length === 1) return parts[0];
-			return { $and: parts };
+			return mergeConjunction(parts) ?? { $and: parts };
 		}
 		case "or": {
 			if (filter.children.length === 0) return { $expr: false };
@@ -175,7 +393,7 @@ function compile(filter) {
 * same way sqlitekit's `LIKE` semantically does.
 */
 function likeToRegex(pattern, caseSensitivity) {
-	let out = "^";
+	let out = "";
 	for (let i = 0; i < pattern.length; i++) {
 		const ch = pattern[i];
 		if (ch === "\\" && i + 1 < pattern.length) {
@@ -190,12 +408,44 @@ function likeToRegex(pattern, caseSensitivity) {
 		else if (ch === "_") out += ".";
 		else out += escapeRegexChar(ch);
 	}
-	out += "$";
-	return caseSensitivity === "sensitive" ? { $regex: out } : {
-		$regex: out,
+	const source = `${out.startsWith(".*") ? out.slice(2) : `^${out}`}`;
+	const anchored = source.endsWith(".*") && !source.endsWith("\\.*") ? source.slice(0, -2) : `${source}$`;
+	return caseSensitivity === "sensitive" ? { $regex: anchored } : {
+		$regex: anchored,
 		$options: "i"
 	};
 }
+/**
+* Merge an AND of field conditions into one object (`{ price: { $gte, $lte } }`) when no field
+* repeats an operator; `undefined` when a merge would change meaning, so the caller keeps `$and`.
+*/
+function mergeConjunction(parts) {
+	const merged = {};
+	for (const part of parts) for (const [field, condition] of Object.entries(part)) {
+		if (field.startsWith("$")) return void 0;
+		if (!(field in merged)) {
+			merged[field] = condition;
+			continue;
+		}
+		const left = asOperators(merged[field]);
+		const right = asOperators(condition);
+		if (!left || !right || Object.keys(right).some((op) => op in left)) return void 0;
+		merged[field] = {
+			...left,
+			...right
+		};
+	}
+	return merged;
+}
+/** A field condition as an operator object — an equality value becomes `{ $eq }`. */
+function asOperators(condition) {
+	if (condition instanceof RegExp || Array.isArray(condition)) return void 0;
+	if (condition !== null && typeof condition === "object" && !(condition instanceof Date)) {
+		const keys = Object.keys(condition);
+		return keys.length > 0 && keys.every((k) => k.startsWith("$")) ? condition : void 0;
+	}
+	return condition === null ? void 0 : { $eq: condition };
+}
 function escapeRegexChar(ch) {
 	return /[.*+?^${}()|[\]\\]/.test(ch) ? `\\${ch}` : ch;
 }
@@ -611,24 +861,35 @@ async function aggregate(Model, pipeline, options = {}) {
 	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.
+* Aggregate with pagination.
+*
+* Page and count run as TWO concurrent pipelines rather than one `$facet`.
+* `$facet` bundles every returned document plus the count into a SINGLE output
+* document, and no stage may exceed 16MB — so a page of large documents failed
+* with `BSONObjectTooLarge` instead of paginating, and the only defence was a
+* warning above an arbitrary limit of 1000 that told the caller to go
+* elsewhere. `$facet` also cannot use an index for the stages inside it.
+*
+* The trade: two reads, so a concurrent write between them can leave `total`
+* a document out of step with `data` — the same trade `PaginationEngine`
+* already makes on both its offset and aggregate paths.
 */
 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: {
-		data: [{ $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 data = result.data || [];
-	const total = result.total[0]?.count || 0;
+	const run = (stages) => {
+		const aggregation = Model.aggregate(stages);
+		if (options.session) aggregation.session(options.session);
+		return aggregation.exec();
+	};
+	const [dataRows, countRows] = await Promise.all([run([
+		...pipeline,
+		{ $skip: skip },
+		{ $limit: limit }
+	]), run([...pipeline, { $count: "count" }])]);
+	const data = dataRows || [];
+	const total = countRows[0]?.count || 0;
 	const pages = Math.ceil(total / limit);
 	return {
 		data,
@@ -748,57 +1009,6 @@ async function minMax(Model, field, query = {}, options = {}) {
 	};
 }
 //#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 === true
-	});
-}
-/**
-* 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,
@@ -813,8 +1023,8 @@ var delete_exports = /* @__PURE__ */ __exportAll({
 */
 async function deleteById(Model, id, options = {}) {
 	const query = {
-		_id: id,
-		...options.query
+		...options.query,
+		_id: id
 	};
 	if (!await Model.findOneAndDelete(query).session(options.session ?? null)) return null;
 	return {
@@ -1053,8 +1263,8 @@ function parsePopulate(populate) {
 async function update(Model, id, data, options = {}) {
 	assertUpdatePipelineAllowed(data, options.updatePipeline);
 	const query = {
-		_id: id,
-		...options.query
+		...options.query,
+		_id: id
 	};
 	return await Model.findOneAndUpdate(query, data, {
 		returnDocument: "after",
@@ -1071,8 +1281,8 @@ async function update(Model, id, data, options = {}) {
 async function updateWithConstraints(Model, id, data, constraints = {}, options = {}) {
 	assertUpdatePipelineAllowed(data, options.updatePipeline);
 	const query = {
-		_id: id,
-		...constraints
+		...constraints,
+		_id: id
 	};
 	return await Model.findOneAndUpdate(query, data, {
 		returnDocument: "after",
@@ -1097,8 +1307,8 @@ async function updateWithValidation(Model, id, data, validationOptions = {}, opt
 		};
 	}
 	const findQuery = {
-		_id: id,
-		...options.query
+		...options.query,
+		_id: id
 	};
 	const existing = await Model.findOne(findQuery).select(options.select || "").session(options.session ?? null).lean();
 	if (!existing) return {
@@ -1204,4 +1414,4 @@ async function pullFromArray(Model, id, field, value, options = {}) {
 	return update(Model, id, { $pull: { [field]: value } }, options);
 }
 //#endregion
-export { upsert as _, count as a, LookupBuilder as b, getByQuery as c, deleteById as d, deleteByQuery as f, create_exports as g, createMany as h, update_exports as i, getOrCreate as l, create as m, update as n, exists as o, delete_exports as p, updateByQuery as r, getById as s, findOneAndUpdate as t, read_exports as u, aggregate_exports as v, compileFilterToMongo as x, distinct as y };
+export { isCreateManyPartialError as C, create_exports as S, SHORTHAND_OPS as _, count as a, create as b, getByQuery as c, deleteById as d, deleteByQuery as f, LookupBuilder as g, distinct as h, update_exports as i, getOrCreate as l, aggregate_exports as m, update as n, exists as o, delete_exports as p, updateByQuery as r, getById as s, findOneAndUpdate as t, read_exports as u, compileFilterToMongo as v, upsert as w, createMany as x, castFilterToSchema as y };

package/dist/utils/index.d.mts

@@ -1,4 +1,4 @@
-import { _ as getMongooseProjection, a as createMemoryCache, b as createError, c as IdType, d as isObjectIdInstance, f as isValidIdForType, g as getFieldsForUser, h as filterResponseData, i as buildCrudSchemasFromMongooseSchema, l as getSchemaIdType, m as createFieldPreset, n as CrudSchemasFramework, o as LoggerConfig, p as toObjectId, r as buildCrudSchemasFromModel, s as configureLogger, t as toPlain, v as CreateErrorOptions, y as ParseDuplicateKeyOptions } from "../to-plain-Dyz_qvuo.mjs";
+import { _ as getMongooseProjection, a as createMemoryCache, b as createError, c as IdType, d as isObjectIdInstance, f as isValidIdForType, g as getFieldsForUser, h as filterResponseData, i as buildCrudSchemasFromMongooseSchema, l as getSchemaIdType, m as createFieldPreset, n as CrudSchemasFramework, o as LoggerConfig, p as toObjectId, r as buildCrudSchemasFromModel, s as configureLogger, t as toPlain, v as CreateErrorOptions, y as ParseDuplicateKeyOptions } from "../to-plain-k7SjNlSS.mjs";
 import { ClientSession, Model } from "mongoose";
 //#region src/utils/id-chunks.d.ts
 /**