@classytic/mongokit 3.39.0 → 3.40.0

package/dist/indexes/verify-indexes.d.mts

@@ -14,6 +14,10 @@
  * Missing UNIQUE indexes are reported separately from missing regular ones —
  * the first silently admits duplicate data, the second only costs a scan.
  *
+ * Same keys are not the same index: a live index is compared on the options that decide
+ * correctness (`unique`, `partialFilterExpression`, `sparse`, `collation`, `expireAfterSeconds`).
+ * A same-key index that differs is reported as `incompatible` — its fix is a rebuild, not a create.
+ *
  * DELIBERATELY ONE-DIRECTIONAL: an index present in the database but absent
  * from a schema is NOT drift. Auth libraries and migrations manage indexes
  * outside the ODM, and treating those as removable is exactly what makes a
@@ -44,11 +48,20 @@ interface MissingIndex {
   /** The declared key, JSON-stringified — stable to log and to diff. */
   key: string;
 }
+/** A live index on the declared keys whose correctness options differ from the declaration. */
+interface IncompatibleIndex extends MissingIndex {
+  /** Declared `unique` — a mismatch here can already have admitted duplicates. */
+  unique: boolean;
+  /** One line per differing option: `unique: declared true, live false`. */
+  differences: string[];
+}
 interface IndexVerifyReport {
   modelsChecked: number;
   /** Declared `unique` indexes with nothing behind them. Duplicates can already exist. */
   missingUnique: MissingIndex[];
   missingRegular: MissingIndex[];
+  /** Same keys, different semantics — e.g. declared unique, built non-unique. */
+  incompatible: IncompatibleIndex[];
   /** Models whose indexes could not be read — collection absent, or no permission. */
   unreadable: string[];
 }
