@classytic/mongokit 3.39.0 → 3.40.0

package/dist/sync/index.mjs

@@ -0,0 +1,334 @@
+import { i as withTransaction } from "../transaction-B5L9glO0.mjs";
+import { Schema } from "mongoose";
+//#region src/sync/index.ts
+function createChangeLogModels(connection, options = {}) {
+	const { collection = "sync_changes", modelName = "SyncChange" } = options;
+	const entriesName = modelName;
+	const counterName = `${modelName}Counter`;
+	return {
+		entries: connection.models[entriesName] ?? connection.model(entriesName, (() => {
+			const schema = new Schema({
+				seq: {
+					type: Number,
+					required: true
+				},
+				scope: {
+					type: String,
+					required: true
+				},
+				docId: {
+					type: String,
+					required: true
+				},
+				op: {
+					type: String,
+					enum: ["upsert", "delete"],
+					required: true
+				},
+				version: {
+					type: Number,
+					required: true
+				},
+				doc: { type: Schema.Types.Mixed },
+				tenantId: { type: String },
+				at: {
+					type: Date,
+					required: true
+				}
+			}, {
+				collection,
+				versionKey: false,
+				minimize: false
+			});
+			schema.index({ seq: 1 }, {
+				unique: true,
+				name: "feed_order"
+			});
+			schema.index({
+				tenantId: 1,
+				scope: 1,
+				seq: 1
+			}, { name: "tenant_scope_feed" });
+			return schema;
+		})()),
+		counter: connection.models[counterName] ?? connection.model(counterName, new Schema({
+			_id: {
+				type: String,
+				required: true
+			},
+			seq: {
+				type: Number,
+				required: true
+			}
+		}, {
+			collection: `${collection}_counter`,
+			versionKey: false
+		})),
+		feed: collection
+	};
+}
+/** Fixed-width, so the opaque cursor also sorts as text. */
+const toCursor = (seq) => String(seq).padStart(16, "0");
+const fromCursor = (cursor) => {
+	if (cursor === "") return 0;
+	const seq = Number(cursor);
+	if (!Number.isSafeInteger(seq) || seq < 0) throw new Error(`[mongokit:sync] "${cursor}" is not a cursor from this feed`);
+	return seq;
+};
+const DEFAULT_LIMIT = 500;
+function createChangeLogStore(models) {
+	const { entries, counter, feed } = models;
+	const sessionOf = (options) => options?.session ? { session: options.session } : {};
+	const filterOf = (after, options = {}) => {
+		const { tenantId, scopes, sharedScopes } = options;
+		const tenant = tenantId === void 0 ? {} : sharedScopes?.length ? { $or: [{ tenantId }, { scope: { $in: [...sharedScopes] } }] } : { tenantId };
+		return {
+			seq: { $gt: after },
+			...tenant,
+			...scopes ? { scope: { $in: [...scopes] } } : {}
+		};
+	};
+	const toEntry = (row) => ({
+		scope: row.scope,
+		docId: row.docId,
+		op: row.op,
+		version: row.version,
+		...row.doc !== void 0 && row.doc !== null ? { doc: row.doc } : {},
+		...typeof row.tenantId === "string" ? { tenantId: row.tenantId } : {},
+		at: row.at,
+		cursor: toCursor(row.seq)
+	});
+	return {
+		async append(entry, options) {
+			const session = sessionOf(options);
+			const seq = (await counter.findOneAndUpdate({ _id: feed }, { $inc: { seq: 1 } }, {
+				upsert: true,
+				returnDocument: "after",
+				lean: true,
+				...session
+			}).exec()).seq;
+			const at = /* @__PURE__ */ new Date();
+			await entries.create([{
+				seq,
+				scope: entry.scope,
+				docId: entry.docId,
+				op: entry.op,
+				version: entry.version,
+				...entry.op === "upsert" && entry.doc !== void 0 ? { doc: entry.doc } : {},
+				...entry.tenantId !== void 0 ? { tenantId: entry.tenantId } : {},
+				at
+			}], session);
+			return {
+				...entry,
+				at,
+				cursor: toCursor(seq)
+			};
+		},
+		async since(cursor, options = {}) {
+			const limit = options.limit ?? DEFAULT_LIMIT;
+			const rows = await entries.find(filterOf(fromCursor(cursor), options)).sort({ seq: 1 }).limit(limit + 1).lean().exec();
+			const page = rows.slice(0, limit).map(toEntry);
+			const last = page[page.length - 1];
+			return {
+				changes: page,
+				cursor: last ? last.cursor : cursor,
+				hasMore: rows.length > limit
+			};
+		},
+		async latestCursor(options = {}) {
+			const row = await entries.findOne(filterOf(0, options)).sort({ seq: -1 }).select({ seq: 1 }).lean().exec();
+			return row?.seq ? toCursor(row.seq) : "";
+		}
+	};
+}
+function createCommandStreamModels(connection, options = {}) {
+	const { prefix = "sync", modelName = "SyncStream" } = options;
+	const model = (name, schema) => connection.models[name] ?? connection.model(name, schema());
+	return {
+		streams: model(modelName, () => new Schema({
+			_id: {
+				type: String,
+				required: true
+			},
+			tenantId: {
+				type: String,
+				required: true
+			},
+			processed: {
+				type: Number,
+				required: true
+			}
+		}, {
+			collection: `${prefix}_streams`,
+			versionKey: false
+		})),
+		verdicts: model(`${modelName}Verdict`, () => {
+			const schema = new Schema({
+				_id: {
+					type: String,
+					required: true
+				},
+				stream: {
+					type: String,
+					required: true
+				},
+				seq: {
+					type: Number,
+					required: true
+				},
+				outcome: {
+					type: String,
+					enum: [
+						"applied",
+						"rejected",
+						"blocked",
+						"resolved"
+					],
+					required: true
+				},
+				code: { type: String },
+				fingerprint: {
+					type: String,
+					required: true
+				},
+				body: { type: String },
+				dependsOn: {
+					type: [String],
+					default: void 0
+				},
+				resolution: {
+					type: {
+						action: String,
+						by: String,
+						at: String,
+						_id: false
+					},
+					default: void 0
+				}
+			}, {
+				collection: `${prefix}_verdicts`,
+				versionKey: false
+			});
+			schema.index({
+				stream: 1,
+				seq: 1
+			}, {
+				unique: true,
+				name: "stream_seq"
+			});
+			schema.index({
+				dependsOn: 1,
+				outcome: 1
+			}, {
+				name: "blocked_on",
+				partialFilterExpression: { outcome: "blocked" }
+			});
+			return schema;
+		}),
+		aliases: model(`${modelName}Alias`, () => {
+			const schema = new Schema({
+				tenantId: {
+					type: String,
+					required: true
+				},
+				localId: {
+					type: String,
+					required: true
+				},
+				serverId: {
+					type: String,
+					required: true
+				}
+			}, {
+				collection: `${prefix}_aliases`,
+				versionKey: false
+			});
+			schema.index({
+				tenantId: 1,
+				localId: 1
+			}, {
+				unique: true,
+				name: "tenant_local"
+			});
+			return schema;
+		})
+	};
+}
+/**
+* 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.
+*/
+function createCommandStreamStore(connection, models, changes) {
+	const { streams, verdicts, aliases } = models;
+	const toVerdict = ({ _id, code, ...rest }) => ({
+		commandId: _id,
+		...rest,
+		...code == null ? {} : { code }
+	});
+	return {
+		changes,
+		transaction: (work) => withTransaction(connection, (session) => work({ session })),
+		async stream({ session }, id) {
+			const row = await streams.findById(id).session(session).lean().exec();
+			return row ? {
+				tenantId: row.tenantId,
+				processed: row.processed
+			} : null;
+		},
+		async advance({ session }, id, tenantId, from, to) {
+			if (from === 0) {
+				if (await streams.exists({ _id: id }).session(session)) return false;
+				await streams.create([{
+					_id: id,
+					tenantId,
+					processed: to
+				}], { session });
+				return true;
+			}
+			return (await streams.updateOne({
+				_id: id,
+				processed: from
+			}, { $set: { processed: to } }, { session }).exec()).modifiedCount === 1;
+		},
+		async verdict({ session }, commandId) {
+			const row = await verdicts.findById(commandId).session(session).lean().exec();
+			return row ? toVerdict(row) : null;
+		},
+		async record({ session }, { commandId, ...rest }) {
+			await verdicts.replaceOne({ _id: commandId }, rest, {
+				upsert: true,
+				session
+			}).exec();
+		},
+		async blockedOn({ session }, commandId) {
+			return (await verdicts.find({
+				outcome: "blocked",
+				dependsOn: commandId
+			}).sort({ seq: 1 }).session(session).lean().exec()).map(toVerdict);
+		},
+		async alias({ session }, { tenantId, localId, serverId }) {
+			const existing = await aliases.findOne({
+				tenantId,
+				localId
+			}).session(session).lean().exec();
+			if (existing) {
+				if (existing.serverId !== serverId) throw new Error(`[mongokit:sync] "${localId}" already names "${existing.serverId}"`);
+				return;
+			}
+			await aliases.create([{
+				tenantId,
+				localId,
+				serverId
+			}], { session });
+		},
+		async aliasOf({ session }, tenantId, localId) {
+			return (await aliases.findOne({
+				tenantId,
+				localId
+			}).session(session).lean().exec())?.serverId ?? null;
+		}
+	};
+}
+//#endregion
+export { createChangeLogModels, createChangeLogStore, createCommandStreamModels, createCommandStreamStore };

