@voltro/plugin-economy 0.0.0-stage → 0.87.0

package/dist/loyaltyStore.server.js

@@ -0,0 +1,553 @@
+import { EconomyError as e, economyError as t } from "./errors.js";
+import { captureBoundMethods as n, dataList as r, dataObject as i, identifier as a } from "./capture.js";
+import { economyAmount as o, nonNegativeAmount as s } from "./amount.js";
+import { captureCurrencies as c } from "./currency.js";
+import { shopInteger as l } from "./shop.js";
+import { defaultLoyaltyPerks as u, defaultLoyaltyTier as d, defineLoyalty as f, loyaltyCreditIntent as p, loyaltyMineIntent as m, loyaltyRebuildIntent as h, loyaltyReceiptIntent as g, loyaltyReverseIntent as _, projectLoyaltyPoints as v, resolveLoyaltyPerks as y, resolveLoyaltyTier as b } from "./loyalty.js";
+import { loyaltyDefinitionsTable as x, loyaltyEntriesTable as S, loyaltySeasonsTable as C, loyaltySubjectsTable as w, loyaltyTenantsTable as T } from "./loyaltyTables.entity.js";
+import { Effect as E, Result as D } from "effect";
+import { createHash as O } from "node:crypto";
+import { and as k, eq as A, queryFor as j } from "@voltro/database";
+//#region src/loyaltyStore.server.ts
+var M = (e) => Array.isArray(e) ? "[" + e.map(M).join(",") + "]" : typeof e == "object" && e ? "{" + Object.keys(e).sort().map((t) => JSON.stringify(t) + ":" + M(e[t])).join(",") + "}" : JSON.stringify(e), N = (e) => O("sha256").update(M(e)).digest("hex"), P = (e, ...t) => e + N(t).slice(0, 56), F = (n) => n instanceof e ? n : t("unavailable"), I = (e) => E.tryPromise({
+	try: e,
+	catch: F
+}), L = (n) => {
+	try {
+		return n();
+	} catch (n) {
+		return E.fail(n instanceof e ? n : t("invalid_input"));
+	}
+}, R = async (e) => {
+	let t = await E.runPromise(E.result(e));
+	if (D.isFailure(t)) throw t.failure;
+	return t.success;
+}, z = (e) => l(e, 0, 864e13), B = (e) => z(e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN), V = (e) => {
+	if (typeof e != "string" || s(e).toString() !== e) throw t("invalid_record");
+	return e;
+}, H = (e) => {
+	let n = i(e, [
+		"tenantId",
+		"ownerId",
+		"authorityId",
+		"purchaseId",
+		"kind",
+		"currency",
+		"amount",
+		"settledAt",
+		"refundedAmount"
+	], "invalid_record");
+	if (n.kind !== "purchase.real" && n.kind !== "purchase.virtual" || n.refundedAmount !== "0") throw t("invalid_record");
+	return Object.freeze({
+		tenantId: a(n.tenantId),
+		ownerId: a(n.ownerId),
+		authorityId: a(n.authorityId),
+		purchaseId: a(n.purchaseId),
+		kind: n.kind,
+		currency: a(n.currency),
+		amount: V(n.amount),
+		settledAt: z(n.settledAt),
+		refundedAmount: "0"
+	});
+}, U = (e) => {
+	let t = i(e, [
+		"tenantId",
+		"ownerId",
+		"authorityId",
+		"purchaseId",
+		"refundId",
+		"totalRefunded",
+		"refundedAt"
+	], "invalid_record");
+	return Object.freeze({
+		tenantId: a(t.tenantId),
+		ownerId: a(t.ownerId),
+		authorityId: a(t.authorityId),
+		purchaseId: a(t.purchaseId),
+		refundId: a(t.refundId),
+		totalRefunded: V(t.totalRefunded),
+		refundedAt: z(t.refundedAt)
+	});
+}, W = (e, n) => {
+	let r = i(e, [
+		"id",
+		"startsAt",
+		"endsAt"
+	], "invalid_record"), o = z(r.startsAt), s = z(r.endsAt);
+	if (o >= s || n !== void 0 && (n < o || n >= s)) throw t("invalid_record");
+	return Object.freeze({
+		id: a(r.id),
+		startsAt: o,
+		endsAt: s
+	});
+}, G = (e) => {
+	let o = i(e, [
+		"loyalty",
+		"currencies",
+		"realMoney",
+		"receiptSource",
+		"seasonSource",
+		"version",
+		"tier",
+		"perks",
+		"allowedServices",
+		"maxHistoryRows",
+		"maxDefinitionRows",
+		"maxSeasonRows",
+		"now"
+	]), s = c(o.currencies), p = o.realMoney ?? !1;
+	if (typeof p != "boolean") throw t("invalid_input");
+	let m = Object.freeze(r(o.loyalty, 32).map((e) => f(e, s, p)));
+	if (!m.length || new Set(m.map((e) => e.id)).size !== m.length) throw t("invalid_input");
+	let h = n(o.receiptSource, ["purchase", "refund"]), g = o.seasonSource === void 0 ? void 0 : n(o.seasonSource, ["read"]);
+	if (m.some((e) => e.decay === "seasonal") && !g) throw t("invalid_input");
+	let _ = a(o.version), v = o.tier ?? d, y = o.perks ?? u, b = o.now ?? Date.now;
+	if (_ === "default.v1" || [
+		v,
+		y,
+		b
+	].some((e) => typeof e != "function")) throw t("invalid_input");
+	let x = Object.freeze(r(o.allowedServices ?? [], 256).map((e) => a(e)));
+	if (new Set(x).size !== x.length) throw t("invalid_input");
+	return Object.freeze({
+		loyalty: m,
+		currencies: s,
+		realMoney: p,
+		receiptSource: h,
+		seasonSource: g,
+		version: _,
+		tier: v,
+		perks: y,
+		now: b,
+		allowedServices: x,
+		maxHistoryRows: l(o.maxHistoryRows ?? 1e4, 1, 1e5),
+		maxDefinitionRows: l(o.maxDefinitionRows ?? 1024, 1, 1e5),
+		maxSeasonRows: l(o.maxSeasonRows ?? 1024, 1, 1e5)
+	});
+}, K = (e, n) => {
+	let r = G(n), u = new Set(r.allowedServices), d = () => z(r.now()), E = (e, t) => P("els_", e, t), D = (e, t, n) => P("ele_", e, t, n), O = (e, t, n, r) => N([
+		e,
+		t,
+		n,
+		r
+	]), M = (e, t, n, r) => N([
+		e,
+		t,
+		n,
+		r
+	]), F = (e) => {
+		let n = structuredClone(e);
+		if (n.type !== "user") throw t("forbidden");
+		return Object.freeze({
+			tenantId: a(n.tenantId),
+			ownerId: a(n.id)
+		});
+	}, K = (e) => {
+		let n = structuredClone(e);
+		if (n.type !== "system" && (n.type !== "service" || !u.has(n.service))) throw t("forbidden");
+	}, q = async (e, n, r, i = !1) => {
+		let a = (await e.query(j(w).where(A("id", E(n, r))).limit(1).descriptor))[0];
+		if (a) {
+			if (a.tenantId !== n || a.admission !== 0 || typeof a.erased != "boolean" || a.ownerId !== (a.erased ? null : r)) throw t("invalid_record");
+			if (l(a.entriesCount, 0, 1e5), a.erased && !i) throw t("erased");
+			return a;
+		}
+	}, J = async (t, n) => {
+		await e.insertIgnore(T.tableName, {
+			id: P("elt_", t),
+			tenantId: t,
+			admission: 0
+		}, { conflictColumns: ["id"] }), await e.insertIgnore(w.tableName, {
+			id: E(t, n),
+			tenantId: t,
+			ownerId: n,
+			erased: !1,
+			admission: 0,
+			entriesCount: 0
+		}, { conflictColumns: ["id"] });
+	}, Y = async (e, n, r, i = !1) => {
+		let a = P("elt_", n);
+		if (await e.updateMany(T.tableName, { admission: 0 }, { where: A("id", a) }) !== 1) throw t("unavailable");
+		let o = (await e.query(j(T).where(A("id", a)).limit(1).descriptor))[0];
+		if (!o || o.tenantId !== n || o.admission !== 0) throw t("invalid_record");
+		if (await e.updateMany(w.tableName, { admission: 0 }, { where: A("id", E(n, r)) }) !== 1 || !await q(e, n, r, i)) throw t("unavailable");
+	}, X = async (e, n, i) => {
+		let o = await e.query(j(C).where(k(A("tenantId", n), A("loyaltyId", i))).limit(r.maxSeasonRows + 1).descriptor);
+		if (o.length > r.maxSeasonRows) throw t("limit_exceeded");
+		let s = o.map((e) => {
+			let r = B(e.startsAt), o = B(e.endsAt), s = a(e.seasonId);
+			if (e.id !== P("elp_", n, i, s) || r >= o) throw t("invalid_record");
+			return Object.freeze({
+				id: s,
+				startsAt: r,
+				endsAt: o
+			});
+		}).sort((e, t) => e.startsAt - t.startsAt);
+		if (s.some((e, t) => t > 0 && e.startsAt < s[t - 1].endsAt)) throw t("invalid_record");
+		return s;
+	}, ee = async (e, n, i, a, o) => {
+		let s = await X(e, n, i), c = s.find((e) => e.id === a.id);
+		if (c) {
+			if (N(c) !== N(a)) throw t("conflict");
+		} else {
+			if (s.some((e) => a.startsAt < e.endsAt && a.endsAt > e.startsAt)) throw t("conflict");
+			if (o) {
+				if (s.length >= r.maxSeasonRows) throw t("limit_exceeded");
+				await e.insert(C.tableName, {
+					id: P("elp_", n, i, a.id),
+					tenantId: n,
+					loyaltyId: i,
+					seasonId: a.id,
+					startsAt: new Date(a.startsAt),
+					endsAt: new Date(a.endsAt)
+				});
+			}
+		}
+	}, te = (e, t) => ({
+		id: P("eld_", e, t.loyalty.id, t.loyalty.version, t.rulesVersion),
+		tenantId: e,
+		loyaltyId: t.loyalty.id,
+		definition: t.loyalty,
+		currencies: t.currencies,
+		realMoney: t.realMoney,
+		rulesVersion: t.rulesVersion
+	}), ne = async (e, n, i) => {
+		let a = te(n, i), o = await e.query(j(x).where(k(A("tenantId", n), A("loyaltyId", i.loyalty.id))).limit(r.maxDefinitionRows + 1).descriptor);
+		if (o.length > r.maxDefinitionRows) throw t("limit_exceeded");
+		for (let e of o) if (f(e.definition, e.currencies, e.realMoney).decay !== i.loyalty.decay) throw t("conflict");
+		let s = o.find((e) => e.id === a.id);
+		if (s) {
+			if (N(s) !== N(a)) throw t("conflict");
+		} else {
+			if (o.length >= r.maxDefinitionRows) throw t("limit_exceeded");
+			await e.insert(x.tableName, a);
+		}
+	}, re = async (e, n, r, s) => {
+		if (s.tenantId !== n || s.ownerId !== r || s.ownerKey !== E(n, r) || s.state !== "fulfilled") throw t("invalid_record");
+		let u = i(s.body, [
+			"kind",
+			"request",
+			"loyalty",
+			"currencies",
+			"realMoney",
+			"rulesVersion",
+			"evidence",
+			"season",
+			"entry",
+			"points"
+		], "invalid_record");
+		if (u.kind !== "credit" && u.kind !== "reverse" || typeof u.realMoney != "boolean") throw t("invalid_record");
+		let d = u.kind, m = d === "credit" ? p(u.request) : _(u.request), h = c(u.currencies), g = f(u.loyalty, h, u.realMoney), v = a(u.rulesVersion), y = i(u.entry, d === "credit" ? [
+			"id",
+			"sequence",
+			"kind",
+			"at",
+			"sourceId",
+			"purchaseId",
+			"seasonId",
+			"purchaseAmount",
+			"numerator",
+			"denominator",
+			"delta"
+		] : [
+			"id",
+			"sequence",
+			"kind",
+			"at",
+			"originalId",
+			"refundId",
+			"seasonId",
+			"totalRefunded",
+			"delta"
+		], "invalid_record");
+		if (typeof y.delta != "string" || o(y.delta).toString() !== y.delta) throw t("invalid_record");
+		let b = Object.freeze({
+			...y,
+			sequence: l(y.sequence, 1, 1e5),
+			at: z(y.at)
+		}), S = d === "credit" ? H(u.evidence) : U(u.evidence), C = d === "credit" ? S.settledAt : S.refundedAt, w = u.season === null ? null : W(u.season, d === "credit" ? C : void 0), T = V(u.points), k = z(b.at);
+		if (m.tenantId !== n || m.ownerId !== r || m.loyaltyId !== g.id || s.loyaltyId !== g.id || S.tenantId !== n || S.ownerId !== r || s.id !== D(n, r, m.requestId) || s.digest !== N([d, m]) || b.id !== s.id || b.kind !== d || B(s.createdAt) !== k || C > k || b.seasonId !== (w?.id ?? null) || g.decay === "none" && w !== null || g.decay === "seasonal" && w === null || v === "default.v1" || s.purchaseKey !== O(n, g.id, S.authorityId, S.purchaseId) || s.refundKey !== (d === "credit" ? null : M(n, g.id, S.authorityId, S.refundId))) throw t("invalid_record");
+		if (d === "credit") {
+			let e = S, n = m, r = b, i = g.pointsFrom.find((e) => e.id === n.sourceId);
+			if (!i || i.kind !== e.kind || i.currency !== e.currency || n.purchaseId !== e.purchaseId || r.sourceId !== i.id || r.purchaseId !== e.purchaseId || r.purchaseAmount !== e.amount || r.numerator !== i.numerator || r.denominator !== i.denominator) throw t("invalid_record");
+		} else {
+			let e = S, n = m, r = b;
+			if (r.originalId !== n.originalId || r.refundId !== n.refundId || e.refundId !== n.refundId || r.totalRefunded !== e.totalRefunded) throw t("invalid_record");
+		}
+		let P = Object.freeze({
+			kind: d,
+			request: m,
+			loyalty: g,
+			currencies: h,
+			realMoney: u.realMoney,
+			rulesVersion: v,
+			evidence: S,
+			season: w,
+			entry: b,
+			points: T
+		}), F = te(n, P), I = (await e.query(j(x).where(A("id", F.id)).limit(1).descriptor))[0];
+		if (!I || N(I) !== N(F)) throw t("invalid_record");
+		if (w) {
+			let r = (await X(e, n, g.id)).find((e) => e.id === w.id);
+			if (!r || N(r) !== N(w)) throw t("invalid_record");
+		}
+		return P;
+	}, Z = async (e, n, i) => {
+		let a = await q(e, n, i), o = await e.query(j(S).where(k(A("tenantId", n), A("ownerKey", E(n, i)))).limit(r.maxHistoryRows + 1).descriptor);
+		if (o.length > r.maxHistoryRows) throw t("limit_exceeded");
+		if (o.length !== (a?.entriesCount ?? 0)) throw t("invalid_record");
+		o.sort((e, t) => Number(e.sequence) - Number(t.sequence));
+		let c = [], l = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new Set(), f = /* @__PURE__ */ new Set();
+		for (let [r, a] of o.entries()) {
+			if (a.sequence !== r + 1) throw t("invalid_record");
+			let o = await re(e, n, i, a), p = l.get(o.loyalty.id) ?? [];
+			if (o.entry.at < (c.at(-1)?.entry.at ?? 0) || p.length && p[0].loyalty.decay !== o.loyalty.decay) throw t("invalid_record");
+			if (o.kind === "credit") {
+				if (d.has(String(a.purchaseKey))) throw t("invalid_record");
+				d.add(String(a.purchaseKey));
+			} else {
+				let e = o.entry, n = p.find((t) => t.entry.id === e.originalId);
+				if (!n || n.kind !== "credit" || N(n.loyalty) !== N(o.loyalty) || n.rulesVersion !== o.rulesVersion || N(n.season) !== N(o.season) || n.evidence.authorityId !== o.evidence.authorityId || n.evidence.purchaseId !== o.evidence.purchaseId || o.evidence.refundedAt < n.evidence.settledAt || f.has(String(a.refundKey))) throw t("invalid_record");
+				f.add(String(a.refundKey));
+			}
+			let m = JSON.stringify([o.loyalty.id, o.entry.seasonId]), h = s((u.get(m) ?? 0n) + BigInt(o.entry.delta));
+			if (o.points !== h.toString()) throw t("invalid_record");
+			u.set(m, h), p.push(o), l.set(o.loyalty.id, p), c.push(o);
+		}
+		let p = /* @__PURE__ */ new Map();
+		for (let [e, t] of l) p.set(e, v(t.map((e) => e.entry), t[0].loyalty.decay));
+		if ((await q(e, n, i))?.entriesCount !== a?.entriesCount) throw t("conflict");
+		return Object.freeze({
+			accepted: c,
+			programs: l,
+			projections: p,
+			count: o.length
+		});
+	}, Q = (e) => Object.freeze({
+		operationId: e.entry.id,
+		requestId: e.request.requestId,
+		loyaltyId: e.loyalty.id,
+		entry: e.entry,
+		points: e.points
+	}), $ = async (e, n, r, i, a, o) => {
+		let s = (await Z(e, n, r)).accepted.find((e) => e.entry.id === i);
+		if (s && a && (s.kind !== a || N(s.request) !== N(o))) throw t("conflict");
+		return s ? Q(s) : void 0;
+	}, ie = (n, i) => I(async () => {
+		let { tenantId: a, ownerId: o, loyaltyId: c } = i, l = D(a, o, i.requestId), u = await e.transactional((e) => $(e, a, o, l, n, i));
+		if (u) return u;
+		await J(a, o);
+		let f = await e.transactional((e) => Z(e, a, o));
+		if (f.count >= r.maxHistoryRows) throw t("limit_exceeded");
+		let p = d();
+		if (p < (f.accepted.at(-1)?.entry.at ?? 0)) throw t("invalid_record");
+		let m = f.programs.get(c) ?? [], h = f.projections.get(c), g, _, y, b, x, C, T;
+		if (n === "credit") {
+			let e = i, n = r.loyalty.find((e) => e.id === c);
+			if (!n) throw t("not_found");
+			g = n, _ = r.currencies, y = r.realMoney, b = r.version;
+			let u = g.pointsFrom.find((t) => t.id === e.sourceId);
+			if (!u) throw t("not_found");
+			let d = H(await R(r.receiptSource.purchase(Object.freeze({
+				tenantId: a,
+				ownerId: o,
+				source: u,
+				purchaseId: e.purchaseId
+			}))));
+			if (d.tenantId !== a || d.ownerId !== o || d.purchaseId !== e.purchaseId || d.kind !== u.kind || d.currency !== u.currency || d.settledAt > p) throw t("invalid_record");
+			if (x = d, C = g.decay === "seasonal" ? W(await R(r.seasonSource.read(Object.freeze({
+				tenantId: a,
+				loyaltyId: c,
+				at: d.settledAt
+			}))), d.settledAt) : null, m.some((e) => e.entry.kind === "credit" && e.entry.sourceId === u.id && e.entry.purchaseId === d.purchaseId)) throw t("conflict");
+			T = Object.freeze({
+				id: l,
+				sequence: m.length + 1,
+				kind: "credit",
+				at: p,
+				sourceId: u.id,
+				purchaseId: d.purchaseId,
+				seasonId: C?.id ?? null,
+				purchaseAmount: d.amount,
+				numerator: u.numerator,
+				denominator: u.denominator,
+				delta: s(BigInt(d.amount) * BigInt(u.numerator) / BigInt(u.denominator)).toString()
+			});
+		} else {
+			let e = i, n = m.find((t) => t.entry.id === e.originalId);
+			if (!n || n.kind !== "credit") throw t("not_found");
+			g = n.loyalty, _ = n.currencies, y = n.realMoney, b = n.rulesVersion, C = n.season;
+			let s = H(n.evidence), c = U(await R(r.receiptSource.refund(Object.freeze({
+				tenantId: a,
+				ownerId: o,
+				purchase: s,
+				refundId: e.refundId
+			}))));
+			if (c.tenantId !== a || c.ownerId !== o || c.authorityId !== s.authorityId || c.purchaseId !== s.purchaseId || c.refundId !== e.refundId || c.refundedAt < s.settledAt || c.refundedAt > p) throw t("invalid_record");
+			let u = n.entry, d = h.credits.find((t) => t.id === e.originalId);
+			if (BigInt(c.totalRefunded) <= BigInt(d.refundedAmount) || BigInt(c.totalRefunded) > BigInt(s.amount)) throw t("conflict");
+			let f = (BigInt(s.amount) - BigInt(c.totalRefunded)) * BigInt(u.numerator) / BigInt(u.denominator);
+			x = c, T = Object.freeze({
+				id: l,
+				sequence: m.length + 1,
+				kind: "reverse",
+				at: p,
+				originalId: u.id,
+				refundId: c.refundId,
+				seasonId: u.seasonId,
+				totalRefunded: c.totalRefunded,
+				delta: (f - BigInt(d.remainingPoints)).toString()
+			});
+		}
+		let P = v([...m.map((e) => e.entry), T], g.decay).balances.find((e) => e.seasonId === T.seasonId).points, F = Object.freeze({
+			kind: n,
+			request: i,
+			loyalty: g,
+			currencies: _,
+			realMoney: y,
+			rulesVersion: b,
+			evidence: x,
+			season: C,
+			entry: T,
+			points: P
+		}), I = O(a, c, x.authorityId, x.purchaseId), L = n === "reverse" ? M(a, c, x.authorityId, x.refundId) : null;
+		return e.transactional(async (e) => {
+			await Y(e, a, o);
+			let s = await $(e, a, o, l, n, i);
+			if (s) return s;
+			if ((await Z(e, a, o)).count !== f.count) throw t("conflict");
+			let u = await e.query(j(S).where(k(A("tenantId", a), A("purchaseKey", I))).limit(r.maxHistoryRows + 1).descriptor);
+			if (u.length > r.maxHistoryRows) throw t("limit_exceeded");
+			if (n === "credit" && u.length || n === "reverse" && !u.some((e) => e.id === i.originalId && e.ownerKey === E(a, o) && e.state === "fulfilled") || L && (await e.query(j(S).where(k(A("tenantId", a), A("refundKey", L))).limit(1).descriptor)).length) throw t("conflict");
+			await ne(e, a, F), C && await ee(e, a, c, C, !0), await e.insert(S.tableName, {
+				id: l,
+				tenantId: a,
+				ownerId: o,
+				ownerKey: E(a, o),
+				loyaltyId: c,
+				sequence: f.count + 1,
+				state: "fulfilled",
+				purchaseKey: I,
+				refundKey: L,
+				digest: N([n, i]),
+				body: F,
+				createdAt: new Date(p)
+			}), await e.update(w.tableName, E(a, o), { entriesCount: f.count + 1 });
+			let d = (await Z(e, a, o)).accepted.find((e) => e.entry.id === l);
+			if (!d) throw t("invalid_record");
+			return Q(d);
+		});
+	}), ae = (t) => L(() => {
+		let n = F(t);
+		return I(async () => (await q(e, n.tenantId, n.ownerId), r.loyalty));
+	}), oe = (n, i) => L(() => {
+		let a = F(n), o = m(i);
+		return I(async () => {
+			let n = r.loyalty.find((e) => e.id === o.loyaltyId);
+			if (!n) throw t("not_found");
+			let i = d(), s = await e.transactional((e) => Z(e, a.tenantId, a.ownerId));
+			if (i < (s.accepted.at(-1)?.entry.at ?? 0) || s.programs.get(n.id)?.some((e) => e.loyalty.decay !== n.decay)) throw t("conflict");
+			let c = n.decay === "seasonal" ? W(await R(r.seasonSource.read(Object.freeze({
+				tenantId: a.tenantId,
+				loyaltyId: n.id,
+				at: i
+			}))), i) : null;
+			c && await e.transactional((e) => ee(e, a.tenantId, n.id, c, !1));
+			let l = s.projections.get(n.id)?.balances.find((e) => e.seasonId === (c?.id ?? null))?.points ?? "0", u = Object.freeze({
+				loyalty: n,
+				currencies: r.currencies,
+				realMoney: r.realMoney,
+				points: l,
+				rulesVersion: r.version
+			}), f = b(u, r.tier), p = y({
+				...u,
+				tierId: f.id
+			}, r.perks);
+			if (((await q(e, a.tenantId, a.ownerId))?.entriesCount ?? 0) !== s.count) throw t("conflict");
+			return Object.freeze({
+				loyalty: n,
+				rulesVersion: r.version,
+				seasonId: c?.id ?? null,
+				points: l,
+				tierId: f.id,
+				perks: p
+			});
+		});
+	}), se = (e, t) => L(() => (K(e), ie("credit", p(t)))), ce = (e, t) => L(() => (K(e), ie("reverse", _(t)))), le = (t, n) => L(() => {
+		let r = F(t), i = g(n);
+		return I(() => e.transactional(async (e) => {
+			let t = await $(e, r.tenantId, r.ownerId, D(r.tenantId, r.ownerId, i.requestId));
+			return Object.freeze(t ? {
+				requestId: i.requestId,
+				state: "fulfilled",
+				receipt: t
+			} : {
+				requestId: i.requestId,
+				state: "not-observed"
+			});
+		}));
+	}), ue = (t, n) => L(() => {
+		K(t);
+		let r = h(n);
+		return I(() => e.transactional(async (e) => (await Z(e, r.tenantId, r.ownerId)).projections.get(r.loyaltyId) ?? v([])));
+	}), de = (e) => {
+		let n = i(e, [
+			"tenantId",
+			"subjectId",
+			"kind"
+		]);
+		if (n.kind !== "guest" && n.kind !== "user") throw t("forbidden");
+		return Object.freeze({
+			tenantId: a(n.tenantId),
+			ownerId: a(n.subjectId)
+		});
+	};
+	return Object.freeze({
+		list: ae,
+		mine: oe,
+		credit: se,
+		reverse: ce,
+		receipt: le,
+		rebuild: ue,
+		exportSubject: (t) => L(() => {
+			let n = de(t);
+			return I(() => e.transactional(async (e) => {
+				if ((await q(e, n.tenantId, n.ownerId, !0))?.erased) return Object.freeze({ loyalty: [] });
+				let t = await Z(e, n.tenantId, n.ownerId);
+				return Object.freeze({ loyalty: Object.freeze(t.accepted.map((e) => Object.freeze({
+					receipt: Q(e),
+					definition: e.loyalty,
+					evidence: e.evidence,
+					season: e.season
+				}))) });
+			}));
+		}),
+		eraseSubject: (n) => L(() => {
+			let i = de(n);
+			return I(async () => {
+				await J(i.tenantId, i.ownerId), await e.transactional(async (e) => {
+					await Y(e, i.tenantId, i.ownerId, !0);
+					let n = await q(e, i.tenantId, i.ownerId, !0), a = await e.query(j(S).where(k(A("tenantId", i.tenantId), A("ownerKey", E(i.tenantId, i.ownerId)))).limit(r.maxHistoryRows + 1).descriptor);
+					if (a.length > r.maxHistoryRows) throw t("limit_exceeded");
+					if (a.length !== n?.entriesCount) throw t("invalid_record");
+					a.sort((e, t) => Number(e.sequence) - Number(t.sequence));
+					for (let [n, r] of a.entries()) {
+						if (!/^ele_[a-f0-9]{56}$/.test(String(r.id)) || r.sequence !== n + 1 || r.ownerId !== i.ownerId && r.ownerId !== null || r.state !== "fulfilled" && r.state !== "erased" || !/^[a-f0-9]{64}$/.test(String(r.purchaseKey)) || r.refundKey !== null && !/^[a-f0-9]{64}$/.test(String(r.refundKey))) throw t("invalid_record");
+						await e.update(S.tableName, String(r.id), {
+							ownerId: null,
+							state: "erased",
+							digest: null,
+							body: null
+						});
+					}
+					await e.update(w.tableName, E(i.tenantId, i.ownerId), {
+						ownerId: null,
+						erased: !0
+					});
+				});
+			});
+		})
+	});
+};
+//#endregion
+export { K as dataStoreLoyalty, G as resolveLoyaltyStoreOptions };

