@classytic/mongokit 3.29.0 → 3.30.0

package/dist/{timestamp.plugin-CFL6LlYZ.mjs → timestamp.plugin-ChFRcLRJ.mjs}

@@ -1,6 +1,5 @@
-import { c as ALL_OPERATIONS, t as HOOK_PRIORITY, u as OP_REGISTRY } from "./Repository-DThvFCaV.mjs";
+import { c as ALL_OPERATIONS, t as HOOK_PRIORITY, u as OP_REGISTRY } from "./Repository-X7U2d0kU.mjs";
 import { n as warn } from "./logger-K7dPmu2U.mjs";
-import { t as createError } from "./error-BuByZwKU.mjs";
 import { throwIfAborted, withRetry } from "@classytic/repo-core/repository";
 import mongoose from "mongoose";
 import { cachePlugin } from "@classytic/repo-core/cache";
@@ -632,81 +631,6 @@ var AuditTrailQuery = class {
 	}
 };
 //#endregion
-//#region src/plugins/batch-operations.plugin.ts
-/**
-* Batch operations plugin.
-*
-* @example
-* const repo = new Repository(Model, [
-*   methodRegistryPlugin(),
-*   batchOperationsPlugin(),
-* ]);
-*
-* // updateMany + deleteMany are primitives on Repository — no plugin needed.
-* await repo.updateMany({ status: 'pending' }, { status: 'active' });
-* await repo.deleteMany({ status: 'deleted' });
-*
-* // bulkWrite is what this plugin contributes.
-* await repo.bulkWrite([...ops]);
-*/
-function batchOperationsPlugin() {
-	return {
-		name: "batch-operations",
-		apply(repo) {
-			if (!repo.registerMethod) throw new Error("batchOperationsPlugin requires methodRegistryPlugin");
-			/**
-			* Execute heterogeneous bulk write operations in a single database call.
-			*
-			* Supports insertOne, updateOne, updateMany, deleteOne, deleteMany, and replaceOne
-			* operations mixed together for maximum efficiency.
-			*
-			* @example
-			* await repo.bulkWrite([
-			*   { insertOne: { document: { name: 'New Item', price: 10 } } },
-			*   { updateOne: { filter: { _id: id1 }, update: { $inc: { views: 1 } } } },
-			*   { updateMany: { filter: { status: 'draft' }, update: { $set: { status: 'published' } } } },
-			*   { deleteOne: { filter: { _id: id2 } } },
-			* ]);
-			*/
-			repo.registerMethod("bulkWrite", async function(operations, options = {}) {
-				const context = await this._buildContext("bulkWrite", {
-					operations,
-					...options
-				});
-				try {
-					const finalOps = context.operations || operations;
-					if (!finalOps || finalOps.length === 0) throw createError(400, "bulkWrite requires at least one operation");
-					const result = await this.Model.bulkWrite(finalOps, {
-						ordered: options.ordered ?? true,
-						session: options.session
-					});
-					const bulkResult = {
-						ok: result.ok,
-						insertedCount: result.insertedCount,
-						upsertedCount: result.upsertedCount,
-						matchedCount: result.matchedCount,
-						modifiedCount: result.modifiedCount,
-						deletedCount: result.deletedCount,
-						insertedIds: result.insertedIds,
-						upsertedIds: result.upsertedIds
-					};
-					await this.emitAsync("after:bulkWrite", {
-						context,
-						result: bulkResult
-					});
-					return bulkResult;
-				} catch (error) {
-					this.emit("error:bulkWrite", {
-						context,
-						error
-					});
-					throw this._handleError(error);
-				}
-			});
-		}
-	};
-}
-//#endregion
 //#region src/plugins/custom-id.plugin.ts
 /**
 * Custom ID Plugin
@@ -893,7 +817,6 @@ function dateSequentialId(options) {
 			default:
 				datePart = `${year}${separator}${month}`;
 				counterKey = `${model.modelName}:${year}-${month}`;
-				break;
 		}
 		const seq = await getNextSequence(counterKey, 1, context._counterConnection, context.session);
 		return `${prefix}${separator}${datePart}${separator}${String(seq).padStart(padding, "0")}`;
@@ -972,50 +895,18 @@ function customIdPlugin(options) {
 					docsNeedingIds.push(doc);
 				}
 				if (docsNeedingIds.length === 0) return;
-				for (const doc of docsNeedingIds) doc[fieldName] = await options.generator({
-					...context,
-					data: doc
-				});
+				for (const doc of docsNeedingIds) {
+					const id = await options.generator({
+						...context,
+						data: doc
+					});
+					doc[fieldName] = id;
+				}
 			});
 		}
 	};
 }
 //#endregion
-//#region src/plugins/method-registry.plugin.ts
-/**
-* Method registry plugin that enables dynamic method registration
-*/
-function methodRegistryPlugin() {
-	return {
-		name: "method-registry",
-		apply(repo) {
-			const registeredMethods = [];
-			/**
-			* Register a new method on the repository instance
-			*/
-			repo.registerMethod = (name, fn) => {
-				if (repo[name]) throw new Error(`Cannot register method '${name}': Method already exists on repository. Choose a different name or use a plugin that doesn't conflict.`);
-				if (!name || typeof name !== "string") throw new Error("Method name must be a non-empty string");
-				if (typeof fn !== "function") throw new Error(`Method '${name}' must be a function`);
-				repo[name] = fn.bind(repo);
-				registeredMethods.push(name);
-				repo.emit("method:registered", {
-					name,
-					fn
-				});
-			};
-			/**
-			* Check if a method is registered
-			*/
-			repo.hasMethod = (name) => typeof repo[name] === "function";
-			/**
-			* Get list of all dynamically registered methods
-			*/
-			repo.getRegisteredMethods = () => [...registeredMethods];
-		}
-	};
-}
-//#endregion
 //#region src/plugins/multi-tenant.plugin.ts
 /**
 * Multi-Tenant Plugin
@@ -1147,34 +1038,32 @@ function multiTenantPlugin(options = {}) {
 								}
 							}
 							break;
-						case "operations":
-							if (context.operations) {
-								const ops = context.operations;
-								for (const subOp of ops) {
-									for (const key of [
-										"updateOne",
-										"updateMany",
-										"deleteOne",
-										"deleteMany",
-										"replaceOne"
-									]) {
-										const opBody = subOp[key];
-										if (opBody?.filter) {
-											assertTenantValue(opBody.filter[tenantField], `bulkWrite ${key}.filter`);
-											opBody.filter = {
-												...opBody.filter,
-												[tenantField]: castId
-											};
-										}
-									}
-									const insertBody = subOp.insertOne;
-									if (insertBody?.document) {
-										assertTenantValue(insertBody.document[tenantField], "bulkWrite insertOne.document");
-										insertBody.document[tenantField] = castId;
+						case "operations": if (context.operations) {
+							const ops = context.operations;
+							for (const subOp of ops) {
+								for (const key of [
+									"updateOne",
+									"updateMany",
+									"deleteOne",
+									"deleteMany",
+									"replaceOne"
+								]) {
+									const opBody = subOp[key];
+									if (opBody?.filter) {
+										assertTenantValue(opBody.filter[tenantField], `bulkWrite ${key}.filter`);
+										opBody.filter = {
+											...opBody.filter,
+											[tenantField]: castId
+										};
 									}
 								}
+								const insertBody = subOp.insertOne;
+								if (insertBody?.document) {
+									assertTenantValue(insertBody.document[tenantField], "bulkWrite insertOne.document");
+									insertBody.document[tenantField] = castId;
+								}
 							}
-							break;
+						}
 					}
 				}, { priority: HOOK_PRIORITY.POLICY });
 			}
@@ -1542,4 +1431,4 @@ function timestampPlugin() {
 	};
 }
 //#endregion
-export { methodRegistryPlugin as a, getNextSequence as c, cachePlugin as d, batchOperationsPlugin as f, auditLogPlugin as g, ensureAuditTrailReady as h, multiTenantPlugin as i, prefixedId as l, auditTrailPlugin as m, softDeletePlugin as n, customIdPlugin as o, AuditTrailQuery as p, adminBypass$1 as r, dateSequentialId as s, timestampPlugin as t, sequentialId as u };
+export { customIdPlugin as a, prefixedId as c, AuditTrailQuery as d, auditTrailPlugin as f, multiTenantPlugin as i, sequentialId as l, auditLogPlugin as m, softDeletePlugin as n, dateSequentialId as o, ensureAuditTrailReady as p, adminBypass$1 as r, getNextSequence as s, timestampPlugin as t, cachePlugin as u };

package/dist/{to-plain-DkF5px0R.d.mts → to-plain-BuX1RUZV.d.mts}

@@ -1,5 +1,5 @@
-import { v as UserContext } from "./repository-DCHRWRXw.mjs";
-import { r as FieldPreset } from "./plugin-options-vFufQZMZ.mjs";
+import { v as UserContext } from "./repository-Q16ErTu8.mjs";
+import { r as FieldPreset } from "./plugin-options-BsFH0sTi.mjs";
 import mongoose, { Schema } from "mongoose";
 import { CacheAdapter } from "@classytic/repo-core/cache";
 import { CrudSchemas, SchemaBuilderOptions } from "@classytic/repo-core/schema";
@@ -288,8 +288,16 @@ declare function buildCrudSchemasFromMongooseSchema(mongooseSchema: Schema, opti
  * field accepts this function directly with no glue. Future Mongo-shaped
  * kits implementing the same contract are interchangeable at the adapter
  * boundary.
+ *
+ * GENERIC over the document type, not fixed to `Model<unknown>`. Only
+ * `.schema` is read, so the document type is irrelevant here — but Mongoose's
+ * `Model<T>` is INVARIANT through `schema.static`, so a hard `Model<unknown>`
+ * parameter rejects every concretely-typed model a host actually has. That is
+ * not theoretical: it made `arc init`'s generated `example.schemas.ts` fail
+ * `tsc` on a brand-new project. Instantiating `TDoc = unknown` still satisfies
+ * `SchemaGenerator<Model<unknown>>`, so the contract claim above is unchanged.
  */
