@classytic/mongokit 3.12.0 → 3.13.1

package/dist/{update-CDxPtpsk.mjs → update-C-3viiw1.mjs}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
-import { r as warn } from "./logger-8-VS1za6.mjs";
+import { n as warn } from "./logger-DprijP5h.mjs";
 import { t as createError } from "./error-B00pI7dV.mjs";
 import { isFilter } from "@classytic/repo-core/filter";
 //#region src/filter/compile.ts
@@ -13,9 +13,79 @@ import { isFilter } from "@classytic/repo-core/filter";
 * appropriately. This keeps the portable API ergonomic for apps that
 * write Mongo queries directly today.
 */
+/**
+* Operator shorthands arc propagates from bracket-syntax URL params.
+* Fastify parses `?createdAt[gte]=...&createdAt[lte]=...` into
+* `{ createdAt: { gte: '...', lte: '...' } }` — without `$` prefixes.
+* Arc intentionally forwards these as-is ("the kit's filter compiler
+* handles them"). This set covers every operator the arc aggregation
+* guard accepts in `parseDateRange` and `hasFilterOnField`.
+*/
+const SHORTHAND_OPS = new Set([
+	"eq",
+	"ne",
+	"gt",
+	"gte",
+	"lt",
+	"lte",
+	"in",
+	"nin",
+	"exists",
+	"regex",
+	"mod"
+]);
+/** Range operators whose string values should be coerced to Date. */
+const RANGE_OPS = new Set([
+	"gt",
+	"gte",
+	"lt",
+	"lte"
+]);
+/** ISO-8601 date-only or datetime string pattern. */
+const ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}/;
+/**
+* Coerce a string value to a Date when it looks like an ISO-8601 date.
+* Needed because MongoDB won't match a BSON Date field against a string
+* value even when using range operators — BSON type comparison treats
+* Date (type 9) and String (type 2) as distinct, so `{ createdAt: {
+* $gte: "2026-05-01" } }` never matches a Date-typed field.
+*/
+function tryCoerceDate(value) {
+	if (typeof value === "string" && ISO_DATE_RE.test(value)) {
+		const d = new Date(value);
+		return Number.isNaN(d.getTime()) ? value : d;
+	}
+	return value;
+}
+/**
+* Expand operator shorthand values in a plain Mongo-style query object.
+* Only expands nested objects whose keys are ALL in `SHORTHAND_OPS` — so
+* real nested documents (e.g. `address: { city: 'Dhaka' }`) pass through
+* unchanged, while `createdAt: { gte: '2026-04-01', lte: '2026-05-01' }`
+* becomes `createdAt: { $gte: Date(2026-04-01), $lte: Date(2026-05-01) }`.
+* String values on range operators are coerced to Date when they match the
+* ISO-8601 pattern, so BSON Date fields in MongoDB are compared correctly.
+*/
+function expandShorthands(obj) {
+	const out = {};
+	for (const [key, value] of Object.entries(obj)) {
+		if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+			const nested = value;
+			const keys = Object.keys(nested);
+			if (keys.length > 0 && keys.every((k) => !k.startsWith("$") && SHORTHAND_OPS.has(k))) {
+				const expanded = {};
+				for (const [op, opVal] of Object.entries(nested)) expanded[`$${op}`] = RANGE_OPS.has(op) ? tryCoerceDate(opVal) : opVal;
+				out[key] = expanded;
+				continue;
+			}
+		}
+		out[key] = value;
+	}
+	return out;
+}
 function compileFilterToMongo(input) {
 	if (!input) return {};
-	if (!isFilter(input)) return input;
+	if (!isFilter(input)) return expandShorthands(input);
 	return compile(input);
 }
 function compile(filter) {
@@ -475,17 +545,17 @@ async function aggregatePaginate(Model, pipeline, options = {}) {
 	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 }],