package/dist/loyaltyStore.testFixtures.js

@@ -0,0 +1,83 @@
+import { loyaltyTables as e } from "./loyaltyTables.entity.js";
+import { dataStoreLoyalty as t } from "./loyaltyStore.server.js";
+import { shopLoyaltyReceiptSource as n } from "./loyaltyShopSource.server.js";
+import { shopAt as r, shopFixture as i } from "./shop.testFixtures.js";
+import { Effect as a } from "effect";
+import { ensureTableRegistered as o } from "@voltro/database";
+//#region src/loyaltyStore.testFixtures.ts
+var s = async (s, c = "tenant", l = {}) => {
+	e.forEach(o);
+	let u = await i(s, c), d = r, f = {
+		currencies: [{
+			id: "test.gold",
+			kind: "soft"
+		}],
+		loyalty: [{
+			id: "vip",
+			titleKey: "test.vip",
+			decay: "seasonal",
+			pointsFrom: [{
+				id: "virtual.gold",
+				kind: "purchase.virtual",
+				currency: "test.gold",
+				numerator: "3",
+				denominator: "2"
+			}],
+			tiers: [{
+				id: "base",
+				at: "0",
+				perks: []
+			}, {
+				id: "silver",
+				at: "9",
+				perks: [{
+					id: "discount",
+					kind: "discount",
+					bps: 100
+				}]
+			}]
+		}],
+		receiptSource: n(s, {
+			shop: u.shop,
+			refunds: { read: (e) => a.succeed({
+				tenantId: e.tenantId,
+				ownerId: e.ownerId,
+				authorityId: e.purchase.authorityId,
+				purchaseId: e.purchase.purchaseId,
+				refundId: e.refundId,
+				totalRefunded: e.refundId === "partial" ? "2" : e.purchase.amount,
+				refundedAt: d
+			}) }
+		}),
+		seasonSource: { read: (e) => a.succeed(e.at < r + 864e5 ? {
+			id: "old",
+			startsAt: r,
+			endsAt: r + 864e5
+		} : {
+			id: "next",
+			startsAt: r + 864e5,
+			endsAt: r + 1728e5
+		}) },
+		version: "fixture.loyalty.v1",
+		now: () => d,
+		...l
+	};
+	return {
+		base: u,
+		options: f,
+		service: t(s, f),
+		credit: (e, t = "credit") => ({
+			tenantId: c,
+			ownerId: "a",
+			loyaltyId: "vip",
+			sourceId: "virtual.gold",
+			purchaseId: e,
+			requestId: t
+		}),
+		setAt: (e) => {
+			d = e;
+		}
+	};
+};
+//#endregion
+export { s as loyaltyStoreFixture };