-declare function buildCrudSchemasFromModel(mongooseModel: mongoose.Model<unknown>, options?: SchemaBuilderOptions): CrudSchemasFramework;
+declare function buildCrudSchemasFromModel<TDoc = unknown>(mongooseModel: mongoose.Model<TDoc>, options?: SchemaBuilderOptions): CrudSchemasFramework;
 //#endregion
 //#region src/utils/to-plain.d.ts
 /**
@@ -320,4 +328,4 @@ declare function buildCrudSchemasFromModel(mongooseModel: mongoose.Model<unknown
  */
 declare function toPlain<T>(value: T): T;
 //#endregion
-export { isDuplicateKeyError as _, configureLogger as a, idVariants as c, toObjectId as d, createFieldPreset as f, createError as g, getMongooseProjection as h, createMemoryCache as i, isObjectIdInstance as l, getFieldsForUser as m, buildCrudSchemasFromModel as n, IdType as o, filterResponseData as p, buildCrudSchemasFromMongooseSchema as r, getSchemaIdType as s, toPlain as t, isValidIdForType as u, parseDuplicateKeyError as v };
+export { parseDuplicateKeyError as S, getMongooseProjection as _, createMemoryCache as a, createError as b, IdType as c, isObjectIdInstance as d, isValidIdForType as f, getFieldsForUser as g, filterResponseData as h, buildCrudSchemasFromMongooseSchema as i, getSchemaIdType as l, createFieldPreset as m, CrudSchemasFramework as n, LoggerConfig as o, toObjectId as p, buildCrudSchemasFromModel as r, configureLogger as s, toPlain as t, idVariants as u, CreateErrorOptions as v, isDuplicateKeyError as x, ParseDuplicateKeyOptions as y };

