@voltro/plugin-progression 0.0.0-stage → 0.88.0

package/dist/questStore.js

@@ -0,0 +1,591 @@
+import { ProgressionError as e, progressionError as t } from "./errors.js";
+import { identifier as n, integer as r, list as i, object as a } from "./capture.js";
+import { captureQuestSignal as o, defaultQuestProgressResolver as s, defaultQuestSelector as c, defineQuest as l, defineQuestPool as u, questTimezone as d, resolveQuestProgress as f, selectQuests as p } from "./quests.js";
+import { questDefinitionsTable as m, questOperationsTable as h, questOriginsTable as g, questRewardsTable as _, questSubjectsTable as v, questWindowsTable as y, questsTable as b } from "./questTables.entity.js";
+import { Effect as x } from "effect";
+import { createHash as S } from "node:crypto";
+import { and as C, eq as w, queryFor as T } from "@voltro/database";
+// src/questStore.ts
+var E = (e) => {
+	let o = a(e, [
+		"source",
+		"channel",
+		"locale",
+		"allowedServices",
+		"eventSources",
+		"statSources",
+		"maxWorkRows",
+		"now",
+		"strategies"
+	]), l = a(o.source), u = a(o.strategies ?? {}, [
+		"questSelector",
+		"questProgressResolver",
+		"version"
+	]), d = u.questSelector ?? c, f = u.questProgressResolver ?? s, p = o.now ?? Date.now;
+	if (typeof l.read != "function" || typeof d != "function" || typeof f != "function" || typeof p != "function" || (d !== c || f !== s) && u.version === void 0) throw t("invalid_input");
+	let m = (e, r) => {
+		let a = Object.freeze(i(e ?? [], r).map(n));
+		if (new Set(a).size !== a.length) throw t("invalid_input");
+		return a;
+	};
+	return Object.freeze({
+		source: Object.freeze({ read: l.read }),
+		channel: n(o.channel),
+		locale: n(o.locale),
+		allowedServices: m(o.allowedServices, 256),
+		eventSources: m(o.eventSources, 64),
+		statSources: m(o.statSources, 64),
+		maxWorkRows: r(o.maxWorkRows ?? 1e4, 1, 1e5),
+		now: p,
+		strategies: Object.freeze({
+			questSelector: d,
+			questProgressResolver: f,
+			version: n(u.version ?? "default.v1")
+		})
+	});
+}, D = (e) => {
+	if (e === null || typeof e == "string" || typeof e == "boolean" || typeof e == "number" && Number.isFinite(e)) return e;
+	if (Array.isArray(e)) return i(e, 1e5).map(D);
+	let t = a(e);
+	return Object.fromEntries(Object.keys(t).sort().map((e) => [e, D(t[e])]));
+}, O = (e) => S("sha256").update(JSON.stringify(D(e))).digest("hex"), k = (e, ...t) => e + O(t).slice(0, 56), A = (n) => x.tryPromise({
+	try: n,
+	catch: (n) => n instanceof e ? n : t("unavailable")
+}), j = (e) => {
+	let n = e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN;
+	if (!Number.isSafeInteger(n) || n < 0 || n > 864e13) throw t("invalid_record");
+	return n;
+}, M = (s, c) => {
+	let S = E(c), D = new Set(S.allowedServices), M = (e) => e.type === "system" || e.type === "service" && D.has(e.service), N = (e) => {
+		if (e.type !== "user") throw t("forbidden");
+		return {
+			tenantId: n(e.tenantId),
+			ownerId: n(e.id)
+		};
+	}, P = (n) => {
+		try {
+			return n();
+		} catch (n) {
+			return x.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	}, F = () => r(S.now(), 0, 864e13), I = (e, t) => k("qps_", e, t), L = (e, t) => C(w("tenantId", e), w("ownerId", t)), R = async (e, t) => {
+		try {
+			await s.insertIgnore(e, t, { conflictColumns: ["id"] });
+		} catch (n) {
+			if (!(await s.query({
+				table: e,
+				predicate: w("id", t.id),
+				order: [],
+				take: 1,
+				skip: void 0,
+				projection: void 0
+			}))[0]) throw n;
+		}
+	}, z = (e, t) => R(v.tableName, {
+		id: I(e, t),
+		tenantId: e,
+		ownerId: t,
+		erased: !1,
+		admission: 0
+	}), B = (e, n, r, i = !1) => {
+		if (e) {
+			if (e.tenantId !== n) throw t("invalid_record");
+			if (e.erased === !0) {
+				if (i && e.ownerId === null) return;
+				throw t("erased");
+			}
+			if (e.erased !== !1 || e.ownerId !== r) throw t("invalid_record");
+		}
+	}, V = async (e, n, r, i = !1) => {
+		let a = I(n, r);
+		if (await e.updateMany(v.tableName, { admission: 0 }, { where: w("id", a) }) !== 1) throw t("unavailable");
+		let o = (await e.query(T(v).where(w("id", a)).limit(1).descriptor))[0];
+		if (!o) throw t("invalid_record");
+		B(o, n, r, i);
+	}, H = async (e, n, r, i) => {
+		let a = await e.query(T(n).where(C(w("tenantId", r), w("ownerKey", i))).limit(S.maxWorkRows + 1).descriptor);
+		if (a.length > S.maxWorkRows) throw t("limit_exceeded");
+		if (a.some((e) => e.tenantId !== r || e.ownerKey !== i)) throw t("invalid_record");
+		return a;
+	}, U = async (e, n, r, i) => {
+		let a = await e.query(T(n).where(L(r, i)).limit(S.maxWorkRows + 1).descriptor);
+		if (a.length > S.maxWorkRows) throw t("limit_exceeded");
+		if (a.some((e) => e.tenantId !== r || e.ownerId !== i || e.ownerKey !== I(r, i))) throw t("invalid_record");
+		return a;
+	}, W = (e) => {
+		let o = a(e.receipt, [
+			"operationId",
+			"kind",
+			"assignmentIds",
+			"completedIds",
+			"rewardsQueued",
+			"at"
+		]);
+		if (o.operationId !== e.id || o.kind !== "assign" && o.kind !== "record" && o.kind !== "reroll") throw t("invalid_record");
+		let s = Object.freeze(i(o.assignmentIds, 8).map(n)), c = Object.freeze(i(o.completedIds, 8).map(n)), l = r(o.at, 0, 864e13);
+		if (new Set(s).size !== s.length || new Set(c).size !== c.length || c.some((e) => !s.includes(e)) || j(e.createdAt) > l) throw t("invalid_record");
+		return Object.freeze({
+			operationId: n(e.id),
+			kind: o.kind,
+			assignmentIds: s,
+			completedIds: c,
+			rewardsQueued: r(o.rewardsQueued, 0, 512),
+			at: l
+		});
+	}, G = async (e, r, i, a, o) => {
+		if (await e.updateMany(h.tableName, { admission: 0 }, { where: w("id", r) }) !== 1) throw t("unavailable");
+		let s = (await e.query(T(h).where(w("id", r)).limit(1).descriptor))[0];
+		if (!s || s.tenantId !== i || s.ownerKey !== a) throw t("invalid_record");
+		if (s.state === "committed" || s.state === "replayed") {
+			if (s.digest !== o) throw t("conflict");
+			if (s.state === "committed") {
+				if (s.linkedOperationId !== null) throw t("invalid_record");
+				return W(s);
+			}
+			let r = (await e.query(T(h).where(w("id", n(s.linkedOperationId))).limit(1).descriptor))[0];
+			if (!r || r.tenantId !== i || r.ownerKey !== a || r.state !== "committed" || r.digest !== o) throw t("invalid_record");
+			return W(r);
+		}
+		if (s.state !== "pending" || s.digest !== null || s.receipt !== null || s.linkedOperationId !== null) throw t("invalid_record");
+		await H(e, h, i, a);
+	}, K = (e, n, r) => A(async () => {
+		let { tenantId: i, ownerId: a, requestId: o, kind: c, payload: l } = e, u = I(i, a), d = k("qpo_", i, a, o), f = O({
+			tenantId: i,
+			ownerId: a,
+			kind: c,
+			payload: l
+		}), p = F();
+		await z(i, a);
+		let m = await s.transactional(async (e) => {
+			if (await V(e, i, a), !(await e.query(T(h).where(w("id", d)).limit(1).descriptor))[0]) {
+				if ((await H(e, h, i, u)).length >= S.maxWorkRows) throw t("limit_exceeded");
+				await e.insert(h.tableName, {
+					id: d,
+					tenantId: i,
+					ownerKey: u,
+					state: "pending",
+					linkedOperationId: null,
+					digest: null,
+					receipt: null,
+					createdAt: new Date(p),
+					admission: 0
+				});
+			}
+			return G(e, d, i, u, f);
+		});
+		if (m) return m;
+		let g = await n();
+		return s.transactional(async (e) => {
+			await V(e, i, a);
+			let t = await G(e, d, i, u, f);
+			if (t) return t;
+			let n = await r(e, g, p, d);
+			return n.operationId === d ? await e.update(h.tableName, d, {
+				state: "committed",
+				digest: f,
+				receipt: n
+			}) : await e.update(h.tableName, d, {
+				state: "replayed",
+				digest: f,
+				linkedOperationId: n.operationId
+			}), n;
+		});
+	}), q = async (e, i, a, o, s) => {
+		let c = k("qpw_", i, a, o, s), l = (await e.query(T(y).where(w("id", c)).limit(1).descriptor))[0];
+		if (!l) throw t("not_found");
+		if (l.tenantId !== i || l.ownerId !== a || l.ownerKey !== I(i, a) || l.poolId !== o || l.windowId !== s || l.rulesVersion !== S.strategies.version) throw t("invalid_record");
+		let f = u(l.pool), p = j(l.startsAt), m = j(l.expiresAt);
+		if (f.id !== o || m <= p || m - p > 316224e5) throw t("invalid_record");
+		let h = d(l.timezone), g = r(l.seed, 0, 2147483647), _ = r(l.rerollsUsed, 0, f.rerolls);
+		if (f.refresh.timezone !== "player" && f.refresh.timezone !== h) throw t("invalid_record");
+		return n(l.sourceRevision), {
+			row: l,
+			pool: f,
+			from: p,
+			until: m,
+			timezone: h,
+			seed: g,
+			rerollsUsed: _
+		};
+	}, J = async (e, n, a, o) => {
+		let s = await e.query(T(b).where(C(L(n, a), w("windowKey", o.row.id))).limit(17).descriptor);
+		if (s.length > o.pool.slots + o.pool.rerolls) throw t("invalid_record");
+		let c = s.map((e) => {
+			if (e.tenantId !== n || e.ownerId !== a || e.ownerKey !== I(n, a) || e.windowKey !== o.row.id || e.poolId !== o.pool.id || e.windowId !== o.row.windowId || e.state !== "active" && e.state !== "completed" && e.state !== "rerolled") throw t("invalid_record");
+			let s = r(e.slot, 1, o.pool.slots), c = r(e.generation, 0, o.pool.rerolls), u = l(e.definition);
+			if (e.id !== k("qpa_", String(o.row.id), String(s), String(c)) || e.questId !== u.id || !o.pool.quests.some((e) => e.id === u.id && O(e) === O(u)) || j(e.expiresAt) !== o.until || j(e.assignedAt) < o.from || j(e.assignedAt) >= o.until) throw t("invalid_record");
+			let d = Object.freeze(i(e.progress, 16).map((e, t) => r(e, 0, u.objectives[t]?.target ?? -1))), f = d.every((e, t) => e === u.objectives[t]?.target);
+			if (d.length !== u.objectives.length || e.state === "completed" && (!f || j(e.completedAt) < j(e.assignedAt) || j(e.completedAt) >= o.until) || e.state === "active" && (f || e.completedAt !== null) || e.state === "rerolled" && e.completedAt !== null) throw t("invalid_record");
+			return {
+				row: e,
+				quest: u,
+				progress: d,
+				slot: s,
+				generation: c
+			};
+		}), u = c.filter((e) => e.row.state !== "rerolled");
+		if (u.length !== o.pool.slots || new Set(u.map((e) => e.slot)).size !== u.length || new Set(c.map((e) => e.quest.id)).size !== c.length) throw t("invalid_record");
+		return c;
+	}, Y = async (e, n, r, i, a, o, s, c) => {
+		let l = n.pool.quests.find((e) => e.id === a);
+		if (!l) throw t("invalid_record");
+		let u = k("qpa_", String(n.row.id), String(o), String(s));
+		return await e.insert(b.tableName, {
+			id: u,
+			tenantId: r,
+			ownerId: i,
+			ownerKey: I(r, i),
+			windowKey: n.row.id,
+			poolId: n.pool.id,
+			windowId: n.row.windowId,
+			slot: o,
+			generation: s,
+			questId: a,
+			definition: l,
+			progress: l.objectives.map(() => 0),
+			state: "active",
+			assignedAt: new Date(c),
+			expiresAt: new Date(n.until),
+			completedAt: null
+		}), u;
+	}, X = (e, o) => P(() => {
+		let s = structuredClone(e), c = a(o, [
+			"tenantId",
+			"ownerId",
+			"poolId",
+			"requestId",
+			"windowId",
+			"from",
+			"until",
+			"timezone",
+			"seed",
+			"expectedPoolDigest"
+		]);
+		if (!M(s)) throw t("forbidden");
+		let l = n(c.tenantId), f = n(c.ownerId), h = n(c.poolId), g = n(c.windowId), _ = r(c.from, 0, 864e13), v = r(c.until, _ + 1, 864e13), C = d(c.timezone), E = r(c.seed, 0, 2147483647);
+		if (v - _ > 316224e5) throw t("invalid_input");
+		let D = c.expectedPoolDigest;
+		if (D !== void 0 && (typeof D != "string" || !/^[a-f0-9]{64}$/.test(D))) throw t("invalid_input");
+		let A = Object.freeze({
+			poolId: h,
+			windowId: g,
+			from: _,
+			until: v,
+			timezone: C,
+			seed: E,
+			...D === void 0 ? {} : { expectedPoolDigest: D }
+		});
+		return K({
+			tenantId: l,
+			ownerId: f,
+			requestId: n(c.requestId),
+			kind: "assign",
+			payload: A
+		}, async () => {
+			let e = a(await x.runPromise(S.source.read({
+				tenantId: l,
+				channel: S.channel,
+				locale: S.locale
+			})), ["revision", "pools"]), r = n(e.revision), o = i(e.pools, 64).map((e) => u(e));
+			if (new Set(o.map((e) => e.id)).size !== o.length) throw t("invalid_record");
+			let s = o.find((e) => e.id === h);
+			if (!s) throw t("not_found");
+			if (D !== void 0 && O(s) !== D) throw t("conflict");
+			if (s.refresh.timezone !== "player" && s.refresh.timezone !== C) throw t("invalid_input");
+			let c = k("qpd_", l, h, String(s.version));
+			return await R(m.tableName, {
+				id: c,
+				tenantId: l,
+				poolId: h,
+				version: s.version,
+				config: s,
+				rulesVersion: S.strategies.version,
+				admission: 0
+			}), {
+				pool: s,
+				revision: r,
+				definitionId: c
+			};
+		}, async (e, r, i, a) => {
+			if (i < _ || i >= v) throw t("conflict");
+			if (await e.updateMany(m.tableName, { admission: 0 }, { where: w("id", r.definitionId) }) !== 1) throw t("unavailable");
+			let o = (await e.query(T(m).where(w("id", r.definitionId)).limit(1).descriptor))[0];
+			if (!o || o.tenantId !== l || o.poolId !== h || o.version !== r.pool.version || o.rulesVersion !== S.strategies.version || O(o.config) !== O(r.pool)) throw t("conflict");
+			let s = k("qpw_", l, f, h, g), c = (await e.query(T(y).where(w("id", s)).limit(1).descriptor))[0], u;
+			if (c) {
+				let i = await q(e, l, f, h, g);
+				if (i.from !== _ || i.until !== v || i.timezone !== C || i.seed !== E || O(i.pool) !== O(r.pool)) throw t("conflict");
+				u = (await J(e, l, f, i)).filter((e) => e.row.state !== "rerolled").sort((e, t) => e.slot - t.slot).map((e) => n(e.row.id));
+			} else {
+				let n = await U(e, y, l, f), a = await U(e, b, l, f);
+				if (n.length >= S.maxWorkRows || a.length + r.pool.slots > S.maxWorkRows || n.some((e) => e.poolId === h && j(e.startsAt) < v && j(e.expiresAt) > _)) throw t("conflict");
+				await e.insert(y.tableName, {
+					id: s,
+					tenantId: l,
+					ownerId: f,
+					ownerKey: I(l, f),
+					poolId: h,
+					windowId: g,
+					startsAt: new Date(_),
+					expiresAt: new Date(v),
+					timezone: C,
+					seed: E,
+					rerollsUsed: 0,
+					pool: r.pool,
+					sourceRevision: r.revision,
+					rulesVersion: S.strategies.version
+				});
+				let o = await q(e, l, f, h, g), c = p({
+					pool: r.pool,
+					count: r.pool.slots,
+					seed: E,
+					excluded: []
+				}, S.strategies.questSelector), d = [];
+				for (let [t, n] of c.entries()) d.push(await Y(e, o, l, f, n, t + 1, 0, i));
+				u = d;
+			}
+			return Object.freeze({
+				operationId: a,
+				kind: "assign",
+				assignmentIds: Object.freeze([...u]),
+				completedIds: Object.freeze([]),
+				rewardsQueued: 0,
+				at: i
+			});
+		});
+	}), Z = (e, r) => P(() => {
+		let i = structuredClone(e), s = a(r, [
+			"tenantId",
+			"ownerId",
+			"poolId",
+			"windowId",
+			"requestId",
+			"source",
+			"origin",
+			"signal"
+		]);
+		if (!M(i)) throw t("forbidden");
+		let c = n(s.tenantId), l = n(s.ownerId), u = n(s.poolId), d = n(s.windowId), p = n(s.source), m = n(s.origin), v = o(s.signal);
+		if (!(v.kind === "event" ? S.eventSources : S.statSources).includes(p)) throw t("forbidden");
+		let y = Object.freeze({
+			poolId: u,
+			windowId: d,
+			source: p,
+			origin: m,
+			signal: v
+		}), x = O({
+			tenantId: c,
+			ownerId: l,
+			kind: "record",
+			payload: y
+		}), C = I(c, l);
+		return K({
+			tenantId: c,
+			ownerId: l,
+			requestId: n(s.requestId),
+			kind: "record",
+			payload: y
+		}, async () => void 0, async (e, r, i, a) => {
+			let o = k("qpn_", c, l, u, d, p, m), s = (await e.query(T(g).where(w("id", o)).limit(1).descriptor))[0];
+			if (s) {
+				if (s.tenantId !== c || s.ownerKey !== C || s.source !== p || s.origin !== m || s.digest !== x) throw t("conflict");
+				let r = (await e.query(T(h).where(w("id", n(s.operationId))).limit(1).descriptor))[0];
+				if (!r || r.tenantId !== c || r.ownerKey !== C || r.state !== "committed" || r.digest !== x) throw t("invalid_record");
+				return W(r);
+			}
+			let y = await q(e, c, l, u, d);
+			if (i < y.from || i >= y.until) throw t("conflict");
+			let E = (await J(e, c, l, y)).filter((e) => e.row.state !== "rerolled").sort((e, t) => e.slot - t.slot), D = [], O = await H(e, _, c, C);
+			if ((await H(e, g, c, C)).length >= S.maxWorkRows) throw t("limit_exceeded");
+			let A = 0;
+			for (let r of E) if (r.row.state === "active") {
+				let o = f({
+					quest: r.quest,
+					progress: r.progress,
+					signal: v
+				}, S.strategies.questProgressResolver), s = o.every((e, t) => e === r.quest.objectives[t]?.target);
+				if (await e.update(b.tableName, String(r.row.id), {
+					progress: o,
+					state: s ? "completed" : "active",
+					completedAt: s ? new Date(i) : null
+				}), s) {
+					D.push(n(r.row.id));
+					for (let [n, o] of r.quest.reward.entries()) {
+						if (O.length + A >= S.maxWorkRows) throw t("limit_exceeded");
+						await e.insert(_.tableName, {
+							id: k("qpr_", String(r.row.id), String(n)),
+							tenantId: c,
+							ownerId: l,
+							ownerKey: C,
+							operationId: a,
+							assignmentId: r.row.id,
+							reward: o,
+							state: "pending",
+							createdAt: new Date(i),
+							deliveredAt: null,
+							deliveryIntent: null,
+							deliveryDigest: null,
+							deliveryReceipt: null
+						}), A++;
+					}
+				}
+			}
+			return await e.insert(g.tableName, {
+				id: o,
+				tenantId: c,
+				ownerKey: C,
+				operationId: a,
+				source: p,
+				origin: m,
+				digest: x
+			}), Object.freeze({
+				operationId: a,
+				kind: "record",
+				assignmentIds: Object.freeze(E.map((e) => n(e.row.id))),
+				completedIds: Object.freeze(D),
+				rewardsQueued: A,
+				at: i
+			});
+		});
+	}), Q = (e, r) => P(() => {
+		let i = structuredClone(e), { tenantId: o, ownerId: s } = N(i), c = a(r, [
+			"poolId",
+			"windowId",
+			"assignmentId",
+			"requestId"
+		]), l = n(c.poolId), u = n(c.windowId), d = n(c.assignmentId), f = Object.freeze({
+			poolId: l,
+			windowId: u,
+			assignmentId: d
+		});
+		return K({
+			tenantId: o,
+			ownerId: s,
+			requestId: n(c.requestId),
+			kind: "reroll",
+			payload: f
+		}, async () => void 0, async (e, n, r, i) => {
+			let a = await q(e, o, s, l, u);
+			if (r < a.from || r >= a.until || a.rerollsUsed >= a.pool.rerolls) throw t("conflict");
+			let c = await J(e, o, s, a), f = c.find((e) => e.row.id === d);
+			if (!f || f.row.state !== "active") throw t("forbidden");
+			if ((await U(e, b, o, s)).length >= S.maxWorkRows) throw t("limit_exceeded");
+			let m = a.rerollsUsed + 1, h = p({
+				pool: a.pool,
+				count: 1,
+				seed: (a.seed ^ m) >>> 0,
+				excluded: c.map((e) => e.quest.id)
+			}, S.strategies.questSelector)[0];
+			await e.update(b.tableName, d, { state: "rerolled" }), await e.update(y.tableName, String(a.row.id), { rerollsUsed: m });
+			let g = await Y(e, a, o, s, h, f.slot, m, r);
+			return Object.freeze({
+				operationId: i,
+				kind: "reroll",
+				assignmentIds: Object.freeze([g]),
+				completedIds: Object.freeze([]),
+				rewardsQueued: 0,
+				at: r
+			});
+		});
+	}), ee = (e) => P(() => {
+		let r = structuredClone(e), { tenantId: i, ownerId: a } = N(r);
+		return A(async () => s.transactional(async (e) => {
+			let r = (await e.query(T(v).where(w("id", I(i, a))).forUpdate().limit(1).descriptor))[0];
+			B(r, i, a);
+			let o = F(), s = await U(e, y, i, a), c = [];
+			if (!r && s.length > 0) throw t("invalid_record");
+			for (let t of s) {
+				let r = await q(e, i, a, n(t.poolId), n(t.windowId));
+				if (!(o < r.from || o >= r.until)) for (let o of await J(e, i, a, r)) o.row.state !== "rerolled" && c.push(Object.freeze({
+					id: n(o.row.id),
+					poolId: r.pool.id,
+					windowId: n(t.windowId),
+					quest: o.quest,
+					progress: o.progress,
+					state: o.row.state,
+					assignedAt: j(o.row.assignedAt),
+					expiresAt: r.until,
+					rerollsUsed: r.rerollsUsed,
+					rerollsAllowed: r.pool.rerolls
+				}));
+			}
+			return Object.freeze(c.sort((e, t) => e.poolId < t.poolId ? -1 : e.poolId > t.poolId ? 1 : e.id < t.id ? -1 : +(e.id > t.id)));
+		}));
+	}), $ = (e, r) => P(() => {
+		let i = a(e, [
+			"subjectId",
+			"tenantId",
+			"kind"
+		]), o = n(i.tenantId), c = n(i.subjectId), l = I(o, c);
+		if (i.kind !== "user" && i.kind !== "guest") throw t("forbidden");
+		return A(async () => (await z(o, c), s.transactional(async (e) => {
+			await V(e, o, c, !0);
+			let t = await U(e, y, o, c), n = await U(e, b, o, c);
+			for (let t of [
+				h,
+				g,
+				_
+			]) await H(e, t, o, l);
+			let i = await H(e, _, o, l);
+			if (!r) return {
+				...i.length ? { rewards: i.map((e) => ({
+					reward: e.reward,
+					state: e.state,
+					deliveryIntent: e.deliveryIntent ?? null,
+					deliveryReceipt: e.deliveryReceipt ?? null
+				})) } : {},
+				windows: t.map((e) => ({
+					poolId: e.poolId,
+					windowId: e.windowId,
+					from: j(e.startsAt),
+					until: j(e.expiresAt),
+					timezone: e.timezone,
+					rerollsUsed: e.rerollsUsed
+				})),
+				quests: n.map((e) => ({
+					id: e.id,
+					poolId: e.poolId,
+					windowId: e.windowId,
+					questId: e.questId,
+					progress: e.progress,
+					state: e.state,
+					assignedAt: j(e.assignedAt),
+					expiresAt: j(e.expiresAt)
+				}))
+			};
+			await e.deleteMany(b.tableName, { where: L(o, c) }), await e.deleteMany(y.tableName, { where: L(o, c) }), await e.updateMany(h.tableName, {
+				ownerKey: null,
+				state: "erased",
+				digest: null,
+				receipt: null,
+				linkedOperationId: null
+			}, { where: C(w("tenantId", o), w("ownerKey", l)) }), await e.updateMany(g.tableName, {
+				ownerKey: null,
+				source: null,
+				origin: null,
+				digest: null
+			}, { where: C(w("tenantId", o), w("ownerKey", l)) }), await e.updateMany(_.tableName, {
+				ownerId: null,
+				ownerKey: null,
+				state: "erased",
+				reward: null,
+				deliveryIntent: null,
+				deliveryDigest: null,
+				deliveryReceipt: null,
+				deliveredAt: null
+			}, { where: C(w("tenantId", o), w("ownerKey", l)) }), await e.update(v.tableName, l, {
+				ownerId: null,
+				erased: !0
+			});
+		})));
+	});
+	return Object.freeze({
+		assign: X,
+		record: Z,
+		reroll: Q,
+		mine: ee,
+		exportSubject: (e) => $(e, !1),
+		eraseSubject: (e) => x.asVoid($(e, !0))
+	});
+};
+export { M as dataStoreQuests, O as questHash, E as resolveQuestOptions };

package/dist/questTables.entity.js

@@ -0,0 +1,116 @@
+import { boolean as e, id as t, integer as n, json as r, table as i, text as a, timestamp as o } from "@voltro/database";
+// src/questTables.entity.ts
+var s = () => a().maxLength(120).externalId().sensitive("pii"), c = () => a().maxLength(120).externalId().sensitive("pii"), l = i("_voltro_prog_quest_definitions", {
+	id: t({ prefix: "qpd" }),
+	tenantId: s(),
+	poolId: a().maxLength(120).safe(),
+	version: n().safe(),
+	config: r().safe(),
+	rulesVersion: a().maxLength(120).safe(),
+	admission: n().serverOnly()
+}).index([
+	"tenantId",
+	"poolId",
+	"version"
+]), u = i("_voltro_prog_quest_subjects", {
+	id: t({ prefix: "qps" }),
+	tenantId: s(),
+	ownerId: c().nullable(),
+	erased: e().serverOnly(),
+	admission: n().serverOnly()
+}).index(["tenantId", "ownerId"]), d = i("_voltro_prog_quest_windows", {
+	id: t({ prefix: "qpw" }),
+	tenantId: s(),
+	ownerId: c(),
+	ownerKey: a().maxLength(64).serverOnly(),
+	poolId: a().maxLength(120).safe(),
+	windowId: a().maxLength(120).safe(),
+	startsAt: o().safe(),
+	expiresAt: o().safe(),
+	timezone: a().maxLength(64).safe(),
+	seed: n().serverOnly(),
+	rerollsUsed: n().safe(),
+	pool: r().safe(),
+	sourceRevision: a().maxLength(120).safe(),
+	rulesVersion: a().maxLength(120).safe()
+}).index(["tenantId", "ownerId"]), f = i("_voltro_prog_quests", {
+	id: t({ prefix: "qpa" }),
+	tenantId: s(),
+	ownerId: c(),
+	ownerKey: a().maxLength(64).serverOnly(),
+	windowKey: a().maxLength(64).serverOnly(),
+	poolId: a().maxLength(120).safe(),
+	windowId: a().maxLength(120).safe(),
+	slot: n().safe(),
+	generation: n().safe(),
+	questId: a().maxLength(120).safe(),
+	definition: r().safe(),
+	progress: r().safe(),
+	state: a().maxLength(16).oneOf([
+		"active",
+		"completed",
+		"rerolled"
+	]).safe(),
+	assignedAt: o().safe(),
+	expiresAt: o().safe(),
+	completedAt: o().nullable().safe()
+}).index([
+	"tenantId",
+	"ownerId",
+	"poolId",
+	"windowId"
+]), p = i("_voltro_prog_quest_operations", {
+	id: t({ prefix: "qpo" }),
+	tenantId: s(),
+	ownerKey: a().maxLength(64).nullable().serverOnly(),
+	state: a().maxLength(16).oneOf([
+		"pending",
+		"committed",
+		"replayed",
+		"erased"
+	]).serverOnly(),
+	linkedOperationId: a().maxLength(64).nullable().serverOnly(),
+	digest: a().maxLength(64).nullable().serverOnly(),
+	receipt: r().nullable().serverOnly(),
+	createdAt: o().safe(),
+	admission: n().serverOnly()
+}).index(["tenantId", "ownerKey"]), m = i("_voltro_prog_quest_origins", {
+	id: t({ prefix: "qpn" }),
+	tenantId: s(),
+	ownerKey: a().maxLength(64).nullable().serverOnly(),
+	operationId: a().maxLength(64).safe(),
+	source: a().maxLength(120).nullable().safe(),
+	origin: a().maxLength(120).nullable().sensitive("pii"),
+	digest: a().maxLength(64).nullable().serverOnly()
+}).index(["tenantId", "ownerKey"]), h = i("_voltro_prog_quest_rewards", {
+	id: t({ prefix: "qpr" }),
+	tenantId: s(),
+	ownerId: c().nullable(),
+	ownerKey: a().maxLength(64).nullable().serverOnly(),
+	operationId: a().maxLength(64).safe(),
+	assignmentId: a().maxLength(64).safe(),
+	reward: r().nullable().serverOnly(),
+	state: a().maxLength(16).oneOf([
+		"pending",
+		"delivered",
+		"erased"
+	]).serverOnly(),
+	createdAt: o().safe(),
+	deliveredAt: o().nullable().safe(),
+	deliveryIntent: r().nullable().serverOnly(),
+	deliveryDigest: a().maxLength(64).nullable().serverOnly(),
+	deliveryReceipt: r().nullable().serverOnly()
+}).index([
+	"tenantId",
+	"ownerKey",
+	"state"
+]), g = [
+	l,
+	u,
+	d,
+	f,
+	p,
+	m,
+	h
+];
+export { l as questDefinitionsTable, p as questOperationsTable, m as questOriginsTable, h as questRewardsTable, u as questSubjectsTable, g as questTables, d as questWindowsTable, f as questsTable };