package/dist/loyaltyTables.entity.js

@@ -0,0 +1,50 @@
+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";
+//#region src/loyaltyTables.entity.ts
+var s = () => a().maxLength(120).externalId().sensitive("pii"), c = i("_voltro_eco_loyalty_tenants", {
+	id: t({ prefix: "elt" }),
+	tenantId: s(),
+	admission: n().serverOnly()
+}).index(["tenantId"]), l = i("_voltro_eco_loyalty_definitions", {
+	id: t({ prefix: "eld" }),
+	tenantId: s(),
+	loyaltyId: a().maxLength(120).serverOnly(),
+	definition: r().serverOnly(),
+	currencies: r().serverOnly(),
+	realMoney: e().serverOnly(),
+	rulesVersion: a().maxLength(120).serverOnly()
+}).index(["tenantId", "loyaltyId"]), u = i("_voltro_eco_loyalty_subjects", {
+	id: t({ prefix: "els" }),
+	tenantId: s(),
+	ownerId: a().maxLength(120).nullable().externalId().sensitive("pii"),
+	erased: e().serverOnly(),
+	admission: n().serverOnly(),
+	entriesCount: n().serverOnly()
+}).index(["tenantId", "ownerId"]), d = i("_voltro_eco_loyalty_entries", {
+	id: t({ prefix: "ele" }),
+	tenantId: s(),
+	ownerId: a().maxLength(120).nullable().externalId().sensitive("pii"),
+	ownerKey: a().maxLength(64).serverOnly(),
+	loyaltyId: a().maxLength(120).serverOnly(),
+	sequence: n().serverOnly(),
+	state: a().maxLength(16).oneOf(["fulfilled", "erased"]).serverOnly(),
+	purchaseKey: a().maxLength(64).serverOnly(),
+	refundKey: a().maxLength(64).nullable().serverOnly(),
+	digest: a().maxLength(64).nullable().serverOnly(),
+	body: r().nullable().serverOnly(),
+	createdAt: o().serverOnly()
+}).index(["tenantId", "ownerKey"]).index(["tenantId", "purchaseKey"]).index(["tenantId", "refundKey"]), f = i("_voltro_eco_loyalty_seasons", {
+	id: t({ prefix: "elp" }),
+	tenantId: s(),
+	loyaltyId: a().maxLength(120).serverOnly(),
+	seasonId: a().maxLength(120).serverOnly(),
+	startsAt: o().serverOnly(),
+	endsAt: o().serverOnly()
+}).index(["tenantId", "loyaltyId"]), p = [
+	c,
+	l,
+	u,
+	d,
+	f
+];
+//#endregion
+export { l as loyaltyDefinitionsTable, d as loyaltyEntriesTable, f as loyaltySeasonsTable, u as loyaltySubjectsTable, p as loyaltyTables, c as loyaltyTenantsTable };