@voltro/plugin-rooms 0.0.0-stage → 0.88.0

package/dist/replayStorage.js

@@ -0,0 +1,484 @@
+import { ProtocolError as e } from "./errors.js";
+import { canonicalRoomJson as t } from "./checkpointJson.js";
+import { RoomReplayPort as n } from "./replayPorts.js";
+import { captureRoomSnapshotEffectRunner as r } from "./snapshotBlobIndex.js";
+import { definedOnly as i } from "./resolvedOptions.js";
+import { captureRoomReplayLimits as a, openArchivedReplay as o } from "./replay.js";
+import { and as s, eq as c, id as l, json as u, table as d, text as f, timestamp as p } from "@voltro/database";
+import { Effect as m, Layer as h, Result as g, Schema as _, Stream as ee } from "effect";
+import { createHash as v } from "node:crypto";
+// src/replayStorage.ts
+var y = "_voltro_replays", b = d(y, {
+	id: l({ prefix: "replay" }),
+	tenantId: f().maxLength(191),
+	replayId: f().maxLength(191),
+	roomId: f().maxLength(191),
+	roomName: f().maxLength(191),
+	matchId: f().maxLength(191),
+	participants: u(),
+	visibility: f().maxLength(16),
+	expiresAt: p().nullable(),
+	receipt: u(),
+	createdAt: p(),
+	updatedAt: p()
+}).unique("byRoomReplay", ["tenantId", "replayId"]).index(["tenantId", "roomId"]).index(["tenantId", "expiresAt"]);
+function x(t) {
+	throw new e({ detail: t });
+}
+var S = (e) => v("sha256").update(e).digest("hex"), C = (e) => typeof e == "string" && e.length > 0 && e.length <= 191 && e.trim() === e && e.isWellFormed() && !/[\u0000-\u001f\u007f]/.test(e) ? e : x("Invalid replay identity"), w = (e, t) => Number.isSafeInteger(e) && e > 0 && e <= t ? e : x("Invalid replay budget"), T = (e) => typeof e == "number" && Number.isSafeInteger(e) && e >= 0 && e <= 864e13 ? e : x("Invalid replay timestamp"), E = (e) => {
+	if (typeof e != "object" || !e || Array.isArray(e) || ![Object.prototype, null].includes(Object.getPrototypeOf(e))) return x("Replay options must be plain data");
+	let t = Object.create(null);
+	for (let n of Reflect.ownKeys(e)) {
+		let r = Object.getOwnPropertyDescriptor(e, n);
+		if (typeof n != "string" || !r || !r.enumerable || !Object.hasOwn(r, "value")) return x("Replay accessors and hidden fields are refused");
+		t[n] = r.value;
+	}
+	return t;
+}, D = (e, t) => {
+	if (!Array.isArray(e) || e.length > t || Reflect.ownKeys(e).length !== e.length + 1) return x("Replay participants exceed their budget");
+	let n = [];
+	for (let t = 0; t < e.length; t++) {
+		let r = Object.getOwnPropertyDescriptor(e, String(t));
+		if (!r?.enumerable || !Object.hasOwn(r, "value")) return x("Replay participant accessors/sparse arrays are refused");
+		n.push(C(r.value));
+	}
+	return new Set(n).size === n.length ? Object.freeze(n.sort()) : x("Replay participants must be unique");
+}, O = (e) => {
+	let t = E(e);
+	return Object.keys(t).some((e) => !["tenantId", "replayId"].includes(e)) ? x("Unknown replay scope field") : Object.freeze({
+		tenantId: C(t.tenantId),
+		replayId: C(t.replayId)
+	});
+}, k = (e) => {
+	let t = E(e), n = E(t.target);
+	return Object.keys(t).some((e) => !["requestId", "target"].includes(e)) || Object.keys(n).some((e) => ![
+		"tenantId",
+		"subjectId",
+		"kind"
+	].includes(e)) || !["user", "guest"].includes(String(n.kind)) ? x("Invalid replay subject request") : Object.freeze({
+		requestId: C(t.requestId),
+		target: Object.freeze({
+			tenantId: C(n.tenantId),
+			subjectId: C(n.subjectId),
+			kind: n.kind === "user" ? "user" : "guest"
+		})
+	});
+}, A = (e, t = 256) => {
+	let n = E(e), r = w(t, 4096);
+	if (Object.keys(n).some((e) => ![
+		"tenantId",
+		"replayId",
+		"roomId",
+		"roomName",
+		"matchId",
+		"participants",
+		"visibility",
+		"expiresAtMs"
+	].includes(e))) return x("Unknown replay metadata field");
+	let i = n.visibility;
+	return i !== "private" && i !== "unlisted" && i !== "public" ? x("Invalid replay visibility") : Object.freeze({
+		tenantId: C(n.tenantId),
+		replayId: C(n.replayId),
+		roomId: C(n.roomId),
+		roomName: C(n.roomName),
+		matchId: C(n.matchId),
+		participants: D(n.participants, r),
+		visibility: i,
+		expiresAtMs: n.expiresAtMs === null ? null : T(n.expiresAtMs)
+	});
+}, te = _.Struct({
+	version: _.Literal(1),
+	fingerprint: _.String,
+	checksum: _.String,
+	size: _.Int,
+	durationMs: _.Int,
+	schemaHash: _.Int,
+	state: _.Literals([
+		"uploading",
+		"ready",
+		"erasing",
+		"erased"
+	]),
+	refId: _.NullOr(_.String),
+	eraseRequest: _.NullOr(_.String)
+}), ne = _.Struct({
+	maxBytes: _.optional(_.Int),
+	maxFrameBytes: _.optional(_.Int),
+	maxFrames: _.optional(_.Int),
+	maxHighlights: _.optional(_.Int),
+	maxSchemaBytes: _.optional(_.Int),
+	maxDurationMs: _.optional(_.Int),
+	checkpointEveryMs: _.optional(_.Int)
+}), re = _.Struct({
+	maxDescriptionBytes: _.optional(_.Int),
+	maxSchemaNodes: _.optional(_.Int),
+	maxSchemaDepth: _.optional(_.Int),
+	codecLimits: _.optional(_.Struct({
+		maxBytes: _.optional(_.Int),
+		maxCollectionLength: _.optional(_.Int),
+		maxFieldId: _.optional(_.Int)
+	}))
+}), ie = (e) => {
+	if (g.isFailure(e)) throw e.failure;
+	return e.success;
+}, j = (n, l) => {
+	let u = E(l);
+	if (Object.keys(u).some((e) => ![
+		"storage",
+		"operations",
+		"authority",
+		"epochNow",
+		"maxTenantReplays",
+		"maxParticipants",
+		"replayLimits",
+		"schemaOptions"
+	].includes(e))) return x("Unknown replay store option");
+	let d = l.storage, f = l.operations, p = l.authority;
+	if (!d || !f?.metadata || !p || typeof l.epochNow != "function" || ![
+		"put",
+		"head",
+		"getStream",
+		"delete"
+	].every((e) => typeof Reflect.get(d, e) == "function") || typeof f.metadata.lookup != "function" || ![
+		"authorize",
+		"withdraw",
+		"authorizeSubject",
+		"withdrawSubject"
+	].every((e) => typeof Reflect.get(p, e) == "function")) return x("Replay store requires complete borrowed storage and authority");
+	let h = C(f.bucket), g = f.metadata.lookup.bind(f.metadata), v = d.put.bind(d), b = d.head.bind(d), j = d.getStream.bind(d), ae = d.delete.bind(d), M = p.authorize.bind(p), oe = p.withdraw.bind(p), se = p.authorizeSubject.bind(p), ce = p.withdrawSubject.bind(p), le = l.epochNow.bind(l), N = w(l.maxTenantReplays ?? 4096, 65536), P = w(l.maxParticipants ?? 256, 4096), F = a(i(_.decodeUnknownSync(ne)(E(l.replayLimits ?? {}), { onExcessProperty: "error" }))), I = E(l.schemaOptions ?? {});
+	I.codecLimits !== void 0 && (I.codecLimits = E(I.codecLimits));
+	let { codecLimits: L, ...ue } = _.decodeUnknownSync(re)(I, { onExcessProperty: "error" }), R = Object.freeze({
+		...i(ue),
+		...L === void 0 ? {} : { codecLimits: Object.freeze(i(L)) }
+	}), z = () => T(le()), B = () => new Date(z()), V = (e) => s(c("tenantId", e.tenantId), c("replayId", e.replayId)), H = (e) => "rooms:replay:" + S(t(e)), U = (e) => H(e), W = async (e, t) => m.isEffect(e) ? t(e) : x("Replay authority must return actual Effects"), G = (e) => {
+		let t = _.decodeUnknownSync(te)(E(e.receipt), { onExcessProperty: "error" });
+		return !/^[a-f0-9]{64}$/.test(t.fingerprint) || !/^[a-f0-9]{64}$/.test(t.checksum) || t.size < 1 || t.size > F.maxBytes || t.durationMs < 0 || t.durationMs > F.maxDurationMs || t.schemaHash < 0 || t.schemaHash > 4294967295 || t.state === "ready" && t.refId === null || ["erasing", "erased"].includes(t.state) !== (t.eraseRequest !== null) || t.state === "erased" && t.refId !== null ? x("Invalid replay durable receipt") : (t.refId !== null && C(t.refId), t.eraseRequest !== null && C(t.eraseRequest), Object.freeze(t));
+	}, K = (e, n) => {
+		if (e.tenantId !== n.tenantId || e.replayId !== n.replayId) return x("Replay SQL identity mismatch");
+		let r = G(e);
+		if (r.state === "erased") {
+			if (e.roomId !== "" || e.roomName !== "" || e.matchId !== "" || D(e.participants, P).length || e.visibility !== "private" || e.expiresAt !== null) return x("Replay erasure retained unexpected metadata");
+		} else {
+			if (C(e.roomId), C(e.roomName), C(e.matchId), D(e.participants, P), ![
+				"private",
+				"unlisted",
+				"public"
+			].includes(String(e.visibility))) return x("Invalid replay visibility");
+			if (e.expiresAt !== null) {
+				if (!(e.expiresAt instanceof Date)) return x("Invalid replay SQL expiry");
+				T(e.expiresAt.getTime());
+			}
+			let n = S(t({
+				roomId: e.roomId,
+				roomName: e.roomName,
+				matchId: e.matchId,
+				participants: D(e.participants, P),
+				visibility: e.visibility,
+				expiresAtMs: e.expiresAt instanceof Date ? e.expiresAt.getTime() : null,
+				checksum: r.checksum,
+				size: r.size,
+				schemaHash: r.schemaHash,
+				durationMs: r.durationMs
+			}));
+			if (r.fingerprint !== n) return x("Replay SQL metadata differs from its publication identity");
+		}
+		for (let t of ["createdAt", "updatedAt"]) if (!(e[t] instanceof Date) || !Number.isFinite(e[t].getTime())) return x("Invalid replay SQL timestamp");
+		return r;
+	}, q = async (e, t, n = !1) => {
+		let r = await e.query({
+			table: y,
+			predicate: V(t),
+			order: [],
+			take: 2,
+			skip: void 0,
+			projection: void 0,
+			...n ? { lock: "update" } : {}
+		});
+		return r.length > 1 ? x("Duplicate replay SQL authority") : r.length ? (K(r[0], t), r[0]) : null;
+	}, J = (e, t) => {
+		let n = K(e, t);
+		return n.state === "ready" ? Object.freeze({
+			replayId: t.replayId,
+			roomId: C(e.roomId),
+			roomName: C(e.roomName),
+			matchId: C(e.matchId),
+			visibility: e.visibility === "public" ? "public" : e.visibility === "unlisted" ? "unlisted" : "private",
+			expiresAtMs: e.expiresAt instanceof Date ? e.expiresAt.getTime() : null,
+			durationMs: n.durationMs,
+			size: n.size,
+			schemaHash: n.schemaHash
+		}) : x("Replay is not ready");
+	}, Y = async (e, t, n) => {
+		if (await e.updateMany("_voltro_replays", {
+			...n,
+			updatedAt: B()
+		}, { where: V(t) }) !== 1) return x("Replay lost its SQL transition");
+	}, X = (e, t, n) => {
+		if (!e || e.tenantId !== t.tenantId || n.refId !== null && e.id !== n.refId || e.size !== n.size || e.checksum !== n.checksum || e.visibility !== "private" || e.contentType !== "application/octet-stream") return x("Replay storage ownership or content mismatch");
+		C(e.id);
+	}, Z = (t) => {
+		let n;
+		try {
+			n = t();
+		} catch {
+			return m.fail(new e({ detail: "Replay admission failed" }));
+		}
+		return m.flatMap(m.context(), (t) => m.uninterruptible(m.tryPromise({
+			try: () => n(r(t)),
+			catch: (t) => t instanceof e ? t : new e({ detail: "Replay operation remains unconfirmed" })
+		})));
+	}, Q = async (e) => {
+		let t = await n.query({
+			table: y,
+			predicate: c("tenantId", e.target.tenantId),
+			order: [{
+				column: "replayId",
+				direction: "asc"
+			}],
+			take: N + 1,
+			skip: void 0,
+			projection: void 0
+		});
+		return t.length > N || new Set(t.map((e) => e.replayId)).size !== t.length ? x("Complete tenant replay inventory exceeds its budget") : Object.freeze(t.filter((t) => {
+			let n = O({
+				tenantId: e.target.tenantId,
+				replayId: C(t.replayId)
+			});
+			return K(t, n).state !== "erased" && D(t.participants, P).includes(e.target.subjectId);
+		}));
+	}, $ = async (e, t, r) => {
+		await W(M(e, "erase"), r);
+		let i = await n.transactional(async (n) => {
+			let r = await q(n, e, !0);
+			if (!r) return x("Replay has no erasure authority");
+			let i = K(r, e);
+			if (i.state === "erased") return i;
+			if (i.state === "erasing" && i.eraseRequest !== t) return x("Replay erasure request changed");
+			let a = {
+				...i,
+				state: "erasing",
+				eraseRequest: t
+			};
+			return await Y(n, e, { receipt: a }), a;
+		});
+		if (i.state === "erased") return;
+		await W(oe(e, t), r);
+		let a = await g({
+			tenantId: e.tenantId,
+			bucket: h,
+			operationId: H(e)
+		}, U(e));
+		if (!a || a.state === "reserved") return x("Replay upload outcome remains pending");
+		X(a.ref, e, i), (a.state === "deleting" || a.state === "ready" && a.held) && await r(ae(a.ref.id, {
+			tenantId: e.tenantId,
+			claim: U(e)
+		}));
+		let o = await g({
+			tenantId: e.tenantId,
+			bucket: h,
+			operationId: H(e)
+		}, U(e));
+		if (!o || o.state === "reserved") return x("Replay claim release remains unconfirmed");
+		if (X(o.ref, e, i), o.state !== "deleted" && (o.state !== "ready" || o.held)) return x("Replay claim release or provider deletion is still pending");
+		await n.transactional(async (n) => {
+			let r = await q(n, e, !0);
+			if (!r) return x("Replay lost its erasure receipt");
+			let a = K(r, e);
+			if (a.state !== "erased") {
+				if (a.state !== "erasing" || a.eraseRequest !== t || a.fingerprint !== i.fingerprint) return x("Replay erasure receipt changed");
+				await Y(n, e, {
+					roomId: "",
+					roomName: "",
+					matchId: "",
+					participants: [],
+					visibility: "private",
+					expiresAt: null,
+					receipt: {
+						...a,
+						state: "erased",
+						refId: null
+					}
+				});
+			}
+		});
+	};
+	return Object.freeze({
+		publish: (e) => Z(() => {
+			let r = E(e);
+			if (Object.keys(r).some((e) => ![
+				"tenantId",
+				"replayId",
+				"roomId",
+				"roomName",
+				"matchId",
+				"participants",
+				"visibility",
+				"expiresAtMs",
+				"bytes"
+			].includes(e))) return x("Unknown replay publication field");
+			let i = { ...r };
+			delete i.bytes;
+			let { tenantId: a, replayId: s, ...c } = A(i, P), l = O({
+				tenantId: a,
+				replayId: s
+			}), u = c.participants;
+			if (!(r.bytes instanceof Uint8Array) || r.bytes.length > F.maxBytes) return x("Replay archive exceeds its budget");
+			let d = r.bytes.slice(), f = ie(o(d, F, R)).metadata, p = S(d), m = S(t({
+				...c,
+				checksum: p,
+				size: d.length,
+				schemaHash: f.schemaHash,
+				durationMs: f.durationMs
+			})), g = {
+				version: 1,
+				fingerprint: m,
+				checksum: p,
+				size: d.length,
+				durationMs: f.durationMs,
+				schemaHash: f.schemaHash,
+				state: "uploading",
+				refId: null,
+				eraseRequest: null
+			};
+			return async (e) => {
+				if (await W(M(l, "publish"), e), c.expiresAtMs !== null && c.expiresAtMs <= z()) return x("New replay expiry must be in the future");
+				await n.insertIgnore(y, {
+					tenantId: l.tenantId,
+					replayId: l.replayId,
+					roomId: c.roomId,
+					roomName: c.roomName,
+					matchId: c.matchId,
+					participants: [...u],
+					visibility: c.visibility,
+					expiresAt: c.expiresAtMs === null ? null : new Date(c.expiresAtMs),
+					receipt: g,
+					createdAt: B(),
+					updatedAt: B()
+				}, { conflictColumns: ["tenantId", "replayId"] });
+				let r = await n.transactional((e) => q(e, l, !0));
+				if (!r) return x("Replay lost its upload journal");
+				let i = K(r, l);
+				if (i.fingerprint !== m || i.checksum !== p) return x("Replay publication identity changed");
+				if (i.state === "ready") return J(r, l);
+				if (i.state !== "uploading") return x("Replay publication is withdrawn");
+				let a = await e(v({
+					bytes: d,
+					tenantId: l.tenantId,
+					visibility: "private",
+					contentType: "application/octet-stream",
+					operationId: H(l),
+					claim: U(l),
+					key: "replays/" + S(t(l)),
+					destination: h
+				}));
+				return X(a, l, i), n.transactional(async (e) => {
+					let t = await q(e, l, !0);
+					if (!t) return x("Replay lost its publication receipt");
+					let n = K(t, l);
+					if (n.fingerprint !== m || !["uploading", "ready"].includes(n.state)) return x("Replay publication was withdrawn");
+					if (n.state === "ready") return n.refId === a.id ? J(t, l) : x("Replay provider identity changed");
+					let r = {
+						...n,
+						state: "ready",
+						refId: a.id
+					};
+					return await Y(e, l, { receipt: r }), J({
+						...t,
+						receipt: r
+					}, l);
+				});
+			};
+		}),
+		load: (e) => Z(() => {
+			let t = O(e);
+			return async (e) => {
+				await W(M(t, "load"), e);
+				let r = await q(n, t);
+				if (!r) return x("Replay is absent");
+				let i = K(r, t), a = J(r, t);
+				if (a.expiresAtMs !== null && a.expiresAtMs <= z()) return x("Replay has expired");
+				let s = await g({
+					tenantId: t.tenantId,
+					bucket: h,
+					operationId: H(t)
+				}, U(t));
+				if (!s || s.state !== "ready" || !s.held) return x("Replay storage claim is not ready");
+				X(s.ref, t, i);
+				let c = await e(b(s.ref.id, { tenantId: t.tenantId }));
+				if (!c) return x("Replay storage reference is absent");
+				X(c, t, i);
+				let l = await e(j(c.id, { tenantId: t.tenantId }));
+				X(l.ref, t, i);
+				let u = new Uint8Array(i.size), d = 0;
+				if (await e(ee.runForEach(l.stream, (e) => m.sync(() => {
+					if (!(e instanceof Uint8Array) || e.length > u.length - d) return x("Replay stream exceeds its recorded size");
+					u.set(e, d), d += e.length;
+				}))), d !== u.length || S(u) !== i.checksum) return x("Replay storage content integrity failed");
+				let f = ie(o(u, F, R));
+				if (f.metadata.schemaHash !== i.schemaHash || f.metadata.durationMs !== i.durationMs) return x("Replay archive differs from SQL metadata");
+				let p = await q(n, t);
+				if (!p || K(p, t).state !== "ready") return x("Replay read was withdrawn");
+				let _ = J(p, t);
+				return _.expiresAtMs !== null && _.expiresAtMs <= z() ? x("Replay expired during its read") : (await W(M(t, "load"), e), u);
+			};
+		}),
+		erase: (e, t) => Z(() => {
+			let n = O(e), r = C(t);
+			return (e) => $(n, r, e);
+		}),
+		expire: (e, t) => Z(() => {
+			let r = O(e), i = C(t);
+			return async (e) => {
+				await W(M(r, "erase"), e);
+				let t = await q(n, r);
+				if (!t) return x("Replay has no retention authority");
+				if (K(t, r).state !== "erased" && (t.expiresAt === null || !(t.expiresAt instanceof Date) || t.expiresAt.getTime() > z())) return x("Replay retention has not expired");
+				await $(r, i, e);
+			};
+		}),
+		subjectRooms: (e) => Z(() => {
+			let t = k(e);
+			return async (e) => (await W(se(t, "rooms"), e), Object.freeze([...new Set((await Q(t)).map((e) => C(e.roomId)))].sort()));
+		}),
+		eraseSubject: (e) => Z(() => {
+			let t = k(e);
+			return async (e) => {
+				await W(ce(t), e);
+				let n = await Q(t);
+				for (let r of n) await $(O({
+					tenantId: t.target.tenantId,
+					replayId: C(r.replayId)
+				}), t.requestId, e);
+				if ((await Q(t)).length) return x("Replay subject gained an unfenced association");
+			};
+		}),
+		exportSubject: (e, t) => Z(() => {
+			let n = k(e), r = t === void 0 ? void 0 : C(t);
+			return async (e) => (await W(se(n, "export"), e), Object.freeze((await Q(n)).filter((e) => G(e).state === "ready" && (r === void 0 || e.roomId === r)).map((e) => J(e, O({
+				tenantId: n.target.tenantId,
+				replayId: C(e.replayId)
+			})))));
+		})
+	});
+}, ae = (e, t) => h.succeed(n, j(e, t)), M = (e, t) => {
+	let n = e.withdraw.bind(e), r = e.rooms.bind(e), i = e.eraseAssociations.bind(e), a = e.exportRoom.bind(e), o = t.subjectRooms.bind(t), s = t.eraseSubject.bind(t), c = t.exportSubject.bind(t);
+	return Object.freeze({
+		withdraw: n,
+		rooms: (e) => {
+			let t = k(e);
+			return m.all([r(t), o(t)]).pipe(m.map(([e, t]) => [.../* @__PURE__ */ new Set([...e, ...t])].sort()));
+		},
+		eraseAssociations: (e) => {
+			let t = k(e);
+			return s(t).pipe(m.andThen(m.suspend(() => i(t))));
+		},
+		exportRoom: (e, t) => {
+			let n = C(e), r = k(t);
+			return m.all([a(n, r), c(r, n)]).pipe(m.map(([e, t]) => ({
+				room: e,
+				replays: t
+			})));
+		}
+	});
+};
+export { y as ROOM_REPLAYS_TABLE, n as RoomReplayPort, A as captureRoomReplayMetadata, j as dataStoreRoomReplays, ae as roomReplayLayer, b as roomReplayTable, M as withRoomReplayPrivacy };