+		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 docs = result.docs || [];
+	const data = result.data || [];
 	const total = result.total[0]?.count || 0;
 	const pages = Math.ceil(total / limit);
 	return {
-		docs,
+		data,
 		total,
 		page,
 		limit,
@@ -662,54 +732,49 @@ var delete_exports = /* @__PURE__ */ __exportAll({
 	softDelete: () => softDelete
 });
 /**
-* Delete by ID
+* Delete by ID. Returns `null` on miss (matches `update()` convention) —
+* a second delete on the same id is a no-op, not an error.
 */
 async function deleteById(Model, id, options = {}) {
 	const query = {
 		_id: id,
 		...options.query
 	};
-	if (!await Model.findOneAndDelete(query).session(options.session ?? null)) return {
-		success: false,
-		message: "Document not found",
-		id: String(id)
-	};
+	if (!await Model.findOneAndDelete(query).session(options.session ?? null)) return null;
 	return {
-		success: true,
 		message: "Deleted successfully",
 		id: String(id)
 	};
 }
 /**
-* Delete many documents
+* Delete many documents. Always returns a {@link DeleteResult} (never
+* null) — a deleteMany with zero matches is a successful op with
+* `count: 0`, not a miss.
 */
 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
+* Delete by query. Returns `null` on miss unless `throwOnNotFound: true`.
 */
 async function deleteByQuery(Model, query, options = {}) {
 	const document = await Model.findOneAndDelete(query).session(options.session ?? null);
 	if (!document) {
 		if (options.throwOnNotFound === true) throw createError(404, "Document not found");
-		return {
-			success: false,
-			message: "Document not found"
-		};
+		return null;
 	}
 	return {
-		success: true,
 		message: "Deleted successfully",
 		id: String(document._id)
 	};
 }
 /**
-* Soft delete (set deleted flag)
+* Soft delete (set deleted flag). Returns `null` on miss for parity with
+* `deleteById`; callers that prefer a throw can wrap or use `throwOnNotFound`
+* pattern at the call site.
 */
 async function softDelete(Model, id, options = {}) {
 	if (!await Model.findByIdAndUpdate(id, {
@@ -719,16 +784,15 @@ async function softDelete(Model, id, options = {}) {
 	}, {
 		returnDocument: "after",
 		session: options.session
-	})) throw createError(404, "Document not found");
+	})) return null;
 	return {
-		success: true,
 		message: "Soft deleted successfully",
 		id: String(id),
 		soft: true
 	};
 }
 /**
-* Restore soft deleted document
+* Restore soft-deleted document. Returns `null` on miss.
 */
 async function restore(Model, id, options = {}) {
 	if (!await Model.findByIdAndUpdate(id, {
@@ -738,9 +802,8 @@ async function restore(Model, id, options = {}) {
 	}, {
 		returnDocument: "after",
 		session: options.session
-	})) throw createError(404, "Document not found");
+	})) return null;
 	return {
-		success: true,
 		message: "Restored successfully",
 		id: String(id)
 	};