package/dist/{update-CI2NdAW6.mjs → update-DHdXdOk_.mjs}

@@ -77,9 +77,28 @@ function expandShorthands(obj) {
 	}
 	return out;
 }
-function compileFilterToMongo(input) {
+/**
+* Build the schema oracle `coerceFilterDates` needs from a mongoose schema.
+*
+* A path is date-coercible only when the schema says it is a Date. Everything else — most
+* importantly a `String` path whose values are ISO-shaped, like a `civilDate` of
+* `'2026-08-02'` — keeps its operand verbatim.
+*
+* Unknown paths default to TRUE (coerce). A filter on a path the schema does not declare
+* is usually a `strict: false` extension or a nested/dynamic key, and the old
+* value-shape-only behaviour is the safer default there: coercing a genuine date string is
+* right far more often than not for an undeclared path.
+*/
+function schemaDateOracle(schema) {
+	return (field) => {
+		const path = schema.path(field);
+		if (!path) return true;
+		return path.instance === "Date";
+	};
+}
+function compileFilterToMongo(input, schema) {
 	if (!input) return {};
-	if (!isFilter(input)) return coerceFilterDates(expandShorthands(input));
+	if (!isFilter(input)) return coerceFilterDates(expandShorthands(input), schema ? { isDateField: schemaDateOracle(schema) } : void 0);
 	return compile(input);
 }
 function compile(filter) {

package/dist/utils/index.d.mts

@@ -1,2 +1,2 @@
-import { a as configureLogger, d as toObjectId, f as createFieldPreset, g as createError, h as getMongooseProjection, i as createMemoryCache, l as isObjectIdInstance, m as getFieldsForUser, n as buildCrudSchemasFromModel, o as IdType, p as filterResponseData, r as buildCrudSchemasFromMongooseSchema, s as getSchemaIdType, t as toPlain, u as isValidIdForType } from "../to-plain-DkF5px0R.mjs";
-export { type IdType, buildCrudSchemasFromModel, buildCrudSchemasFromMongooseSchema, configureLogger, createError, createFieldPreset, createMemoryCache, filterResponseData, getFieldsForUser, getMongooseProjection, getSchemaIdType, isObjectIdInstance, isValidIdForType, toObjectId, toPlain };
+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-BuX1RUZV.mjs";
+export { type CreateErrorOptions, type CrudSchemasFramework, type IdType, type LoggerConfig, type ParseDuplicateKeyOptions, buildCrudSchemasFromModel, buildCrudSchemasFromMongooseSchema, configureLogger, createError, createFieldPreset, createMemoryCache, filterResponseData, getFieldsForUser, getMongooseProjection, getSchemaIdType, isObjectIdInstance, isValidIdForType, toObjectId, toPlain };

package/dist/utils/index.mjs

@@ -3,5 +3,5 @@ import { t as configureLogger } from "../logger-K7dPmu2U.mjs";
 import { t as createError } from "../error-BuByZwKU.mjs";
 import { i as getMongooseProjection, n as filterResponseData, r as getFieldsForUser, t as createFieldPreset } from "../field-selection-FSQFLpsU.mjs";
 import { n as createMemoryCache, t as toPlain } from "../to-plain-vksRrLtc.mjs";
-import { n as buildCrudSchemasFromMongooseSchema, t as buildCrudSchemasFromModel } from "../mongooseToJsonSchema-CByt1VhQ.mjs";
+import { n as buildCrudSchemasFromMongooseSchema, t as buildCrudSchemasFromModel } from "../mongooseToJsonSchema-DKbnKduN.mjs";
 export { buildCrudSchemasFromModel, buildCrudSchemasFromMongooseSchema, configureLogger, createError, createFieldPreset, createMemoryCache, filterResponseData, getFieldsForUser, getMongooseProjection, getSchemaIdType, isObjectIdInstance, isValidIdForType, toObjectId, toPlain };

package/dist/{validation-chain.plugin-BLecaKa0.d.mts → validation-chain.plugin-BSshLJTA.d.mts}

@@ -1,6 +1,6 @@
 import { a as PopulateSpec, i as ObjectId, l as SortSpec, s as SelectSpec } from "./core-62oo3N1C.mjs";
-import { h as RepositoryInstance, l as Plugin, p as RepositoryContext } from "./repository-DCHRWRXw.mjs";
-import { c as ValidationChainOptions, i as Logger, l as ValidatorDefinition, o as SoftDeleteOptions, r as FieldPreset, t as CascadeOptions } from "./plugin-options-vFufQZMZ.mjs";
+import { h as RepositoryInstance, l as Plugin, p as RepositoryContext } from "./repository-Q16ErTu8.mjs";
+import { c as ValidationChainOptions, i as Logger, l as ValidatorDefinition, o as SoftDeleteOptions, r as FieldPreset, t as CascadeOptions } from "./plugin-options-BsFH0sTi.mjs";
 import { BulkWriteResult } from "@classytic/repo-core/repository";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { OffsetPaginationResult } from "@classytic/repo-core/pagination";
@@ -958,4 +958,4 @@ declare function immutableField(field: string): ValidatorDefinition;
  */
 declare function uniqueField(field: string, errorMessage?: string): ValidatorDefinition;
 //#endregion
-export { IdempotencyStorePluginOptions as A, AppendOnlyPluginOptions as B, LeasePluginOptions as C, immutableStatesPlugin as D, ImmutableStatesPluginOptions as E, cascadePlugin as F, AggregateHelpersMethods as H, BatchOperationsMethods as I, BulkWriteResult as L, fieldFilterPlugin as M, ElasticSearchOptions as N, IdempotencyClaim as O, elasticSearchPlugin as P, batchOperationsPlugin as R, LeaseMethods as S, ImmutableClaimView as T, aggregateHelpersPlugin as U, appendOnlyPlugin as V, observabilityPlugin as _, uniqueField as a, MethodRegistryRepository as b, TenantContext as c, SubdocumentMethods as d, subdocumentPlugin as f, OperationMetric as g, ObservabilityOptions as h, requireField as i, idempotencyStorePlugin as j, IdempotencyStoreMethods as k, TenantStore as l, softDeletePlugin as m, blockIf as n, validationChainPlugin as o, SoftDeleteMethods as p, immutableField as r, timestampPlugin as s, autoInject as t, createTenantContext as u, MongoOperationsMethods as v, leasePlugin as w, methodRegistryPlugin as x, mongoOperationsPlugin as y, auditLogPlugin as z };
+export { IdempotencyStoreMethods as A, auditLogPlugin as B, LeaseMethods as C, ImmutableStatesPluginOptions as D, ImmutableClaimView as E, elasticSearchPlugin as F, appendOnlyPlugin as H, cascadePlugin as I, BatchOperationsMethods as L, idempotencyStorePlugin as M, fieldFilterPlugin as N, immutableStatesPlugin as O, ElasticSearchOptions as P, BulkWriteResult as R, methodRegistryPlugin as S, leasePlugin as T, AggregateHelpersMethods as U, AppendOnlyPluginOptions as V, aggregateHelpersPlugin as W, OperationMetric as _, requireField as a, mongoOperationsPlugin as b, timestampPlugin as c, createTenantContext as d, SubdocumentMethods as f, ObservabilityOptions as g, softDeletePlugin as h, immutableField as i, IdempotencyStorePluginOptions as j, IdempotencyClaim as k, TenantContext as l, SoftDeleteMethods as m, autoInject as n, uniqueField as o, subdocumentPlugin as p, blockIf as r, validationChainPlugin as s, OperationType as t, TenantStore as u, observabilityPlugin as v, LeasePluginOptions as w, MethodRegistryRepository as x, MongoOperationsMethods as y, batchOperationsPlugin as z };

package/dist/{validation-chain.plugin-CwOcUJC1.mjs → validation-chain.plugin-BxTl_dYR.mjs}

@@ -1,5 +1,5 @@
-import { c as ALL_OPERATIONS, u as OP_REGISTRY } from "./Repository-DThvFCaV.mjs";
-import { _ as upsert } from "./update-CI2NdAW6.mjs";
+import { c as ALL_OPERATIONS, u as OP_REGISTRY } from "./Repository-X7U2d0kU.mjs";
+import { _ as upsert } from "./update-DHdXdOk_.mjs";
 import { n as warn } from "./logger-K7dPmu2U.mjs";
 import { t as createError } from "./error-BuByZwKU.mjs";
 import { r as getFieldsForUser } from "./field-selection-FSQFLpsU.mjs";
@@ -463,7 +463,8 @@ function fieldFilterPlugin(fieldPreset) {
 		apply(repo) {
 			const applyFieldFiltering = (context) => {
 				if (!fieldPreset) return;
-				const presetSelect = getFieldsForUser(context.context?.user || context.user, fieldPreset).join(" ");
+				const user = context.context?.user || context.user;
+				const presetSelect = getFieldsForUser(user, fieldPreset).join(" ");
 				if (context.select) context.select = `${presetSelect} ${context.select}`;
 				else context.select = presetSelect;
 			};