@classytic/mongokit 3.29.0 → 3.31.0

package/dist/{repository-DCHRWRXw.d.mts → repository-Q16ErTu8.d.mts}

@@ -1,6 +1,6 @@
 import { a as PopulateSpec, i as ObjectId, l as SortSpec, o as ReadPreferenceType, r as FilterQuery, s as SelectSpec, t as AnyDocument } from "./core-62oo3N1C.mjs";
 import { r as DocField } from "./type-utils-CLzRFtIA.mjs";
-import { RepositoryBase } from "@classytic/repo-core/repository";
+import { RepoCapabilities, RepositoryBase } from "@classytic/repo-core/repository";
 import { Model, PipelineStage } from "mongoose";
 import { HttpError } from "@classytic/repo-core/errors";
 import { OffsetPaginationResult } from "@classytic/repo-core/pagination";
@@ -191,6 +191,24 @@ interface RepositoryOptions {
    * ```
    */
   requirePlugins?: readonly RepositoryPluginName[];
+  /**
+   * Override the whole runtime capability descriptor.
+   *
+   * By DEFAULT `repo.capabilities` is OBSERVED from the model's live
+   * connection topology (see `capabilities.ts`) — a standalone `mongod`
+   * reports `transactions: false`, and an unreadable topology reports
+   * `false` with `transactionsResolution: 'unknown'` so money kernels fail
+   * closed. Supply this only when you genuinely know better than the driver:
+   * a proxied/wrapped connection, a non-mongoose seam, or a test that needs
+   * to pin a descriptor.
+   *
+   * **Never pass `{ ...MONGOKIT_CAPABILITIES }` to quiet a boot gate.** That
+   * re-creates the exact defect the observation replaced: a declared
+   * capability nothing can falsify. If a deployment truly cannot do
+   * transactions and you accept the risk, say so at the KERNEL
+   * (`allowNonTransactional: true`), where the degradation is logged.
+   */
+  capabilities?: RepoCapabilities;
   /**
    * Standard Schema validator (Zod 3.24+, Valibot 1+, ArkType 2+, ...)
    * for write payloads. Forwarded to `RepositoryBase`, which validates

package/dist/testkit/index.d.mts

@@ -1,4 +1,5 @@
-import { a as Repository, n as CreateRepositoryConfig } from "../create-repository-D4ZU94b3.mjs";
+import { n as Repository } from "../Repository-BAzymuOz.mjs";
+import { n as CreateRepositoryConfig } from "../create-repository-mEdfH9sz.mjs";
 import { Connection, Model, Schema } from "mongoose";
 import { MongoMemoryReplSet, MongoMemoryServer } from "mongodb-memory-server";
 //#region src/testkit/index.d.ts
@@ -7,6 +8,12 @@ interface MongoMemoryOptions {
    * Boot a single-node replica set instead of a standalone mongod. Required for
    * any code that opens a `session.startTransaction()` — a standalone server
    * rejects it with error 263. Slightly slower to start (~2-3s). Default false.
+   *
+   * Since 2026-08-05 this also changes what `repo.capabilities` REPORTS:
+   * capabilities are observed from the live topology, so a standalone harness
+   * yields `transactions: false` and any kernel boot gate built on it will
+   * (correctly) refuse to bind. Set `replset: true` when the code under test
+   * constructs a money kernel — or pass that kernel's `allowNonTransactional`.
    */
   replset?: boolean;
   /** Database name baked into the generated URI. Default `"mongokit-test"`. */

package/dist/testkit/index.mjs

@@ -1,4 +1,4 @@
-import { t as createRepository } from "../create-repository-uhKt_oUT.mjs";
+import { t as createRepository } from "../create-repository-BOTVMsIg.mjs";
 import { createConnection } from "mongoose";
 //#region src/testkit/index.ts
 function idempotentStop(server) {

package/dist/{timestamp.plugin-CFL6LlYZ.mjs → timestamp.plugin-i9Qxm6kn.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-BQ3FEnOa.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-DAO5STDv.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) {
@@ -182,6 +201,25 @@ const DANGEROUS_OPERATORS = [
 	"$accumulator"
 ];
 /**
+* The local side of a join correlation, coerced when the two sides are stored
+* as different BSON types.
+*
+* `$convert` with `onError`/`onNull` rather than `$toObjectId`: the latter
+* throws on the first unconvertible value, which would fail the entire
+* aggregation because ONE row held a legacy non-ObjectId reference. Returning
+* null makes that row miss the join, exactly as a genuine non-match would.
+*/
+function localCorrelation(localField, coerce) {
+	const path = `$${localField}`;
+	if (coerce !== "objectId") return path;
+	return { $convert: {
+		input: path,
+		to: "objectId",
+		onError: null,
+		onNull: null
+	} };
+}
+/**
 * Fluent builder for MongoDB $lookup aggregation stage
 * Optimized for custom field joins at scale
 */
@@ -222,6 +260,17 @@ var LookupBuilder = class LookupBuilder {
 		return this;
 	}
 	/**
+	* Coerce the local field before comparing it to the foreign field.
+	*
+	* Use when the two sides are stored as different BSON types — most commonly a
+	* `string` reference against an `ObjectId` `_id`. Without it the join matches
+	* nothing and reports no error. See {@link LookupOptions.coerce}.
+	*/
+	coerce(kind) {
+		this.options.coerce = kind;
+		return this;
+	}
+	/**
 	* Mark this lookup as returning a single document
 	* Automatically unwraps the array result to a single object or null
 	*/
@@ -274,11 +323,12 @@ var LookupBuilder = class LookupBuilder {
 	* Otherwise, we use the simpler localField/foreignField form.
 	*/
 	build() {
-		const { from, localField, foreignField, as, single, pipeline, let: letVars } = this.options;
+		const { from, localField, foreignField, as, single, pipeline, let: letVars, coerce } = this.options;
 		if (!from) throw new Error("LookupBuilder: \"from\" collection is required");
+		if (coerce && (!localField || !foreignField)) throw new Error("LookupBuilder: \"coerce\" needs both localField and foreignField — it describes how to compare them. Without both there is no comparison to coerce.");
 		const outputField = as || from;
 		const stages = [];
-		const usePipelineForm = pipeline || letVars;
+		const usePipelineForm = pipeline || letVars || coerce;
 		let lookupStage;
 		if (usePipelineForm) if (!pipeline || pipeline.length === 0) {
 			if (!localField || !foreignField) throw new Error("LookupBuilder: When using pipeline form without a custom pipeline, both localField and foreignField are required to auto-generate the pipeline");
@@ -286,7 +336,7 @@ var LookupBuilder = class LookupBuilder {
 			lookupStage = { $lookup: {
 				from,
 				let: {
-					[localField]: `$${localField}`,
+					[localField]: localCorrelation(localField, coerce),
 					...letVars || {}
 				},
 				pipeline: autoPipeline,
@@ -297,7 +347,7 @@ var LookupBuilder = class LookupBuilder {
 			let effectiveLet = letVars;
 			let effectivePipeline = safePipeline;
 			if (localField && foreignField && !letVars) {
-				effectiveLet = { lookupJoinVal: `$${localField}` };
+				effectiveLet = { lookupJoinVal: localCorrelation(localField, coerce) };
 				effectivePipeline = [{ $match: { $expr: { $eq: [`$${foreignField}`, "$$lookupJoinVal"] } } }, ...safePipeline];
 			}
 			lookupStage = { $lookup: {
@@ -370,7 +420,11 @@ var LookupBuilder = class LookupBuilder {
 					...lookup.let || {}
 				});
 				builder.sanitize(false);
-			} else if (lookup.let) builder.let(lookup.let);
+			} else {
+				if (lookup.let) builder.let(lookup.let);
+				if (lookup.coerce) builder.coerce(lookup.coerce);
+				if (lookup.coerce) builder.coerce(lookup.coerce);
+			}
 			return builder.build();
 		});
 	}
@@ -394,6 +448,7 @@ var LookupBuilder = class LookupBuilder {
 			if (lookup.single !== void 0) builder.single(lookup.single);
 			if (lookup.pipeline) builder.pipeline(lookup.pipeline);
 			if (lookup.let) builder.let(lookup.let);
+			if (lookup.coerce) builder.coerce(lookup.coerce);
 			return builder.build();
 		});
 	}

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-CpcB6dOd.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-BQ3FEnOa.mjs";
+import { _ as upsert } from "./update-DAO5STDv.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;
 			};