package/dist/tenant/index.mjs

@@ -64,6 +64,8 @@ function declareIndexes(schema, tenant, declarations) {
 */
 function injectTenantField(schema, tenant, options = {}) {
 	for (const declaration of options.indexes ?? []) assertIndexDeclaration(declaration, tenant);
+	const declaredNames = new Set(indexEntries(schema).map(([, o]) => o?.name).filter((n) => typeof n === "string"));
+	for (const name of options.skipIndexes ?? []) if (!declaredNames.has(name)) throw new Error(`[mongokit/tenant] skipIndexes names '${name}', but no index on this schema has that name — rename the exemption with the index, or the index silently gets the tenant prefix`);
 	const isObjectId = tenant.fieldType === "objectId";
 	const scoped = isScoped(tenant);
 	schema.add({ [tenant.tenantField]: {

package/dist/testkit/index.d.mts

@@ -1,5 +1,5 @@
-import { n as Repository } from "../Repository-IxI983_m.mjs";
-import { n as CreateRepositoryConfig } from "../create-repository-CRXjDa3N.mjs";
+import { r as Repository } from "../Repository-CR8Y9g2E.mjs";
+import { n as CreateRepositoryConfig } from "../create-repository-CAle1MSU.mjs";
 import { Connection, Model, Schema } from "mongoose";
 import { MongoMemoryReplSet, MongoMemoryServer } from "mongodb-memory-server";
 //#region src/testkit/index.d.ts

package/dist/testkit/index.mjs

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

package/dist/{timestamp.plugin-B5eiaItQ.mjs → timestamp.plugin-DF0gJB6p.mjs}

@@ -1,4 +1,4 @@
-import { c as ALL_OPERATIONS, t as HOOK_PRIORITY, u as OP_REGISTRY } from "./Repository-D7fDpyFx.mjs";
+import { i as ALL_OPERATIONS, o as OP_REGISTRY, t as HOOK_PRIORITY } from "./Repository-BMgPSkqZ.mjs";
 import { n as warn } from "./logger-K7dPmu2U.mjs";
 import { throwIfAborted, withRetry } from "@classytic/repo-core/repository";
 import mongoose from "mongoose";
@@ -754,6 +754,33 @@ async function getNextSequence(counterKey, increment = 1, connection, session) {
 	return result.seq;
 }
 /**
+* Current value of a counter, or `null` when it has never been created.
+* `null` and `0` differ: only a missing counter needs seeding.
+*/
+async function readSequence(counterKey, connection) {
+	const doc = await getCounterModel(connection).findById(counterKey).lean();
+	return doc ? doc.seq : 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.
+*/
+async function ensureSequenceAtLeast(counterKey, floor, connection) {
+	if (!Number.isSafeInteger(floor) || floor < 0) throw new Error(`ensureSequenceAtLeast: floor must be a non-negative integer, got ${floor}`);
+	const result = await getCounterModel(connection).findOneAndUpdate({ _id: counterKey }, { $max: { seq: floor } }, {
+		upsert: true,
+		returnDocument: "after"
+	});
+	if (!result) throw new Error(`Failed to seed counter '${counterKey}'`);
+	return result.seq;
+}
+/**
 * Generator: Simple sequential counter.
 * Produces IDs like `INV-0001`, `INV-0002`, etc.
 *
@@ -930,6 +957,62 @@ function customIdPlugin(options) {
 	};
 }
 //#endregion
+//#region src/utils/scope.ts
+/** Tenant context keys forwarded even when no tenant plugin declared one. */
+const CONVENTIONAL_TENANT_KEYS = ["organizationId", "tenantId"];
+const ATTRIBUTION_KEYS = [
+	"session",
+	"user",
+	"userId",
+	"requestId"
+];
+/** Where a repository records the tenant context keys its plugins read. */
+const TENANT_KEYS = Symbol.for("@classytic/mongokit/tenant-context-keys");
+/**
+* Record that `repo` resolves its tenant from `contextKey`. Called by
+* `multiTenantPlugin` at bind, so forwarding knows a custom key (`branchId`)
+* without the host restating it.
+*/
+function declareTenantContextKey(repo, contextKey) {
+	const holder = repo;
+	if (!holder[TENANT_KEYS]) Object.defineProperty(holder, TENANT_KEYS, {
+		value: /* @__PURE__ */ new Set(),
+		enumerable: false
+	});
+	holder[TENANT_KEYS]?.add(contextKey);
+}
+/** Every tenant context key relevant to a call spanning these repositories. */
+function tenantContextKeysOf(...repos) {
+	const keys = new Set(CONVENTIONAL_TENANT_KEYS);
+	for (const repo of repos) for (const key of repo?.[TENANT_KEYS] ?? []) keys.add(key);
+	return [...keys];
+}
+/**
+* The scope to hand a second repository call made on behalf of `source`
+* (a hook's `RepositoryContext`, or a host's request context).
+*
+* Absent values are omitted, never written as `undefined`, so spreading the
+* result into an options bag cannot erase a value set there.
+*/
+function forwardScope(source, tenantKeys = CONVENTIONAL_TENANT_KEYS) {
+	if (!source) return {};
+	const out = {};
+	let hasTenant = false;
+	for (const key of tenantKeys) {
+		const value = source[key];
+		if (value === void 0) continue;
+		out[key] = value;
+		if (value !== null && value !== "") hasTenant = true;
+	}
+	if (!hasTenant && source.bypassTenant === true) out.bypassTenant = true;
+	for (const key of ATTRIBUTION_KEYS) if (source[key] !== void 0) out[key] = source[key];
+	return out;
+}
+/** Every key `forwardScope` governs. Other forwarding helpers must not copy these themselves. */
+function isScopeKey(key, tenantKeys = CONVENTIONAL_TENANT_KEYS) {
+	return key === "bypassTenant" || tenantKeys.includes(key) || ATTRIBUTION_KEYS.includes(key);
+}
+//#endregion
 //#region src/plugins/multi-tenant.plugin.ts
 /**
 * Multi-Tenant Plugin
@@ -983,6 +1066,7 @@ function multiTenantPlugin(options = {}) {
 	return {
 		name: "multi-tenant",
 		apply(repo) {
+			declareTenantContextKey(repo, contextKey);
 			const allOps = [...ALL_OPERATIONS.map((op) => ({
 				op,
 				policyKey: OP_REGISTRY[op].policyKey
@@ -1500,4 +1584,4 @@ function timestampPlugin() {
 	};
 }
 //#endregion
-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 };
+export { AuditTrailQuery as _, declareTenantContextKey as a, auditLogPlugin as b, tenantContextKeysOf as c, ensureSequenceAtLeast as d, getNextSequence as f, cachePlugin as g, sequentialId as h, multiTenantPlugin as i, customIdPlugin as l, readSequence as m, softDeletePlugin as n, forwardScope as o, prefixedId as p, adminBypass$1 as r, isScopeKey as s, timestampPlugin as t, dateSequentialId as u, auditTrailPlugin as v, ensureAuditTrailReady as y };

package/dist/{to-plain-B8ufk3Qz.d.mts → to-plain-k7SjNlSS.d.mts}

@@ -1,5 +1,5 @@
-import { v as UserContext } from "./repository-ZbLtL7Nk.mjs";
-import { r as FieldPreset } from "./plugin-options-BuvtOSZf.mjs";
+import { v as UserContext } from "./repository-odl03582.mjs";
+import { r as FieldPreset } from "./plugin-options-Zk46lD6F.mjs";
 import mongoose, { Schema } from "mongoose";
 import { CacheAdapter } from "@classytic/repo-core/cache";
 import { HttpError } from "@classytic/repo-core/errors";