@classytic/mongokit 3.29.0 → 3.31.0

package/dist/method-registry.plugin-DblM7V6j.mjs

@@ -0,0 +1,112 @@
+import { t as createError } from "./error-BuByZwKU.mjs";
+//#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/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
+export { batchOperationsPlugin as n, methodRegistryPlugin as t };

package/dist/model-registry-ClKtWiHa.mjs

@@ -0,0 +1,67 @@
+import mongoose from "mongoose";
+//#region src/model-registry.ts
+/**
+* Model registration — the ONE place `mongoose.models` is touched.
+*
+* ## Why this exists
+*
+* Mongoose locks a schema on the first `model()` call and throws (`OverwriteModelError`)
+* on the second, so every caller that might register twice hand-rolls a guard:
+*
+* ```ts
+* const Counter = mongoose.models.LoyaltyCardCounter ?? mongoose.model('LoyaltyCardCounter', schema);
+* if (!mongoose.models.organization) mongoose.model('organization', new Schema({}, { strict: false }));
+* ```
+*
+* That idiom was written at least five times across the hosts and twice inside mongokit
+* itself. Worse, the hand-rolled form silently REUSES whatever is registered — so a second
+* call passing extra fields or indexes has them dropped with no error, which is how a
+* model ends up missing an index nobody can explain.
+*
+* ## The two policies, made explicit
+*
+* - `onExisting: 'reuse'` — idempotent registration. The caller adds nothing new, so an
+*   existing model is the right answer (stubs, counters, boot-time guards).
+* - `onExisting: 'throw'` — the caller is contributing schema (extra fields, indexes) that
+*   mongoose CANNOT apply to a locked schema. Silently reusing loses it; this fails loud.
+*
+* There is deliberately no default. Picking one for the caller is how the silent-drop bug
+* got in, and the two are not interchangeable.
+*/
+/**
+* A model name was already registered when a `throw` policy required it to be free.
+*
+* Typed (not a bare `Error`) so consumers — kernels wrapping their own domain collision error,
+* tests asserting the failure — can `instanceof`-check it instead of matching a message string.
+*/
+var ModelCollisionError = class extends Error {
+	modelName;
+	constructor(modelName, detail) {
+		super(`[mongokit] model '${modelName}' is already registered. Mongoose locks a schema on the first model() call, so anything this call adds (fields, indexes) would be SILENTLY DROPPED.${detail ? ` ${detail}` : ""}`);
+		this.name = "ModelCollisionError";
+		this.modelName = modelName;
+	}
+};
+/** Is this model name already registered? Prefer {@link defineModel} over asking. */
+function isModelRegistered(name, connection) {
+	const registry = connection ? connection.models : mongoose.models;
+	return Boolean(registry[name]);
+}
+/**
+* Register a model, or return the existing one, according to `onExisting`.
+*
+* `schema` is a FACTORY so it is never built when an existing model wins — building a
+* schema has side effects (plugin application, index declaration) that should not run for
+* a registration that is about to be discarded.
+*/
+function defineModel(name, schema, options) {
+	const target = options.connection;
+	const existing = (target ? target.models : mongoose.models)[name];
+	if (existing) {
+		if (options.onExisting === "throw") throw new ModelCollisionError(name, options.throwHint);
+		return existing;
+	}
+	return target ? target.model(name, schema(), options.collection) : mongoose.model(name, schema(), options.collection);
+}
+//#endregion
+export { defineModel as n, isModelRegistered as r, ModelCollisionError as t };

package/dist/{mongooseToJsonSchema-CByt1VhQ.mjs → mongooseToJsonSchema-DKbnKduN.mjs}