@@ -66,4 +79,4 @@ declare function verifyIndexes(connection: IndexVerifiableConnection, options?:
 /** One-line summary for a boot log. */
 declare function formatIndexReport(report: IndexVerifyReport): string;
 //#endregion
-export { IndexVerifiableConnection, IndexVerifiableModel, IndexVerifyReport, MissingIndex, VerifyIndexesOptions, formatIndexReport, verifyIndexes };
+export { IncompatibleIndex, IndexVerifiableConnection, IndexVerifiableModel, IndexVerifyReport, MissingIndex, VerifyIndexesOptions, formatIndexReport, verifyIndexes };

package/dist/indexes/verify-indexes.mjs

@@ -22,12 +22,45 @@ function textFields(key) {
 	const fields = Object.entries(key).filter(([, dir]) => dir === "text").map(([field]) => field);
 	return fields.length > 0 ? fields.sort() : null;
 }
+/** Order-free JSON, so `{a:1,b:2}` equals `{b:2,a:1}` — option objects are not order-sensitive. */
+function canonical(value) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "undefined";
+	if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+	return `{${Object.keys(value).sort().map((k) => `${JSON.stringify(k)}:${canonical(value[k])}`).join(",")}}`;
+}
+/**
+* The options that change what an index GUARANTEES, compared declared → live. Absent means
+* off (`unique`, `sparse`) or none (`partialFilterExpression`, `expireAfterSeconds`). A collation
+* is compared on the DECLARED fields only: the server fills in every default it does not store.
+*/
+function optionDifferences(declared, live) {
+	const diffs = [];
+	const flag = (name) => {
+		const d = declared[name] === true;
+		const l = live[name] === true;
+		if (d !== l) diffs.push(`${name}: declared ${d}, live ${l}`);
+	};
+	flag("unique");
+	flag("sparse");
+	for (const name of ["partialFilterExpression", "expireAfterSeconds"]) {
+		const d = declared[name] === void 0 ? "none" : canonical(declared[name]);
+		const l = live[name] === void 0 ? "none" : canonical(live[name]);
+		if (d !== l) diffs.push(`${name}: declared ${d}, live ${l}`);
+	}
+	const dColl = declared.collation;
+	const lColl = live.collation;
+	if (dColl) {
+		if (Object.keys(dColl).filter((k) => canonical(dColl[k]) !== canonical(lColl?.[k])).length > 0) diffs.push(`collation: declared ${canonical(dColl)}, live ${lColl ? canonical(lColl) : "none"}`);
+	} else if (lColl && lColl.locale !== "simple") diffs.push(`collation: declared none, live ${canonical(lColl)}`);
+	return diffs;
+}
 async function verifyIndexes(connection, options = {}) {
 	const include = options.includeModel ?? (() => true);
 	const report = {
 		modelsChecked: 0,
 		missingUnique: [],
 		missingRegular: [],
+		incompatible: [],
 		unreadable: []
 	};
 	for (const name of connection.modelNames().sort()) {
@@ -39,8 +72,12 @@ async function verifyIndexes(connection, options = {}) {
 		let existingText;
 		try {
 			const live = await model.collection.listIndexes().toArray();
-			existing = new Set(live.map((i) => normalizeKey(i.key)));
-			existingText = new Set(live.filter((i) => i.weights).map((i) => JSON.stringify(Object.keys(i.weights).sort())));
+			existing = /* @__PURE__ */ new Map();
+			existingText = /* @__PURE__ */ new Map();
+			for (const index of live) {
+				const [map, k] = index.weights ? [existingText, JSON.stringify(Object.keys(index.weights).sort())] : [existing, normalizeKey(index.key)];
+				map.set(k, [...map.get(k) ?? [], index]);
+			}
 		} catch {
 			report.unreadable.push(name);
 			continue;
@@ -48,15 +85,24 @@ async function verifyIndexes(connection, options = {}) {
 		report.modelsChecked += 1;
 		for (const [key, indexOptions] of declared) {
 			const asText = textFields(key);
-			if (asText) {
-				if (existingText.has(JSON.stringify(asText))) continue;
-			} else if (existing.has(normalizeKey(key))) continue;
+			const sameKey = asText ? existingText.get(JSON.stringify(asText)) : existing.get(normalizeKey(key));
 			const entry = {
 				model: name,
 				collection: model.collection.name,
 				key: JSON.stringify(key)
 			};
-			if (indexOptions?.unique) report.missingUnique.push(entry);
+			const opts = indexOptions ?? {};
+			if (sameKey && sameKey.length > 0) {
+				const diffsPerCandidate = sameKey.map((live) => optionDifferences(opts, live));
+				if (diffsPerCandidate.some((d) => d.length === 0)) continue;
+				report.incompatible.push({
+					...entry,
+					unique: opts.unique === true,
+					differences: diffsPerCandidate[0] ?? []
+				});
+				continue;
+			}
+			if (opts.unique === true) report.missingUnique.push(entry);
 			else report.missingRegular.push(entry);
 		}
 	}
@@ -67,7 +113,8 @@ function formatIndexReport(report) {
 	const parts = [
 		`${report.modelsChecked} models checked`,
 		`missing unique: ${report.missingUnique.length}`,
-		`missing regular: ${report.missingRegular.length}`
+		`missing regular: ${report.missingRegular.length}`,
+		`incompatible: ${report.incompatible.length}`
 	];
 	if (report.unreadable.length > 0) parts.push(`unreadable: ${report.unreadable.length}`);
 	return `[index-check] ${parts.join(" — ")}`;

package/dist/{multi-tenant.plugin-B-tzNeYL.d.mts → multi-tenant.plugin-CBgCo9im.d.mts}

@@ -1,5 +1,5 @@
 import { g as ObjectId } from "./pagination-BpIv2bdS.mjs";
-import { l as Plugin, p as RepositoryContext } from "./repository-ZbLtL7Nk.mjs";
+import { l as Plugin, p as RepositoryContext } from "./repository-odl03582.mjs";
 import mongoose, { Connection } from "mongoose";
 import { CacheAdapter as CacheAdapter$1, CacheOptions, RepositoryCacheHandle as RepositoryCacheHandle$1, RepositoryCachePluginOptions, cachePlugin } from "@classytic/repo-core/cache";
 import { TenantConfig } from "@classytic/repo-core/tenant";
@@ -307,6 +307,22 @@ interface CustomIdOptions {
  * });
  */
 declare function getNextSequence(counterKey: string, increment?: number, connection?: mongoose.Connection, session?: mongoose.ClientSession): Promise<number>;
+/**
+ * Current value of a counter, or `null` when it has never been created.
+ * `null` and `0` differ: only a missing counter needs seeding.
+ */
+declare function readSequence(counterKey: string, connection?: mongoose.Connection): Promise<number | null>;
+/**
+ * Raise a counter to at least `floor` — never lowers it. Atomic (`$max` +
+ * upsert), so concurrent seeders converge on the highest floor.
+ *
+ * Use before a counter's first increment when ids were already issued under
+ * another key (e.g. moving from a global to a per-tenant sequence); otherwise
+ * the new counter restarts at 1 and re-issues taken ids.
+ *
+ * @returns The counter's value after the raise.
+ */
+declare function ensureSequenceAtLeast(counterKey: string, floor: number, connection?: mongoose.Connection): Promise<number>;
 interface SequentialIdOptions {
   /** Prefix string (e.g., 'INV', 'ORD') */
   prefix: string;
@@ -638,4 +654,4 @@ declare function adminBypass(options: {
   adminRoles: readonly string[];
 }): (context: RepositoryContext, operation: string) => boolean;
 //#endregion
-export { ensureAuditTrailReady as A, AuditTrailMethods as C, AuditTrailQueryOptions as D, AuditTrailQuery as E, EnsureAuditTrailReadyOptions as O, AuditQueryResult as S, AuditTrailOptions as T, RepositoryCachePluginOptions as _, DateSequentialIdOptions as a, AuditOperation as b, SequentialIdOptions as c, getNextSequence as d, prefixedId as f, RepositoryCacheHandle$1 as g, CacheOptions as h, CustomIdOptions as i, auditTrailPlugin as k, customIdPlugin as l, CacheAdapter$1 as m, adminBypass as n, IdGenerator as o, sequentialId as p, multiTenantPlugin as r, PrefixedIdOptions as s, MultiTenantOptions as t, dateSequentialId as u, cachePlugin as v, AuditTrailMode as w, AuditQueryOptions as x, AuditEntry as y };
+export { EnsureAuditTrailReadyOptions as A, AuditQueryOptions as C, AuditTrailOptions as D, AuditTrailMode as E, ensureAuditTrailReady as M, AuditTrailQuery as O, AuditOperation as S, AuditTrailMethods as T, CacheOptions as _, DateSequentialIdOptions as a, cachePlugin as b, SequentialIdOptions as c, ensureSequenceAtLeast as d, getNextSequence as f, CacheAdapter$1 as g, sequentialId as h, CustomIdOptions as i, auditTrailPlugin as j, AuditTrailQueryOptions as k, customIdPlugin as l, readSequence as m, adminBypass as n, IdGenerator as o, prefixedId as p, multiTenantPlugin as r, PrefixedIdOptions as s, MultiTenantOptions as t, dateSequentialId as u, RepositoryCacheHandle$1 as v, AuditQueryResult as w, AuditEntry as x, RepositoryCachePluginOptions as y };

package/dist/outbox/index.d.mts

@@ -1,4 +1,4 @@
-import { n as Repository } from "../Repository-IxI983_m.mjs";
+import { r as Repository } from "../Repository-CR8Y9g2E.mjs";
 import { Connection, Model } from "mongoose";
 //#region src/outbox/index.d.ts
 /** Delivery states. `dead_letter` is terminal and operator-visible. */

package/dist/outbox/index.mjs

@@ -1,4 +1,4 @@
-import { n as Repository } from "../Repository-D7fDpyFx.mjs";
+import { n as Repository } from "../Repository-BMgPSkqZ.mjs";
 import { n as batchOperationsPlugin, t as methodRegistryPlugin } from "../method-registry.plugin-C63pGn1d.mjs";
 import { Schema } from "mongoose";
 //#region src/outbox/index.ts
@@ -172,12 +172,14 @@ function createOutboxModel(connection, options = {}) {
 	*
 	* 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.
+	* and the outbox's idempotency guarantee is gone with nothing in the logs. `$gte: ''` indexes
+	* only rows that carry a string key — the same rows as `$type: 'string'`, but the dedupe
+	* lookup by key can use it (a `$type` filter is never implied by an equality query).
 	*/
 	schema.index({ dedupeKey: 1 }, {
+		name: "dedupeKey_str",
 		unique: true,
-		partialFilterExpression: { dedupeKey: { $type: "string" } }
+		partialFilterExpression: { dedupeKey: { $gte: "" } }
 	});
 	/**
 	* The DEAD-LETTER read. `getDeadLettered` is part of the `OutboxStore` contract and is what

package/dist/pagination/PaginationEngine.mjs

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

package/dist/{plugin-options-BuvtOSZf.d.mts → plugin-options-Zk46lD6F.d.mts}

@@ -1,5 +1,5 @@
 import { _ as PopulateSpec, g as ObjectId, x as SortSpec, y as SelectSpec } from "./pagination-BpIv2bdS.mjs";
-import { h as RepositoryInstance, p as RepositoryContext } from "./repository-ZbLtL7Nk.mjs";
+import { h as RepositoryInstance, p as RepositoryContext } from "./repository-odl03582.mjs";
 import { OffsetPaginationResult } from "@classytic/repo-core/pagination";
 //#region src/types/plugin-options.d.ts
 /** Field preset configuration (field-filter plugin) */
@@ -69,6 +69,9 @@ interface SoftDeleteRepository<TDoc = unknown> {
    */
   restore(id: string | ObjectId, options?: {
     session?: unknown;
+    organizationId?: unknown;
+    bypassTenant?: boolean;
+    [key: string]: unknown;
   }): Promise<TDoc>;
   /**
    * Get all soft-deleted documents
@@ -109,6 +112,17 @@ interface CascadeRelation {
   model?: string;
   /** Foreign key field in the related model that references the deleted document */
   foreignKey: string;
+  /**
+   * WHICH parent field `foreignKey` stores. Default: the parent repository's
+   * `idField` (`_id` unless the repository declares another).
+   *
+   * Set it when the two differ. An order repository addressed by `orderNumber`
+   * whose children store the order's `_id` declares `parentKey: '_id'`;
+   * without it, `delete('ORD-2026-0001')` cascaded with the order NUMBER and
+   * every child delete failed on the ObjectId cast. The cascade reads the
+   * parent's value for this field before the delete, under the same session.
+   */
+  parentKey?: string;
   /** Whether to use soft delete if available (default: follows parent behavior) */
   softDelete?: boolean;
   /**

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-ZbLtL7Nk.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-B-tzNeYL.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-DvrLJIbJ.mjs";
+import { S as RepositoryPluginName, b as MONGOKIT_PLUGIN_NAMES, l as Plugin, x as MongoKitPluginName } from "../repository-odl03582.mjs";
+import { A as EnsureAuditTrailReadyOptions, C as AuditQueryOptions, D as AuditTrailOptions, E as AuditTrailMode, M as ensureAuditTrailReady, O as AuditTrailQuery, S as AuditOperation, T as AuditTrailMethods, _ as CacheOptions, a as DateSequentialIdOptions, b as cachePlugin, c as SequentialIdOptions, f as getNextSequence, g as CacheAdapter, h as sequentialId, i as CustomIdOptions, j as auditTrailPlugin, k as AuditTrailQueryOptions, l as customIdPlugin, o as IdGenerator, p as prefixedId, r as multiTenantPlugin, s as PrefixedIdOptions, t as MultiTenantOptions, u as dateSequentialId, v as RepositoryCacheHandle, w as AuditQueryResult, x as AuditEntry, y as RepositoryCachePluginOptions } from "../multi-tenant.plugin-CBgCo9im.mjs";
+import { A as IdempotencyStoreMethods, B as batchOperationsPlugin, C as LeaseMethods, D as ImmutableStatesPluginOptions, E as ImmutableClaimView, F as elasticSearchPlugin, G as aggregateHelpersPlugin, H as AppendOnlyPluginOptions, 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 appendOnlyPlugin, V as auditLogPlugin, W as AggregateHelpersMethods, _ 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 } from "../validation-chain.plugin-DYp9E7K2.mjs";
 import { ChangeLogStore } from "@classytic/repo-core/sync";
 //#region src/plugins/change-log.plugin.d.ts
 interface ChangeLogPluginOptions {
@@ -12,6 +12,11 @@ interface ChangeLogPluginOptions {
   tenantField?: string;
   /** Monotonic per-doc version field. Default `version` (kernel convention). */
   versionField?: string;
+  /**
+   * The document as a subscriber may see it — fields picked, secrets (a cost price) dropped. Tenant
+   * and version are still read from the whole document. Default: the whole document.
+   */
+  project?: (doc: Record<string, unknown>) => Record<string, unknown>;
 }
 declare function changeLogPlugin(options: ChangeLogPluginOptions): Plugin;
 //#endregion

package/dist/plugins/index.mjs

@@ -1,14 +1,18 @@
-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-B5eiaItQ.mjs";
+import { _ as AuditTrailQuery, b as auditLogPlugin, f as getNextSequence, g as cachePlugin, h as sequentialId, i as multiTenantPlugin, l as customIdPlugin, n as softDeletePlugin, p as prefixedId, t as timestampPlugin, u as dateSequentialId, v as auditTrailPlugin, y as ensureAuditTrailReady } from "../timestamp.plugin-DF0gJB6p.mjs";
 import { n as batchOperationsPlugin, t as methodRegistryPlugin } from "../method-registry.plugin-C63pGn1d.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-Bju1D1Sn.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-BLY2gLEk.mjs";
 //#region src/plugins/change-log.plugin.ts
 const PLUGIN_NAME = "changeLog";
+/** Marks a repository already captured: the store and scope it writes to. */
+const CAPTURED = Symbol.for("mongokit.changeLog.capture");
+/** Where `before:updateMany` / `before:deleteMany` leave the ids they matched for the after hook. */
+const MATCHED_IDS = Symbol("changeLog.matchedIds");
 function isSkipped(context) {
 	const list = context.skipPlugins;
 	return Array.isArray(list) && list.includes(PLUGIN_NAME);
 }
 function changeLogPlugin(options) {
-	const { store, scope, tenantField = "organizationId", versionField = "version" } = options;
+	const { store, scope, tenantField = "organizationId", versionField = "version", project } = options;
 	const toRecord = (doc) => {
 		if (!doc || typeof doc !== "object") return null;
 		const d = doc;
@@ -21,51 +25,120 @@ function changeLogPlugin(options) {
 		return updatedAt instanceof Date ? updatedAt.getTime() : 0;
 	};
 	const tenantOf = (doc, context) => {
-		const raw = doc[tenantField] ?? context.organizationId;
+		const raw = doc?.[tenantField] ?? context.organizationId;
 		return raw === void 0 || raw === null ? void 0 : String(raw);
 	};
-	const capture = async (op, doc, context) => {
+	const appendOptions = (context) => context.session !== void 0 ? { session: context.session } : void 0;
+	const upsert = async (doc, context) => {
 		const record = toRecord(doc);
 		if (!record || record._id === void 0) return;
 		const tenantId = tenantOf(record, context);
 		await store.append({
 			scope,
 			docId: String(record._id),
-			op,
+			op: "upsert",
 			version: versionOf(record),
-			...op === "upsert" ? { doc: record } : {},
+			doc: project ? project(record) : record,
 			...tenantId !== void 0 ? { tenantId } : {}
-		}, context.session !== void 0 ? { session: context.session } : void 0);
+		}, appendOptions(context));
+	};
+	const tombstone = async (docId, context) => {
+		if (docId === void 0 || docId === null) return;
+		const tenantId = tenantOf(null, context);
+		await store.append({
+			scope,
+			docId: String(docId),
+			op: "delete",
+			version: 0,
+			...tenantId !== void 0 ? { tenantId } : {}
+		}, appendOptions(context));
 	};
 	return {
 		name: PLUGIN_NAME,
 		apply(repo) {
+			const marked = repo;
+			const existing = marked[CAPTURED];
+			if (existing) {
+				if (existing.store === store && existing.scope === scope) return;
+				throw new Error(`[mongokit] changeLogPlugin is already capturing this repository as "${existing.scope}"`);
+			}
+			marked[CAPTURED] = {
+				store,
+				scope
+			};
+			/** The whole document as committed in this session — never a projection. */
+			const reread = async (id, context) => {
+				const query = repo.Model.findById(id).lean();
+				if (context.session !== void 0) query.session(context.session);
+				return query.exec();
+			};
+			const matchingIds = async (context, filter) => {
+				const query = repo.Model.find(filter ?? {}).select({ _id: 1 }).lean();
+				if (context.session !== void 0) query.session(context.session);
+				return (await query.exec()).map((d) => d._id);
+			};
 			repo.on("after:create", async ({ context, result }) => {
-				if (isSkipped(context) || !result) return;
-				await capture("upsert", result, context);
+				if (!isSkipped(context) && result) await upsert(result, context);
 			});
 			repo.on("after:createMany", async ({ context, result }) => {
 				if (isSkipped(context) || !Array.isArray(result)) return;
-				for (const doc of result) await capture("upsert", doc, context);
+				for (const doc of result) await upsert(doc, context);
 			});
 			repo.on("after:update", async ({ context, result }) => {
-				if (isSkipped(context) || !result) return;
-				await capture("upsert", result, context);
+				if (!isSkipped(context) && result) await upsert(result, context);
+			});
+			for (const op of [
+				"claim",
+				"claimVersion",
+				"findOneAndUpdate",
+				"getOrCreate",
+				"restore"
+			]) repo.on(`after:${op}`, async ({ context, result }) => {
+				if (isSkipped(context)) return;
+				const id = toRecord(result)?._id;
+				if (id === void 0) return;
+				const doc = await reread(id, context);
+				if (doc) await upsert(doc, context);
+				else await tombstone(id, context);
+			});
+			for (const op of ["updateMany", "deleteMany"]) repo.on(`before:${op}`, async (context) => {
+				if (!isSkipped(context)) context[MATCHED_IDS] = await matchingIds(context, context.query);
+			});
+			/** Each re-read document as an upsert, or a tombstone where it is gone. */
+			const capture = async (ids, context) => {
+				for (const id of ids) {
+					const doc = await reread(id, context);
+					if (doc) await upsert(doc, context);
+					else await tombstone(id, context);
+				}
+			};
+			repo.on("after:updateMany", async ({ context }) => {
+				if (!isSkipped(context)) await capture(context[MATCHED_IDS] ?? [], context);
+			});
+			repo.on("after:anonymize", async ({ context, result }) => {
+				if (!isSkipped(context)) await capture(result.ids, context);
+			});
+			repo.on("after:deleteMany", async ({ context }) => {
+				if (!isSkipped(context)) await capture(context[MATCHED_IDS] ?? [], context);
 			});
 			repo.on("after:delete", async ({ context, result }) => {
 				if (isSkipped(context) || !result) return;
-				const summary = result;
-				const ctxId = context.id;
-				const docId = summary.id ?? ctxId;
-				if (docId === void 0 || docId === null) return;
-				const tenantRaw = context.organizationId;
-				await store.append({
-					scope,
-					docId: String(docId),
-					op: "delete",
-					version: 0,
-					...tenantRaw !== void 0 && tenantRaw !== null ? { tenantId: String(tenantRaw) } : {}
-				}, context.session !== void 0 ? { session: context.session } : void 0);
+				await tombstone(result.id ?? context.id, context);
+			});
+			repo.on("before:bulkWrite", async (context) => {
+				if (isSkipped(context)) return;
+				const ids = [];
+				for (const op of context.operations ?? []) {
+					const [kind, spec] = Object.entries(op)[0] ?? [];
+					if (!kind || !spec) continue;
+					if (kind === "insertOne") ids.push(spec.document?._id);
+					else ids.push(...await matchingIds(context, spec.filter));
+				}
+				context[MATCHED_IDS] = ids.filter((id) => id !== void 0);
+			});
+			repo.on("after:bulkWrite", async ({ context, result }) => {
+				if (isSkipped(context)) return;
+				await capture([...context[MATCHED_IDS] ?? [], ...Object.values(result?.upsertedIds ?? {})], context);
 			});
 		}
 	};

package/dist/{repository-ZbLtL7Nk.d.mts → repository-odl03582.d.mts}

@@ -363,8 +363,23 @@ interface RepositoryContext {
   _cacheResolved?: unknown;
   /** Cache hit status (internal — `'fresh'` or `'stale'`) */
   _cacheStatus?: 'fresh' | 'stale' | 'miss' | 'disabled' | 'bypass';
-  /** IDs to cascade delete (internal) */
-  _cascadeIds?: unknown[];
+  /**
+   * Parent key values captured before a delete, by `parentKey` (internal —
+   * cascade plugin). Restrict, detach and cascade all read these.
+   */
+  _cascadeParentKeys?: Map<string, unknown[]>;
+  /**
+   * Memo shared by every hook of THIS operation: N plugins that need the same read pay for
+   * one. Scoped to the operation, so it can never serve a value across writes. A rejected
+   * load is forgotten, so the next caller retries.
+   */
+  memo?: <T>(key: string, load: () => Promise<T>) => Promise<T>;
+  /**
+   * The persisted document an id-addressed operation targets, as it is BEFORE the write,
+   * read once under the operation's session (not tenant-filtered — the write's own filter
+   * decides whether it applies). Use this instead of `Model.findById(context.id)` in a hook.
+   */
+  loadTarget?: () => Promise<Record<string, unknown> | null>;
   /** Custom context data from plugins */
   [key: string]: unknown;
 }
@@ -528,6 +543,9 @@ type AllPluginMethods<TDoc> = {
   deleteSubdocument(parentId: string | ObjectId, arrayPath: DocField<TDoc>, subId: string | ObjectId, options?: Record<string, unknown>): Promise<TDoc>;
   restore(id: string | ObjectId, options?: {
     session?: unknown;
+    organizationId?: unknown;
+    bypassTenant?: boolean;
+    [key: string]: unknown;
   }): Promise<TDoc>;
   getDeleted(params?: {
     filters?: Record<string, unknown>;

package/dist/sync/index.d.mts

@@ -0,0 +1,40 @@
+import { ClientSession, Connection, Model } from "mongoose";
+import { ChangeLogStore, CommandStreamStore, CommandStreamTx } from "@classytic/repo-core/sync";
+//#region src/sync/index.d.ts
+interface ChangeLogModelOptions {
+  /** Entries collection. Default `sync_changes`; its counter lives in `<collection>_counter`. */
+  collection?: string;
+  /** Mongoose model name prefix. Default `SyncChange`. Must be unique per connection. */
+  modelName?: string;
+}
+interface ChangeLogModels {
+  entries: Model<Record<string, unknown>>;
+  counter: Model<Record<string, unknown>>;
+  /** The counter document's id (one feed per entries collection). */
+  feed: string;
+}
+declare function createChangeLogModels(connection: Connection, options?: ChangeLogModelOptions): ChangeLogModels;
+declare function createChangeLogStore(models: ChangeLogModels): ChangeLogStore;
+interface CommandStreamModelOptions {
+  /** Collection prefix: `<prefix>_streams`, `<prefix>_verdicts`, `<prefix>_aliases`. Default `sync`. */
+  prefix?: string;
+  /** Mongoose model name prefix. Default `SyncStream`. Must be unique per connection. */
+  modelName?: string;
+}
+interface CommandStreamModels {
+  streams: Model<Record<string, unknown>>;
+  verdicts: Model<Record<string, unknown>>;
+  aliases: Model<Record<string, unknown>>;
+}
+declare function createCommandStreamModels(connection: Connection, options?: CommandStreamModelOptions): CommandStreamModels;
+interface MongoCommandStreamTx extends CommandStreamTx {
+  readonly session: ClientSession;
+}
+/**
+ * The mongo {@link CommandStreamStore} (replica set). Proven by `runCommandStreamStoreConformance`.
+ * Concurrent transactions on one stream write-conflict on its document and `withTransaction`
+ * retries the loser, which then reads the winner's watermark.
+ */
+declare function createCommandStreamStore(connection: Pick<Connection, 'startSession'>, models: CommandStreamModels, changes: ChangeLogStore): CommandStreamStore<MongoCommandStreamTx>;
+//#endregion
+export { ChangeLogModelOptions, ChangeLogModels, CommandStreamModelOptions, CommandStreamModels, MongoCommandStreamTx, createChangeLogModels, createChangeLogStore, createCommandStreamModels, createCommandStreamStore };