@@ -834,16 +897,37 @@ async function getAll(Model, query = {}, options = {}) {
 	return mongoQuery.exec();
 }
 /**
-* Get or create document (upsert)
+* Get or create document (atomic upsert).
+*
+* Returns `{ doc, created }` so callers can disambiguate the two
+* outcomes without a follow-up read — load-bearing for race-detection
+* in idempotency stores, lock acquisition, and "ensure-exists" flows.
+*
+* `created: true` ⇔ this caller's `createData` won the race and was
+* just inserted; `created: false` ⇔ a doc matching `query` already
+* existed and was returned unchanged.
+*
+* Mongo: `includeResultMetadata: true` returns the raw `ModifyResult`
+* (`{ value, lastErrorObject, ok }`). `lastErrorObject.upserted` is
+* the `_id` of a freshly-inserted row — present iff this call inserted.
 */
 async function getOrCreate(Model, query, createData, options = {}) {
-	return Model.findOneAndUpdate(query, { $setOnInsert: createData }, {
+	const result = await Model.findOneAndUpdate(query, { $setOnInsert: createData }, {
 		upsert: true,
 		returnDocument: "after",
 		runValidators: true,
+		includeResultMetadata: true,
 		session: options.session,
 		...options.updatePipeline !== void 0 ? { updatePipeline: options.updatePipeline } : {}
 	});
+	if (result && typeof result === "object" && "value" in result) return {
+		doc: result.value,
+		created: result.lastErrorObject?.upserted != null
+	};
+	return {
+		doc: result,
+		created: false
+	};
 }
 /**
 * Count documents matching query

package/dist/utils/index.d.mts

@@ -1,94 +1,5 @@
-import { lt as SortSpec, q as PopulateSpec, rt as SelectSpec } from "../types-DXscZnLu.mjs";
-import { a as createFieldPreset, c as getMongooseProjection, i as configureLogger, l as createError, n as buildCrudSchemasFromMongooseSchema, o as filterResponseData, r as createMemoryCache, s as getFieldsForUser, t as buildCrudSchemasFromModel } from "../mongooseToJsonSchema-rtkdbBhf.mjs";
+import { a as createFieldPreset, c as getMongooseProjection, i as configureLogger, l as createError, n as buildCrudSchemasFromMongooseSchema, o as filterResponseData, r as createMemoryCache, s as getFieldsForUser, t as buildCrudSchemasFromModel } from "../mongooseToJsonSchema-BgRAaXX-.mjs";
 
-//#region src/utils/cache-keys.d.ts
-/**
- * Generate cache key for getById operations
- *
- * Includes select/populate/lean in the key so different query shapes
- * (e.g., plain vs populated, lean vs hydrated) never collide.
- *
- * Format: {prefix}:id:{model}:{documentId} (no options)
- * Format: {prefix}:id:{model}:{documentId}:{optionsHash} (with options)
- *
- * @example
- * byIdKey('mk', 'User', '507f1f77bcf86cd799439011')
- * // => 'mk:id:User:507f1f77bcf86cd799439011'
- * byIdKey('mk', 'User', '507f1f77bcf86cd799439011', { select: 'name email' })
- * // => 'mk:id:User:507f1f77bcf86cd799439011:a1b2c3d4'
- */
-declare function byIdKey(prefix: string, model: string, id: string, options?: {
-  select?: SelectSpec;
-  populate?: PopulateSpec;
-  lean?: boolean;
-}): string;
-/**
- * Generate cache key for single-document queries
- *
- * Format: {prefix}:one:{model}:{queryHash}
- *
- * @example
- * byQueryKey('mk', 'User', { email: 'john@example.com' })
- * // => 'mk:one:User:a1b2c3d4'
- */
-declare function byQueryKey(prefix: string, model: string, version: number, query: Record<string, unknown>, options?: {
-  select?: SelectSpec;
-  populate?: PopulateSpec;
-}): string;
-/**
- * Generate cache key for paginated list queries
- *
- * Format: {prefix}:list:{model}:{version}:{queryHash}
- *
- * The version component enables efficient bulk invalidation:
- * - On any mutation, bump the version
- * - All list cache keys become invalid without scanning/deleting each
- *
- * @example
- * listQueryKey('mk', 'User', 1, { filters: { status: 'active' }, page: 1, limit: 20 })
- * // => 'mk:list:User:1:e5f6g7h8'
- */
-declare function listQueryKey(prefix: string, model: string, version: number, params: {
-  filters?: Record<string, unknown>;
-  sort?: SortSpec;
-  page?: number;
-  limit?: number;
-  after?: string;
-  select?: SelectSpec;
-  populate?: PopulateSpec;
-  search?: string;
-  mode?: string;
-  lean?: boolean;
-  readPreference?: string;
-  hint?: string | Record<string, unknown>;
-  maxTimeMS?: number;
-  countStrategy?: string;
-}): string;
-/**
- * Generate cache key for collection version tag
- *
- * Format: {prefix}:ver:{model}
- *
- * Used to track mutation version for list invalidation
- */
-declare function versionKey(prefix: string, model: string): string;
-/**
- * Generate pattern for clearing all cache keys for a model
- *
- * Format: {prefix}:*:{model}:*
- *
- * @example
- * modelPattern('mk', 'User')
- * // => 'mk:*:User:*'
- */
-declare function modelPattern(prefix: string, model: string): string;
-/**
- * Generate pattern for clearing all list cache keys for a model
- *
- * Format: {prefix}:list:{model}:*
- */
-declare function listPattern(prefix: string, model: string): string;
-//#endregion
 //#region src/utils/id-resolution.d.ts
 /**
  * ID Resolution Primitive
@@ -146,4 +57,4 @@ declare function getSchemaIdType(schema?: SchemaLike | null): IdType;
  */
 declare function isValidIdForType(id: unknown, idType: IdType): boolean;
 //#endregion
-export { type IdType, buildCrudSchemasFromModel, buildCrudSchemasFromMongooseSchema, byIdKey, byQueryKey, configureLogger, createError, createFieldPreset, createMemoryCache, filterResponseData, getFieldsForUser, getMongooseProjection, getSchemaIdType, isObjectIdInstance, isValidIdForType, listPattern, listQueryKey, modelPattern, versionKey };
+export { type IdType, buildCrudSchemasFromModel, buildCrudSchemasFromMongooseSchema, configureLogger, createError, createFieldPreset, createMemoryCache, filterResponseData, getFieldsForUser, getMongooseProjection, getSchemaIdType, isObjectIdInstance, isValidIdForType };

package/dist/utils/index.mjs

@@ -1,6 +1,6 @@
-import { t as configureLogger } from "../logger-8-VS1za6.mjs";
+import { t as configureLogger } from "../logger-DprijP5h.mjs";
 import { t as createError } from "../error-B00pI7dV.mjs";
-import { n as isObjectIdInstance, r as isValidIdForType, t as getSchemaIdType } from "../id-resolution-e4BT9zAV.mjs";
-import { a as byIdKey, c as listQueryKey, i as getMongooseProjection, l as modelPattern, n as filterResponseData, o as byQueryKey, r as getFieldsForUser, s as listPattern, t as createFieldPreset, u as versionKey } from "../field-selection-dI0m4RBs.mjs";
-import { n as buildCrudSchemasFromMongooseSchema, r as createMemoryCache, t as buildCrudSchemasFromModel } from "../mongooseToJsonSchema-B187ufOP.mjs";
-export { buildCrudSchemasFromModel, buildCrudSchemasFromMongooseSchema, byIdKey, byQueryKey, configureLogger, createError, createFieldPreset, createMemoryCache, filterResponseData, getFieldsForUser, getMongooseProjection, getSchemaIdType, isObjectIdInstance, isValidIdForType, listPattern, listQueryKey, modelPattern, versionKey };
+import { i as getMongooseProjection, n as filterResponseData, r as getFieldsForUser, t as createFieldPreset } from "../field-selection-Br3WPOEb.mjs";
+import { n as isObjectIdInstance, r as isValidIdForType, t as getSchemaIdType } from "../id-resolution-B0Odvvou.mjs";
+import { n as buildCrudSchemasFromMongooseSchema, r as createMemoryCache, t as buildCrudSchemasFromModel } from "../mongooseToJsonSchema-BYbG894y.mjs";
+export { buildCrudSchemasFromModel, buildCrudSchemasFromMongooseSchema, configureLogger, createError, createFieldPreset, createMemoryCache, filterResponseData, getFieldsForUser, getMongooseProjection, getSchemaIdType, isObjectIdInstance, isValidIdForType };