@@ -69,6 +69,14 @@ function buildCrudSchemasFromMongooseSchema(mongooseSchema, options = {}) {
 * 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.
 */
 function buildCrudSchemasFromModel(mongooseModel, options = {}) {
 	if (!mongooseModel?.schema) throw new Error("Invalid mongoose model");
@@ -118,7 +126,8 @@ function buildJsonSchemaFromPaths(mongooseSchema, options) {
 		properties
 	};
 	if (required.length) schema.required = required;
-	applyFieldRules(schema, collectFieldsToOmit(options, "create"), options);
+	const fieldsToOmit = collectFieldsToOmit(options, "create");
+	applyFieldRules(schema, fieldsToOmit, options);
 	const reqOv = options?.create?.requiredOverrides || {};
 	const optOv = options?.create?.optionalOverrides || {};
 	schema.required = schema.required || [];
@@ -468,7 +477,8 @@ function stripDefaultsDeep(node) {
 function buildJsonSchemaForUpdate(createJson, options) {
 	const clone = JSON.parse(JSON.stringify(createJson));
 	delete clone.required;
-	applyFieldRules(clone, collectFieldsToOmit(options, "update"), options);
+	const fieldsToOmit = collectFieldsToOmit(options, "update");
+	applyFieldRules(clone, fieldsToOmit, options);
 	stripDefaultsDeep(clone);
 	if (options?.strictAdditionalProperties === true) clone.additionalProperties = false;
 	if (options?.update?.requireAtLeastOne === true) clone.minProperties = 1;
@@ -499,7 +509,8 @@ function buildJsonSchemaForResponse(mongooseSchema, options) {
 		fieldRules: stripCreateOnlyFieldRulesForResponse(options.fieldRules),
 		create: void 0
 	});
-	applyFieldRules(responseSchema, collectFieldsToOmit(options, "response"), options);
+	const fieldsToOmit = collectFieldsToOmit(options, "response");
+	applyFieldRules(responseSchema, fieldsToOmit, options);
 	responseSchema.required = void 0;
 	if (options?.strictAdditionalProperties !== true) responseSchema.additionalProperties = true;
 	if (fullSchema.title && !responseSchema.title) responseSchema.title = fullSchema.title;

package/dist/{multi-tenant.plugin-DVyVGREb.d.mts → multi-tenant.plugin-2VtSSm1Y.d.mts}

@@ -1,5 +1,5 @@
 import { i as ObjectId } from "./core-62oo3N1C.mjs";
-import { l as Plugin, p as RepositoryContext } from "./repository-DCHRWRXw.mjs";
+import { l as Plugin, p as RepositoryContext } from "./repository-Q16ErTu8.mjs";
 import mongoose, { Connection } from "mongoose";
 import { CacheAdapter as CacheAdapter$1, CacheOptions, RepositoryCacheHandle, RepositoryCachePluginOptions, cachePlugin } from "@classytic/repo-core/cache";
 import { TenantConfig } from "@classytic/repo-core/tenant";

package/dist/{operations-C8IcCHF9.d.mts → operations-CuzX9m2Z.d.mts}

@@ -26,8 +26,39 @@ interface LookupOptions {
   select?: string | readonly string[] | Record<string, 0 | 1>;
   /** Additional pipeline to run on the joined collection */
   pipeline?: PipelineStage[];
-  /** Optional let variables for pipeline */
-  let?: Record<string, string>;
+  /**
+   * Let variables for the pipeline form.
+   *
+   * Values are aggregation EXPRESSIONS, not just field paths — `'$skuRef'` and
+   * `{ $toObjectId: '$skuRef' }` are both valid. This was typed
+   * `Record<string, string>`, which made every cross-type correlation
+   * inexpressible through the typed API and pushed callers to hand-write raw
+   * pipelines or give up on the join entirely.
+   */
+  let?: Record<string, unknown>;
+  /**
+   * Coerce `localField` before comparing it to `foreignField`.
+   *
+   * ## Why this exists
+   *
+   * A `$lookup` compares values with STRICT BSON type equality. A `string`
+   * holding `"6a43c8fd…"` never equals an `ObjectId("6a43c8fd…")`, so the join
+   * matches nothing — and a `$lookup` that matches nothing is not an error, it
+   * is an empty array. The row renders without its joined data and every count
+   * downstream is plausibly, silently wrong.
+   *
+   * That is not hypothetical: flow stores `skuRef` as an opaque `string` (it
+   * must also admit non-ObjectId SKU codes) while `catalog_products._id` is an
+   * `ObjectId`. The naive form returned 0 matches for every row; the coerced
+   * form returned all of them. The workaround was a second round-trip resolver
+   * per request.
+   *
+   * `'objectId'` compiles to a `$convert` with `onError: null` — NOT
+   * `$toObjectId`, which THROWS on the first unconvertible value and would take
+   * down the whole query for one legacy SKU code. A row whose ref cannot be an
+   * ObjectId simply does not join, which is the same outcome as a genuine miss.
+   */
+  coerce?: 'objectId';
   /** Query filter to apply before join (legacy, for aggregate.ts compatibility) */
   query?: Record<string, unknown>;
   /** Query options (legacy, for aggregate.ts compatibility) */
@@ -75,6 +106,14 @@ declare class LookupBuilder {
    * Defaults to the collection name if not specified
    */
   as(fieldName: string): 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: NonNullable<LookupOptions['coerce']>): this;
   /**
    * Mark this lookup as returning a single document
    * Automatically unwraps the array result to a single object or null
@@ -98,7 +137,7 @@ declare class LookupBuilder {
    * Set let variables for use in pipeline
    * Allows referencing local document fields in the pipeline
    */
-  let(variables: Record<string, string>): this;
+  let(variables: Record<string, unknown>): this;
   /**
    * Control pipeline sanitization (default: true)
    * Set to false for auto-generated pipelines that are known safe

package/dist/outbox/index.d.mts

@@ -0,0 +1,63 @@
+import { n as Repository } from "../Repository-BAzymuOz.mjs";
+import { Connection, Model } from "mongoose";
+//#region src/outbox/index.d.ts
+/** Delivery states. `dead_letter` is terminal and operator-visible. */
+declare const OUTBOX_STATUSES: readonly ["pending", "delivered", "dead_letter"];
+interface OutboxModelOptions {
+  /** Collection name. Default `event_outbox`. */
+  collection?: string;
+  /** Mongoose model name. Default `EventOutbox`. Must be unique per connection. */
+  modelName?: string;
+  /**
+   * How long a DELIVERED row is retained before the TTL monitor removes it.
+   * Default 7 days. Pending and dead-lettered rows are never auto-removed —
+   * expiring an undelivered event would destroy the guarantee the table exists for.
+   */
+  ttlSeconds?: number;
+  /**
+   * Column holding the "not claimable before" timestamp. Default `visibleAt`.
+   *
+   * Configurable because an existing table cannot be renamed without rebuilding the claim
+   * index — the one index whose absence turns a busy outbox into a collection scan. One live
+   * host uses `nextVisibleAt`; it passes that here and keeps its data and indexes untouched.
+   * The same value must be given to `repositoryAsOutboxStore`, or the writer and the claimer
+   * disagree about which column means "visible" and the queue silently stops draining.
+   */
+  visibleAtField?: string;
+}
+/**
+ * Build (or return) the outbox model on `connection`.
+ *
+ * Idempotent per connection: calling twice returns the same model rather than throwing
+ * `OverwriteModelError`, so a host may build it lazily from several call sites.
+ */
+declare function createOutboxModel(connection: Connection, options?: OutboxModelOptions): Model<Record<string, unknown>>;
+/**
+ * The repository `repositoryAsOutboxStore` needs, with the plugin set it actually calls.
+ *
+ * The adapter drives `create` / `getOne` / `getAll` / `findOneAndUpdate` (base `Repository`)
+ * plus `deleteMany`, which is contributed by `batchOperationsPlugin` THROUGH the method
+ * registry. Both plugins are therefore required, and in that pairing — a host that passes only
+ * `batchOperationsPlugin()` gets a repository whose `deleteMany` is never registered.
+ *
+ * This existed as three hand-written lines in a host, which is two lines too many to get wrong
+ * silently: the wrong plugin list does not fail at boot, it fails the first time a delivered row
+ * is swept, on a code path nobody watches. `Repository` validates the registered set at
+ * construction and throws naming what is missing, so composing it HERE moves that check to
+ * every consumer instead of the one host that remembered.
+ *
+ * ```ts
+ * const store = repositoryAsOutboxStore(
+ *   createOutboxRepository(connection),        // this
+ *   { visibleAtField: 'nextVisibleAt' },       // iff you passed the same to createOutboxModel
+ * );
+ * ```
+ *
+ * `plugins` appends to the required set rather than replacing it — for an observability or
+ * cache plugin a deployment wants on this table too.
+ */
+declare function createOutboxRepository(connection: Connection, options?: OutboxModelOptions & {
+  plugins?: readonly unknown[];
+}): Repository<Record<string, unknown>>;
+//#endregion
+export { OUTBOX_STATUSES, OutboxModelOptions, createOutboxModel, createOutboxRepository };

package/dist/outbox/index.mjs

@@ -0,0 +1,239 @@
+import { n as Repository } from "../Repository-BQ3FEnOa.mjs";
+import { n as batchOperationsPlugin, t as methodRegistryPlugin } from "../method-registry.plugin-DblM7V6j.mjs";
+import { Schema } from "mongoose";
+//#region src/outbox/index.ts
+/**
+* The mongo-backed OUTBOX table — schema, indexes and repository.
+*
+* ## Why this is here
+*
+* Two ERP hosts independently hand-rolled this: 465 lines in one, 301 in the other, both
+* implementing the same `OutboxStore` contract over the same database. The second host's source
+* even carries the comment *"be-prod learned that the hard way"* about a partial-index pitfall —
+* the LESSON transferred and the code was rewritten anyway. That is the failure mode worth
+* naming: duplication here does not fail loudly, it drifts, and this is the table that guarantees
+* a collected payment is eventually recorded.
+*
+* ## What this module is, and is not
+*
+* It is the MONGO half only: a schema, the four indexes that make claim/dedupe/retention correct,
+* and a repository over them. It does NOT implement `OutboxStore` — `@classytic/arc`'s
+* `repositoryAsOutboxStore` already does that, generically, over any repository. Keeping the two
+* apart is what avoids a dependency cycle (mongokit does not depend on arc) and what lets a
+* non-mongo kit reuse the contract half.
+*
+* A host composes three lines:
+*
+* ```ts
+* const model = createOutboxModel(connection, { visibleAtField: 'nextVisibleAt' });
+* const repository = new Repository(model);
+* const store = repositoryAsOutboxStore(repository, { visibleAtField: 'nextVisibleAt' });
+* ```
+*/
+/** Delivery states. `dead_letter` is terminal and operator-visible. */
+const OUTBOX_STATUSES = [
+	"pending",
+	"delivered",
+	"dead_letter"
+];
+const DEFAULT_TTL_SECONDS = 604800;
+/**
+* Build (or return) the outbox model on `connection`.
+*
+* Idempotent per connection: calling twice returns the same model rather than throwing
+* `OverwriteModelError`, so a host may build it lazily from several call sites.
+*/
+function createOutboxModel(connection, options = {}) {
+	const { collection = "event_outbox", modelName = "EventOutbox", ttlSeconds = DEFAULT_TTL_SECONDS, visibleAtField = "visibleAt" } = options;
+	const existing = connection.models[modelName];
+	if (existing) return existing;
+	/**
+	* The document shape is `repositoryAsOutboxStore`'s, not an invention of this module.
+	*
+	* Two things about it surprise people coming from a hand-rolled table, and both are
+	* deliberate:
+	*
+	* 1. **`_id` IS the event id** (a string), not an ObjectId with a separate `eventId`
+	*    column. That is what makes `save` idempotent for free — a redelivered event is a
+	*    duplicate-key error the adapter swallows, with no read-then-write race to lose.
+	* 2. **The whole `event` is nested**, rather than split into `payload` + `meta`. The relay
+	*    republishes the event verbatim; splitting it means reassembling it on the way out, and
+	*    a reassembly that drifts from the original is a corrupted replay nobody can detect.
+	*
+	* A host with an EXISTING outbox in a different shape cannot simply point this at its
+	* collection — the ids are of a different type. That is a data migration, not a config
+	* change, and it must be planned rather than discovered.
+	*/
+	const schema = new Schema({
+		/** The event id itself. String, because the adapter writes `event.meta.id` here. */
+		_id: {
+			type: String,
+			required: true
+		},
+		/** The event, verbatim, as the relay will republish it. */
+		event: {
+			type: Schema.Types.Mixed,
+			required: true
+		},
+		type: {
+			type: String,
+			required: true
+		},
+		status: {
+			type: String,
+			enum: [...OUTBOX_STATUSES],
+			default: "pending"
+		},
+		attempts: {
+			type: Number,
+			default: 0
+		},
+		/**
+		* Caller-supplied dedupe key. `null` when absent — see the partial index below for
+		* why null must not participate in the unique constraint.
+		*/
+		dedupeKey: {
+			type: String,
+			default: null
+		},
+		partitionKey: {
+			type: String,
+			default: null
+		},
+		headers: {
+			type: Schema.Types.Mixed,
+			default: null
+		},
+		leaseOwner: {
+			type: String,
+			default: null
+		},
+		leaseExpiresAt: {
+			type: Date,
+			default: null
+		},
+		[visibleAtField]: {
+			type: Date,
+			default: Date.now
+		},
+		deliveredAt: {
+			type: Date,
+			default: null
+		},
+		firstFailedAt: {
+			type: Date,
+			default: null
+		},
+		lastFailedAt: {
+			type: Date,
+			default: null
+		},
+		lastError: {
+			type: Schema.Types.Mixed,
+			default: null
+		},
+		createdAt: {
+			type: Date,
+			default: Date.now
+		}
+	}, {
+		/**
+		* `strict: false` so a host may stamp extra columns without a schema change, and
+		* `timestamps: false` because `createdAt` is set by the adapter — letting mongoose
+		* manage it would add an `updatedAt` the claim index does not cover.
+		*
+		* `_id: false` disables mongoose's ObjectId auto-generation; the adapter always
+		* supplies the id.
+		*/
+		strict: false,
+		timestamps: false,
+		collection,
+		versionKey: false,
+		_id: false
+	});
+	/**
+	* THE CLAIM INDEX. The relay's hot query is
+	* `status = 'pending' AND <visibleAt> <= now`, ordered by `createdAt`.
+	* Without this the relay table-scans on every tick.
+	*/
+	schema.index({
+		status: 1,
+		[visibleAtField]: 1,
+		createdAt: 1
+	});
+	/**
+	* Retention. Scoped to `deliveredAt`, which is only ever set on success — so a pending or
+	* dead-lettered row has `null` and is never expired. A TTL on `createdAt` would silently
+	* delete undelivered events, which is the one thing this table must never do.
+	*/
+	schema.index({ deliveredAt: 1 }, { expireAfterSeconds: ttlSeconds });
+	/**
+	* Dedupe. `unique` + `partialFilterExpression` on the TYPE, not on `$ne: null`.
+	*
+	* Mongo rejects `unique` combined with a `sparse: true` + partial filter ("cannot mix"), and
+	* the failure is that the index silently never builds — so duplicate events insert happily
+	* and the outbox's idempotency guarantee is gone with nothing in the logs. Filtering on
+	* `$type: 'string'` indexes only rows that actually carry a key.
+	*/
+	schema.index({ dedupeKey: 1 }, {
+		unique: true,
+		partialFilterExpression: { dedupeKey: { $type: "string" } }
+	});
+	/**
+	* The DEAD-LETTER read. `getDeadLettered` is part of the `OutboxStore` contract and is what
+	* an operator alert polls — hourly, forever, on a table that grows. Partial, because the
+	* rows an operator reads are a vanishing fraction of the rows written, and a full index on
+	* `status` would be almost entirely `delivered` entries nobody queries by status alone.
+	*
+	* A host that dropped this still worked: the alert just collection-scanned every hour, which
+	* is invisible until the table is large and then is a periodic production stall.
+	*/
+	schema.index({
+		status: 1,
+		lastFailedAt: 1
+	}, { partialFilterExpression: { status: "dead_letter" } });
+	/**
+	* There is deliberately NO `claimToken` index.
+	*
+	* One host's fork claims with a generated token; `repositoryAsOutboxStore` claims with a
+	* LEASE (`leaseOwner` + `leaseExpiresAt`), already covered above. An index copied across
+	* from that fork would be permanently empty here — free to write, but it advertises a
+	* column this shape never sets, which is how the next reader concludes the two tables are
+	* interchangeable.
+	*/
+	return connection.model(modelName, schema, collection);
+}
+/**
+* The repository `repositoryAsOutboxStore` needs, with the plugin set it actually calls.
+*
+* The adapter drives `create` / `getOne` / `getAll` / `findOneAndUpdate` (base `Repository`)
+* plus `deleteMany`, which is contributed by `batchOperationsPlugin` THROUGH the method
+* registry. Both plugins are therefore required, and in that pairing — a host that passes only
+* `batchOperationsPlugin()` gets a repository whose `deleteMany` is never registered.
+*
+* This existed as three hand-written lines in a host, which is two lines too many to get wrong
+* silently: the wrong plugin list does not fail at boot, it fails the first time a delivered row
+* is swept, on a code path nobody watches. `Repository` validates the registered set at
+* construction and throws naming what is missing, so composing it HERE moves that check to
+* every consumer instead of the one host that remembered.
+*
+* ```ts
+* const store = repositoryAsOutboxStore(
+*   createOutboxRepository(connection),        // this
+*   { visibleAtField: 'nextVisibleAt' },       // iff you passed the same to createOutboxModel
+* );
+* ```
+*
+* `plugins` appends to the required set rather than replacing it — for an observability or
+* cache plugin a deployment wants on this table too.
+*/
+function createOutboxRepository(connection, options = {}) {
+	const { plugins = [], ...modelOptions } = options;
+	return new Repository(createOutboxModel(connection, modelOptions), [
+		methodRegistryPlugin(),
+		batchOperationsPlugin(),
+		...plugins
+	]);
+}
+//#endregion
+export { OUTBOX_STATUSES, createOutboxModel, createOutboxRepository };

package/dist/pagination/PaginationEngine.mjs

@@ -1,2 +1,2 @@
-import { t as PaginationEngine } from "../PaginationEngine-CczbvCAq.mjs";
+import { t as PaginationEngine } from "../PaginationEngine-CuONvwCM.mjs";
 export { PaginationEngine };

package/dist/{plugin-options-vFufQZMZ.d.mts → plugin-options-BsFH0sTi.d.mts}

@@ -1,5 +1,5 @@
 import { a as PopulateSpec, i as ObjectId, l as SortSpec, s as SelectSpec } from "./core-62oo3N1C.mjs";
-import { h as RepositoryInstance, p as RepositoryContext } from "./repository-DCHRWRXw.mjs";
+import { h as RepositoryInstance, p as RepositoryContext } from "./repository-Q16ErTu8.mjs";
 import { OffsetPaginationResult } from "@classytic/repo-core/pagination";
 //#region src/types/plugin-options.d.ts
 /** Field preset configuration (field-filter plugin) */

package/dist/plugins/index.d.mts

@@ -1,6 +1,6 @@
-import { S as RepositoryPluginName, b as MONGOKIT_PLUGIN_NAMES, l as Plugin, x as MongoKitPluginName } from "../repository-DCHRWRXw.mjs";
-import { A as ensureAuditTrailReady, C as AuditTrailMethods, D as AuditTrailQueryOptions, E as AuditTrailQuery, O as EnsureAuditTrailReadyOptions, S as AuditQueryResult, T as AuditTrailOptions, _ as RepositoryCachePluginOptions, a as DateSequentialIdOptions, b as AuditOperation, c as SequentialIdOptions, d as getNextSequence, f as prefixedId, g as RepositoryCacheHandle, h as CacheOptions, i as CustomIdOptions, k as auditTrailPlugin, l as customIdPlugin, m as CacheAdapter, o as IdGenerator, p as sequentialId, r as multiTenantPlugin, s as PrefixedIdOptions, t as MultiTenantOptions, u as dateSequentialId, v as cachePlugin, w as AuditTrailMode, x as AuditQueryOptions, y as AuditEntry } from "../multi-tenant.plugin-DVyVGREb.mjs";
-import { A as IdempotencyStorePluginOptions, B as AppendOnlyPluginOptions, C as LeasePluginOptions, D as immutableStatesPlugin, E as ImmutableStatesPluginOptions, F as cascadePlugin, H as AggregateHelpersMethods, I as BatchOperationsMethods, M as fieldFilterPlugin, N as ElasticSearchOptions, O as IdempotencyClaim, P as elasticSearchPlugin, R as batchOperationsPlugin, S as LeaseMethods, T as ImmutableClaimView, U as aggregateHelpersPlugin, V as appendOnlyPlugin, _ as observabilityPlugin, a as uniqueField, b as MethodRegistryRepository, c as TenantContext, d as SubdocumentMethods, f as subdocumentPlugin, g as OperationMetric, h as ObservabilityOptions, i as requireField, j as idempotencyStorePlugin, k as IdempotencyStoreMethods, l as TenantStore, m as softDeletePlugin, n as blockIf, o as validationChainPlugin, p as SoftDeleteMethods, r as immutableField, s as timestampPlugin, t as autoInject, u as createTenantContext, v as MongoOperationsMethods, w as leasePlugin, x as methodRegistryPlugin, y as mongoOperationsPlugin, z as auditLogPlugin } from "../validation-chain.plugin-BLecaKa0.mjs";
+import { S as RepositoryPluginName, b as MONGOKIT_PLUGIN_NAMES, l as Plugin, x as MongoKitPluginName } from "../repository-Q16ErTu8.mjs";
+import { A as ensureAuditTrailReady, C as AuditTrailMethods, D as AuditTrailQueryOptions, E as AuditTrailQuery, O as EnsureAuditTrailReadyOptions, S as AuditQueryResult, T as AuditTrailOptions, _ as RepositoryCachePluginOptions, a as DateSequentialIdOptions, b as AuditOperation, c as SequentialIdOptions, d as getNextSequence, f as prefixedId, g as RepositoryCacheHandle, h as CacheOptions, i as CustomIdOptions, k as auditTrailPlugin, l as customIdPlugin, m as CacheAdapter, o as IdGenerator, p as sequentialId, r as multiTenantPlugin, s as PrefixedIdOptions, t as MultiTenantOptions, u as dateSequentialId, v as cachePlugin, w as AuditTrailMode, x as AuditQueryOptions, y as AuditEntry } from "../multi-tenant.plugin-2VtSSm1Y.mjs";
+import { A as IdempotencyStoreMethods, B as auditLogPlugin, C as LeaseMethods, D as ImmutableStatesPluginOptions, E as ImmutableClaimView, F as elasticSearchPlugin, H as appendOnlyPlugin, I as cascadePlugin, L as BatchOperationsMethods, M as idempotencyStorePlugin, N as fieldFilterPlugin, O as immutableStatesPlugin, P as ElasticSearchOptions, S as methodRegistryPlugin, T as leasePlugin, U as AggregateHelpersMethods, V as AppendOnlyPluginOptions, W as aggregateHelpersPlugin, _ as OperationMetric, a as requireField, b as mongoOperationsPlugin, c as timestampPlugin, d as createTenantContext, f as SubdocumentMethods, g as ObservabilityOptions, h as softDeletePlugin, i as immutableField, j as IdempotencyStorePluginOptions, k as IdempotencyClaim, l as TenantContext, m as SoftDeleteMethods, n as autoInject, o as uniqueField, p as subdocumentPlugin, r as blockIf, s as validationChainPlugin, t as OperationType, u as TenantStore, v as observabilityPlugin, w as LeasePluginOptions, x as MethodRegistryRepository, y as MongoOperationsMethods, z as batchOperationsPlugin } from "../validation-chain.plugin-BSshLJTA.mjs";
 import { ChangeLogStore } from "@classytic/repo-core/sync";
 //#region src/plugins/change-log.plugin.d.ts
 interface ChangeLogPluginOptions {
@@ -15,4 +15,4 @@ interface ChangeLogPluginOptions {
 }
 declare function changeLogPlugin(options: ChangeLogPluginOptions): Plugin;
 //#endregion
-export { type AggregateHelpersMethods, type AppendOnlyPluginOptions, type AuditEntry, type AuditOperation, type AuditQueryOptions, type AuditQueryResult, type AuditTrailMethods, type AuditTrailMode, type AuditTrailOptions, AuditTrailQuery, type AuditTrailQueryOptions, type BatchOperationsMethods, type CacheAdapter, type CacheOptions, type ChangeLogPluginOptions, type CustomIdOptions, type DateSequentialIdOptions, type ElasticSearchOptions, type EnsureAuditTrailReadyOptions, type IdGenerator, type IdempotencyClaim, type IdempotencyStoreMethods, type IdempotencyStorePluginOptions, type ImmutableClaimView, type ImmutableStatesPluginOptions, type LeaseMethods, type LeasePluginOptions, MONGOKIT_PLUGIN_NAMES, type MethodRegistryRepository, type MongoKitPluginName, type MongoOperationsMethods, type MultiTenantOptions, type ObservabilityOptions, type OperationMetric, type PrefixedIdOptions, type RepositoryCacheHandle, type RepositoryCachePluginOptions, type RepositoryPluginName, type SequentialIdOptions, type SoftDeleteMethods, type SubdocumentMethods, type TenantContext, type TenantStore, aggregateHelpersPlugin, appendOnlyPlugin, auditLogPlugin, auditTrailPlugin, autoInject, batchOperationsPlugin, blockIf, cachePlugin, cascadePlugin, changeLogPlugin, createTenantContext, customIdPlugin, dateSequentialId, elasticSearchPlugin, ensureAuditTrailReady, fieldFilterPlugin, getNextSequence, idempotencyStorePlugin, immutableField, immutableStatesPlugin, leasePlugin, methodRegistryPlugin, mongoOperationsPlugin, multiTenantPlugin, observabilityPlugin, prefixedId, requireField, sequentialId, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validationChainPlugin };
+export { type AggregateHelpersMethods, type AppendOnlyPluginOptions, type AuditEntry, type AuditOperation, type AuditQueryOptions, type AuditQueryResult, type AuditTrailMethods, type AuditTrailMode, type AuditTrailOptions, AuditTrailQuery, type AuditTrailQueryOptions, type BatchOperationsMethods, type CacheAdapter, type CacheOptions, type ChangeLogPluginOptions, type CustomIdOptions, type DateSequentialIdOptions, type ElasticSearchOptions, type EnsureAuditTrailReadyOptions, type IdGenerator, type IdempotencyClaim, type IdempotencyStoreMethods, type IdempotencyStorePluginOptions, type ImmutableClaimView, type ImmutableStatesPluginOptions, type LeaseMethods, type LeasePluginOptions, MONGOKIT_PLUGIN_NAMES, type MethodRegistryRepository, type MongoKitPluginName, type MongoOperationsMethods, type MultiTenantOptions, type ObservabilityOptions, type OperationMetric, type OperationType, type PrefixedIdOptions, type RepositoryCacheHandle, type RepositoryCachePluginOptions, type RepositoryPluginName, type SequentialIdOptions, type SoftDeleteMethods, type SubdocumentMethods, type TenantContext, type TenantStore, aggregateHelpersPlugin, appendOnlyPlugin, auditLogPlugin, auditTrailPlugin, autoInject, batchOperationsPlugin, blockIf, cachePlugin, cascadePlugin, changeLogPlugin, createTenantContext, customIdPlugin, dateSequentialId, elasticSearchPlugin, ensureAuditTrailReady, fieldFilterPlugin, getNextSequence, idempotencyStorePlugin, immutableField, immutableStatesPlugin, leasePlugin, methodRegistryPlugin, mongoOperationsPlugin, multiTenantPlugin, observabilityPlugin, prefixedId, requireField, sequentialId, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validationChainPlugin };

package/dist/plugins/index.mjs

@@ -1,5 +1,6 @@
-import { a as methodRegistryPlugin, c as getNextSequence, d as cachePlugin, f as batchOperationsPlugin, g as auditLogPlugin, h as ensureAuditTrailReady, i as multiTenantPlugin, l as prefixedId, m as auditTrailPlugin, n as softDeletePlugin, o as customIdPlugin, p as AuditTrailQuery, s as dateSequentialId, t as timestampPlugin, u as sequentialId } from "../timestamp.plugin-CFL6LlYZ.mjs";
-import { _ as cascadePlugin, a as uniqueField, c as subdocumentPlugin, d as mongoOperationsPlugin, f as leasePlugin, g as elasticSearchPlugin, h as fieldFilterPlugin, i as requireField, l as observabilityPlugin, m as idempotencyStorePlugin, n as blockIf, o as validationChainPlugin, p as immutableStatesPlugin, r as immutableField, s as createTenantContext, t as autoInject, u as MONGOKIT_PLUGIN_NAMES, v as appendOnlyPlugin, y as aggregateHelpersPlugin } from "../validation-chain.plugin-CwOcUJC1.mjs";
+import { a as customIdPlugin, c as prefixedId, d as AuditTrailQuery, f as auditTrailPlugin, i as multiTenantPlugin, l as sequentialId, m as auditLogPlugin, n as softDeletePlugin, o as dateSequentialId, p as ensureAuditTrailReady, s as getNextSequence, t as timestampPlugin, u as cachePlugin } from "../timestamp.plugin-i9Qxm6kn.mjs";
+import { n as batchOperationsPlugin, t as methodRegistryPlugin } from "../method-registry.plugin-DblM7V6j.mjs";
+import { _ as cascadePlugin, a as uniqueField, c as subdocumentPlugin, d as mongoOperationsPlugin, f as leasePlugin, g as elasticSearchPlugin, h as fieldFilterPlugin, i as requireField, l as observabilityPlugin, m as idempotencyStorePlugin, n as blockIf, o as validationChainPlugin, p as immutableStatesPlugin, r as immutableField, s as createTenantContext, t as autoInject, u as MONGOKIT_PLUGIN_NAMES, v as appendOnlyPlugin, y as aggregateHelpersPlugin } from "../validation-chain.plugin-CpcB6dOd.mjs";
 //#region src/plugins/change-log.plugin.ts
 const PLUGIN_NAME = "changeLog";
 function isSkipped(context) {