@voltro/plugin-economy 0.0.0-stage → 0.88.0

package/dist/iapRefunds.js

@@ -0,0 +1,6 @@
+import { IapRefundEventPayloadSchema as e, IapRefundEventsPort as t, economyRefundReversed as n, economyRefunded as r } from "./iapRefundEvents.js";
+import { iapRefundAdjustmentsTable as i, iapRefundNamespacesTable as a, iapRefundOrdersTable as o, iapRefundSubjectsTable as s, iapRefundTables as c } from "./iapRefundTables.entity.js";
+import { IapRefundPort as l, captureIapRefundService as u, dataStoreIapRefunds as d } from "./iapRefunds.server.js";
+import { inventoryIapRefundAssets as f } from "./iapInventoryRefunds.server.js";
+import { deliverIapRefundEvents as p, iapRefundEventSchedule as m, noRefundAbuseSignal as h } from "./iapRefundEventDelivery.server.js";
+export { e as IapRefundEventPayloadSchema, t as IapRefundEventsPort, l as IapRefundPort, u as captureIapRefundService, d as dataStoreIapRefunds, p as deliverIapRefundEvents, n as economyRefundReversed, r as economyRefunded, i as iapRefundAdjustmentsTable, m as iapRefundEventSchedule, a as iapRefundNamespacesTable, o as iapRefundOrdersTable, s as iapRefundSubjectsTable, c as iapRefundTables, f as inventoryIapRefundAssets, h as noRefundAbuseSignal };

package/dist/iapRefunds.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 { economyAmountString as o, nonNegativeAmount as s } from "./amount.js";
+import { shopInteger as c } from "./shop.js";
+import { captureIapRefundDisposition as l, iapTimestamp as u } from "./iap.js";
+import { IapRefundEventPayloadSchema as d } from "./iapRefundEvents.js";
+import { canonicalDataJson as f } from "./canonicalDataJson.js";
+import { readVerifiedIapCurrentState as p } from "./iapCurrentState.server.js";
+import { readEconomyTransferEvidence as m } from "./walletStore.js";
+import { iapRefundAdjustmentsTable as h, iapRefundNamespacesTable as g, iapRefundOrdersTable as _, iapRefundSubjectsTable as v } from "./iapRefundTables.entity.js";
+import { Context as y, Effect as b, Result as x, Schema as S } from "effect";
+import { systemSubject as C } from "@voltro/protocol";
+import { createHash as w } from "node:crypto";
+import { and as T, eq as E, queryFor as D } from "@voltro/database";
+import { executeSqlMutations as O, prepareSqlMutation as k, prepareSqlMutationGroup as A } from "@voltro/database/sql";
+// src/iapRefunds.server.ts
+var j = class extends y.Service()("@voltro/IapRefundPort") {}, M = (e) => n(e, [
+	"reconcile",
+	"rebuild",
+	"observe",
+	"exportSubject",
+	"eraseSubject"
+]), N = (e) => w("sha256").update(f(e)).digest("hex"), P = (e, t) => e + N(t).slice(0, 56), F = (n) => n instanceof e ? n : t("unavailable"), I = (e) => b.tryPromise({
+	try: e,
+	catch: F
+}), L = async (e) => {
+	let t = await b.runPromise(e.pipe(b.result));
+	if (x.isFailure(t)) throw t.failure;
+	return t.success;
+}, R = (e) => {
+	let t = i(e, ["tenantId", "ownerId"]);
+	return Object.freeze({
+		tenantId: a(t.tenantId),
+		ownerId: a(t.ownerId)
+	});
+}, ee = /* @__PURE__ */ new WeakMap(), z = (e) => {
+	let n = typeof e == "object" && e ? ee.get(e) : void 0;
+	if (!n) throw t("forbidden");
+	return n;
+}, B = (e, t) => Object.freeze(e.receipt.transfers.map((e) => Object.freeze({
+	currency: e.currency,
+	original: e.amount,
+	refunded: (BigInt(e.amount) * BigInt(t.refundNumerator) / BigInt(t.refundDenominator)).toString()
+}))), V = (e) => {
+	let n = i(e, [
+		"orderId",
+		"sequence",
+		"state",
+		"refundNumerator",
+		"refundDenominator",
+		"observedAt",
+		"noticeId",
+		"fingerprint",
+		"debtPolicy",
+		"currencies",
+		"transfers",
+		"assets"
+	], "invalid_record"), o = c(n.refundDenominator, 1, 1e5), l = c(n.refundNumerator, 0, o);
+	if (n.state !== (l === 0 ? "active" : l === o ? "revoked" : "partially-refunded") || n.debtPolicy !== "allowNegative" && n.debtPolicy !== "blockSpend" || typeof n.fingerprint != "string" || !/^[a-f0-9]{64}$/.test(n.fingerprint) || typeof n.noticeId != "string" || !n.noticeId.length || n.noticeId.length > 128) throw t("invalid_record");
+	let d = Object.freeze(r(n.currencies, 16, "invalid_record").map((e) => {
+		let n = i(e, [
+			"currency",
+			"original",
+			"refunded"
+		], "invalid_record"), r = s(n.original).toString(), c = s(n.refunded).toString();
+		if (r === "0" || c !== (BigInt(r) * BigInt(l) / BigInt(o)).toString()) throw t("invalid_record");
+		return Object.freeze({
+			currency: a(n.currency),
+			original: r,
+			refunded: c
+		});
+	})), f = Object.freeze(r(n.transfers, 16, "invalid_record").map((e) => {
+		let n = i(e, [
+			"txId",
+			"currency",
+			"amount",
+			"at"
+		], "invalid_record"), r = s(n.amount).toString();
+		if (r === "0") throw t("invalid_record");
+		return Object.freeze({
+			txId: a(n.txId),
+			currency: a(n.currency),
+			amount: r,
+			at: u(n.at)
+		});
+	}));
+	if (new Set(d.map((e) => e.currency)).size !== d.length || new Set(f.map((e) => e.txId)).size !== f.length) throw t("invalid_record");
+	return Object.freeze({
+		orderId: a(n.orderId),
+		sequence: c(n.sequence, 1, 1e5),
+		state: n.state,
+		refundNumerator: l,
+		refundDenominator: o,
+		observedAt: u(n.observedAt),
+		noticeId: n.noticeId,
+		fingerprint: n.fingerprint,
+		debtPolicy: n.debtPolicy,
+		currencies: d,
+		transfers: f,
+		assets: structuredClone(n.assets)
+	});
+}, H = (e, r) => {
+	let s = i(r, [
+		"realMoney",
+		"namespace",
+		"debtPolicy",
+		"orders",
+		"economy",
+		"assets",
+		"assetsVersion",
+		"maxHistoryRows"
+	]);
+	if (s.realMoney !== !0) throw t(s.realMoney === !1 ? "real_money_disabled" : "invalid_input");
+	if (s.debtPolicy !== "allowNegative" && s.debtPolicy !== "blockSpend") throw t("invalid_input");
+	let y = a(s.namespace), x = s.debtPolicy, w = c(s.maxHistoryRows ?? 1e4, 1, 1e5), j = n(s.orders, ["prepareCurrentState"]), M = n(s.economy, ["prepareTransfer", "prepareIapRefund"]), z = s.assets === void 0 ? void 0 : n(s.assets, [
+		"prepare",
+		"validate",
+		"audit"
+	]), H = z ? a(s.assetsVersion) : null;
+	if (!z && s.assetsVersion !== void 0) throw t("invalid_input");
+	let U = N([x, H]), W = P("ifn_", y), te = C("economy.iap-refunds"), G = (e) => P("ifs_", [
+		y,
+		e.tenantId,
+		e.ownerId
+	]), K = (e, t) => P("ifo_", t), q = async (t) => {
+		let n = [[g, {
+			id: W,
+			namespace: y,
+			admission: 0,
+			configurationDigest: U,
+			rowsCount: 0
+		}], [v, {
+			id: G(t),
+			namespace: y,
+			tenantId: t.tenantId,
+			ownerId: t.ownerId,
+			erased: !1,
+			admission: 0,
+			rowsCount: 0
+		}]];
+		for (let [t, r] of n) try {
+			await e.insertIgnore(t.tableName, r, { conflictColumns: ["id"] });
+		} catch (n) {
+			if (!(await e.query(D(t).where(E("id", r.id)).limit(1).descriptor))[0]) throw n;
+		}
+	}, ne = async (e, n, r = !1, i = !1) => {
+		let o = (await e.query(D(g).where(E("id", W)).limit(1).descriptor))[0], s = (await e.query(D(v).where(E("id", G(n))).limit(1).descriptor))[0], l = await e.query(D(h).where(E("namespace", y)).limit(w + 1).descriptor);
+		if (l.length > w) throw t("limit_exceeded");
+		if (i && !s) {
+			if ((o ? o.namespace !== y || o.admission !== 0 || o.configurationDigest !== U || l.length !== c(o.rowsCount, 0, w) : l.length !== 0) || l.some((e) => e.tenantId === n.tenantId && e.ownerKey === G(n))) throw t("invalid_record");
+		} else {
+			if (!o || !s || o.namespace !== y || s.namespace !== y || s.tenantId !== n.tenantId || o.admission !== 0 || s.admission !== 0 || !r && o.configurationDigest !== U) throw t("conflict");
+			if (c(o.rowsCount, 0, w), c(s.rowsCount, 0, w), s.erased === !0) {
+				if (!r || s.ownerId !== null) throw t("erased");
+			} else if (s.erased !== !1 || s.ownerId !== n.ownerId) throw t("invalid_record");
+			if (l.length !== o.rowsCount || l.filter((e) => e.tenantId === n.tenantId && e.ownerKey === G(n)).length !== s.rowsCount) throw t("invalid_record");
+			for (let e of l) if (c(e.sequence, 1, w), e.namespace !== y || typeof e.ownerKey != "string" || !/^ifs_[a-f0-9]{56}$/.test(e.ownerKey) || e.id !== P("ifa_", [K({
+				tenantId: a(e.tenantId),
+				ownerId: e.ownerId === null ? n.ownerId : a(e.ownerId)
+			}, a(e.orderId)), String(e.sequence)]) && e.ownerId !== null) throw t("invalid_record");
+			return {
+				header: o,
+				person: s
+			};
+		}
+	}, J = async (e, n, r = !1) => {
+		if (await e.updateMany(g.tableName, { admission: 0 }, { where: E("id", W) }) !== 1 || await e.updateMany(v.tableName, { admission: 0 }, { where: E("id", G(n)) }) !== 1) throw t("unavailable");
+		let i = await ne(e, n, r);
+		if (!i) throw t("invalid_record");
+		return i;
+	}, Y = async (e, n, r, i, a = !1) => {
+		let s = K(n, r), c = (await e.query(D(_).where(E("id", s)).limit(1).descriptor))[0];
+		if (!c) return {
+			row: void 0,
+			receipts: [],
+			latest: null
+		};
+		if (c.namespace !== y || c.tenantId !== n.tenantId || c.ownerKey !== G(n) || c.orderId !== r || c.ownerId !== n.ownerId || c.erased !== !1 && c.erased !== 0 || c.admission !== 0 || typeof c.configurationDigest != "string") throw t(c.erased === !0 || c.erased === 1 ? "erased" : "invalid_record");
+		let l = await e.query(D(h).where(T(E("namespace", y), E("orderId", r))).orderBy("sequence", "asc").limit(w + 1).descriptor);
+		if (l.length > w) throw t("limit_exceeded");
+		if (l.length !== c.rowsCount) throw t("invalid_record");
+		let d = null, p = [];
+		for (let a of l) {
+			let c;
+			try {
+				c = V(a.receipt);
+			} catch {
+				throw t("invalid_record");
+			}
+			if (a.id !== P("ifa_", [s, String(c.sequence)]) || a.tenantId !== n.tenantId || a.ownerKey !== G(n) || a.ownerId !== n.ownerId || a.orderId !== r || a.sequence !== p.length + 1 || c.sequence !== a.sequence || c.orderId !== r || c.observedAt < (d?.observedAt ?? 0) || c.debtPolicy !== x || u(a.at instanceof Date ? a.at.getTime() : Date.parse(String(a.at))) !== c.observedAt || d && f(c.currencies.map((e) => [e.currency, e.original])) !== f(d.currencies.map((e) => [e.currency, e.original])) || i && f(c.currencies) !== f(B(i, c))) throw t("invalid_record");
+			let l = c.currencies.map((e) => ({
+				...e,
+				delta: BigInt(e.refunded) - BigInt(d?.currencies.find((t) => t.currency === e.currency)?.refunded ?? "0")
+			})).filter((e) => e.delta !== 0n);
+			if (l.length !== c.transfers.length) throw t("invalid_record");
+			for (let [a, s] of l.entries()) {
+				let l = c.transfers[a], u = (s.delta < 0n ? -s.delta : s.delta).toString();
+				if (l.currency !== s.currency || l.amount !== u) throw t("invalid_record");
+				let d = (await m(e, n.tenantId, [l.txId], s.currency)).get(l.txId), p = d.pair.find((e) => BigInt(String(e.debit)) > 0n), h = d.pair.find((e) => BigInt(String(e.credit)) > 0n), g = s.delta > 0n ? p : h, _ = s.delta > 0n ? h : p;
+				if (i) {
+					let r = i.receipt.transfers.find((e) => e.currency === s.currency), a = (await m(e, n.tenantId, [r.txId], s.currency)).get(r.txId).pair.find((e) => BigInt(String(e.debit)) > 0n);
+					if (_.systemAccount !== a.systemAccount) throw t("invalid_record");
+				}
+				if (f(d.receipt.receipt) !== f(l) || d.receipt.state !== "committed" || d.receipt.id !== l.txId || g.ownerId !== n.ownerId || g.ownerKind !== "player" || g.accountKind !== "wallet" || _.accountKind !== "system" || p.reason !== (s.delta > 0n ? "iap.refund" : "iap.refund-reversed") || p.refKind !== "iap-order" || p.refId !== r || o(s.delta > 0n ? p.debit : h.credit) !== u) throw t("invalid_record");
+			}
+			if (i && i.receipt.grants.length) {
+				if (!z) throw t("unavailable");
+				let n = {
+					original: i,
+					state: {
+						orderId: r,
+						channel: i.facts.channel,
+						state: c.state,
+						refundNumerator: c.refundNumerator,
+						refundDenominator: c.refundDenominator,
+						observedAt: c.observedAt,
+						revokedAt: null
+					},
+					previous: d,
+					sequence: c.sequence
+				};
+				z.validate(n, c.assets), await z.audit(e, n, c.assets);
+			} else if (i && c.assets !== null) throw t("invalid_record");
+			p.push(c), d = c;
+		}
+		if (!a && f(c.receipt) !== f(d)) throw t("invalid_record");
+		return {
+			row: c,
+			receipts: Object.freeze(p),
+			latest: d
+		};
+	}, re = async (e, n) => {
+		let r = R(n.scope), i = a(n.orderId);
+		if (n.receipt.orderId !== i) throw t("invalid_record");
+		let o = await ne(e, r, !1, !0), s = await Y(e, r, i, n);
+		if (!o && s.row) throw t("invalid_record");
+		let c = s.latest;
+		if (!c) {
+			if (s.row) throw t("invalid_record");
+			return null;
+		}
+		if (c.observedAt < n.receipt.at) throw t("invalid_record");
+		return l({
+			sequence: c.sequence,
+			state: c.state,
+			refundNumerator: c.refundNumerator,
+			refundDenominator: c.refundDenominator,
+			observedAt: c.observedAt
+		});
+	}, X = (n, r, i) => {
+		let a = Object.freeze(structuredClone(n)), o = f(n), s = R(i.scope);
+		return ee.set(a, Object.freeze({
+			scope: s,
+			orderId: n.orderId,
+			noticeId: n.noticeId,
+			fingerprint: n.fingerprint,
+			prepare: () => j.prepareCurrentState(r).pipe(b.map((r) => {
+				let a = k(e, async (e) => {
+					await J(e, s);
+					let r = (await Y(e, s, i.orderId, i)).receipts.find((e) => e.sequence === n.sequence);
+					if (!r || f(r) !== o) throw t("conflict");
+					return null;
+				});
+				return A(e, [r, a], async () => null);
+			}))
+		})), a;
+	}, ie = (n) => p(n).pipe(b.flatMap((r) => I(async () => {
+		let { original: i, state: o, assertFresh: s } = r, c = R(i.scope);
+		if (i.receipt.grants.length && !z) throw t("unavailable");
+		let l = await L(j.prepareCurrentState(n));
+		await q(c);
+		let u = (await e.transactional(async (e) => (await J(e, c), Y(e, c, i.orderId, i)))).latest;
+		if (u && o.observedAt < u.observedAt) return X(u, n, i);
+		let d = B(i, o);
+		if (u && o.observedAt === u.observedAt && o.refundNumerator * u.refundDenominator !== u.refundNumerator * o.refundDenominator) throw t("conflict");
+		if (u && f(d) === f(u.currencies) && o.state === u.state && o.observedAt === u.observedAt) return X(u, n, i);
+		let p = (u?.sequence ?? 0) + 1, b = K(c, i.orderId), S = N([
+			i.receipt,
+			i.product,
+			i.currencies,
+			U
+		]), C = Object.freeze({
+			original: i,
+			state: o,
+			previous: u,
+			sequence: p
+		}), T = [l, k(e, async (e) => {
+			s();
+			let { header: n, person: r } = await J(e, c), a = await Y(e, c, i.orderId, i);
+			if (f(a.latest) !== f(u)) throw t("conflict");
+			if (Number(n.rowsCount) >= w || Number(r.rowsCount) >= w || p > w) throw t("limit_exceeded");
+			if (!a.row) await e.insert(_.tableName, {
+				id: b,
+				namespace: y,
+				tenantId: c.tenantId,
+				ownerKey: G(c),
+				ownerId: c.ownerId,
+				orderId: i.orderId,
+				admission: 0,
+				configurationDigest: S,
+				receipt: null,
+				erased: !1,
+				rowsCount: 0
+			});
+			else if (a.row.configurationDigest !== S) throw t("conflict");
+			return null;
+		})], E = d.map((e) => ({
+			...e,
+			delta: BigInt(e.refunded) - BigInt(u?.currencies.find((t) => t.currency === e.currency)?.refunded ?? "0")
+		})).filter((e) => e.delta !== 0n);
+		for (let t of E) {
+			let r = P("ifr_", [
+				b,
+				String(p),
+				t.currency
+			]), o = (t.delta < 0n ? -t.delta : t.delta).toString();
+			if (t.delta > 0n) T.push(await L(M.prepareIapRefund(te, n, {
+				requestId: r,
+				currency: t.currency,
+				amount: o,
+				debtPolicy: x
+			})));
+			else {
+				let n = i.receipt.transfers.find((e) => e.currency === t.currency), s = (await e.transactional(async (e) => (await m(e, c.tenantId, [n.txId], t.currency)).get(n.txId))).pair.find((e) => BigInt(String(e.debit)) > 0n);
+				T.push(await L(M.prepareTransfer(te, {
+					tenantId: c.tenantId,
+					requestId: r,
+					currency: t.currency,
+					amount: o,
+					from: {
+						kind: "system",
+						id: a(s.systemAccount)
+					},
+					to: {
+						kind: "wallet",
+						ownerKind: "player",
+						ownerId: c.ownerId
+					},
+					reason: "iap.refund-reversed",
+					ref: {
+						kind: "iap-order",
+						id: i.orderId
+					}
+				})));
+			}
+		}
+		i.receipt.grants.length && T.push(await L(z.prepare(C)));
+		let D = A(e, T, async (e, t) => {
+			s();
+			let n = t.slice(2, 2 + E.length), r = i.receipt.grants.length ? z.validate(C, t[t.length - 1]) : null, a = V({
+				orderId: i.orderId,
+				sequence: p,
+				state: o.state,
+				refundNumerator: o.refundNumerator,
+				refundDenominator: o.refundDenominator,
+				observedAt: o.observedAt,
+				noticeId: i.notice.noticeId,
+				fingerprint: i.fingerprint,
+				debtPolicy: x,
+				currencies: d,
+				transfers: n,
+				assets: r
+			}), { header: l, person: u } = await J(e, c);
+			await e.insert(h.tableName, {
+				id: P("ifa_", [b, String(p)]),
+				namespace: y,
+				tenantId: c.tenantId,
+				ownerKey: G(c),
+				ownerId: c.ownerId,
+				orderId: i.orderId,
+				sequence: p,
+				receipt: a,
+				at: new Date(o.observedAt),
+				eventState: "pending",
+				eventDeliveryVersion: null
+			}), await e.update(_.tableName, b, {
+				receipt: a,
+				rowsCount: p
+			}), await e.update(g.tableName, W, { rowsCount: Number(l.rowsCount) + 1 }), await e.update(v.tableName, G(c), { rowsCount: Number(u.rowsCount) + 1 });
+			let f = await Y(e, c, i.orderId, i);
+			return s(), f.latest;
+		});
+		return X((await O(e, [D]))[0], n, i);
+	})), b.catchDefect(() => b.fail(t("unavailable")))), ae = (n) => p(n).pipe(b.flatMap((t) => j.prepareCurrentState(n).pipe(b.flatMap((n) => I(async () => {
+		let r = R(t.original.scope), i = k(e, async (e) => {
+			if (t.assertFresh(), !(await e.query(D(v).where(E("id", G(r))).limit(1).descriptor))[0]) return null;
+			await J(e, r);
+			let n = await Y(e, r, t.original.orderId, t.original, !0);
+			return n.row && await e.update(_.tableName, String(n.row.id), { receipt: n.latest }), t.assertFresh(), n.latest;
+		});
+		return (await O(e, [n, i]))[1];
+	})))), b.catchDefect(() => b.fail(t("unavailable")))), oe = (t, n) => b.try({
+		try: () => ({
+			scope: R(t),
+			orderId: a(n)
+		}),
+		catch: F
+	}).pipe(b.flatMap(({ scope: t, orderId: n }) => I(() => e.transactional(async (e) => (await e.query(D(v).where(E("id", G(t))).limit(1).descriptor))[0] ? (await J(e, t), (await Y(e, t, n)).latest) : null)))), se = (e) => {
+		let n = i(e, [
+			"tenantId",
+			"subjectId",
+			"kind"
+		]);
+		if (n.kind !== "user" && n.kind !== "guest") throw t("invalid_input");
+		return R({
+			tenantId: n.tenantId,
+			ownerId: n.subjectId
+		});
+	}, ce = (n) => b.try({
+		try: () => se(n),
+		catch: F
+	}).pipe(b.flatMap((n) => I(async () => (await q(n), e.transactional(async (e) => {
+		let { person: r } = await J(e, n, !0);
+		if (r.erased) return { refunds: [] };
+		let i = await e.query(D(h).where(T(E("namespace", y), E("tenantId", n.tenantId), E("ownerKey", G(n)))).limit(w + 1).descriptor);
+		if (i.length > w || i.length !== r.rowsCount) throw t("invalid_record");
+		return { refunds: i.map((e) => V(e.receipt)) };
+	}))))), le = (n) => b.try({
+		try: () => se(n),
+		catch: F
+	}).pipe(b.flatMap((n) => I(async () => {
+		await q(n), await e.transactional(async (e) => {
+			let { person: r } = await J(e, n, !0), i = await e.query(D(h).where(T(E("namespace", y), E("tenantId", n.tenantId), E("ownerKey", G(n)))).limit(w + 1).descriptor);
+			if (i.length > w || i.length !== r.rowsCount) throw t("invalid_record");
+			let a = await e.query(D(_).where(T(E("namespace", y), E("tenantId", n.tenantId), E("ownerKey", G(n)))).limit(w + 1).descriptor);
+			if (a.length > w) throw t("limit_exceeded");
+			for (let t of i) await e.update(h.tableName, String(t.id), {
+				ownerId: null,
+				receipt: null,
+				eventState: "erased",
+				eventDeliveryVersion: null
+			});
+			for (let t of a) await e.update(_.tableName, String(t.id), {
+				ownerId: null,
+				receipt: null,
+				erased: !0
+			});
+			await e.update(v.tableName, G(n), {
+				ownerId: null,
+				erased: !0
+			});
+		});
+	}))), Z = (e) => {
+		let n = structuredClone(e);
+		if (n.type !== "system" && !(n.type === "serviceAccount" && n.scopes?.includes("economy:events:write"))) throw t("forbidden");
+		return n;
+	}, Q = (e) => {
+		if (e.eventState !== "pending" && e.eventState !== "delivered" && e.eventState !== "erased" || (e.eventState === "delivered" ? typeof e.eventDeliveryVersion != "string" || a(e.eventDeliveryVersion) === "default.v1" : e.eventDeliveryVersion !== null) || (e.eventState === "erased" ? e.ownerId !== null || e.receipt !== null : e.ownerId === null || e.receipt === null)) throw t("invalid_record");
+	}, ue = /* @__PURE__ */ new WeakMap(), $ = async (e, n, r, i = !1) => {
+		if (r.type === "serviceAccount" && r.tenantId !== n.scope.tenantId) throw t("forbidden");
+		let { person: o } = await J(e, n.scope), s = (await e.query(D(h).where(E("id", n.id)).limit(1).descriptor))[0];
+		if (!s) throw t("not_found");
+		if (Q(s), s.eventState === "erased") throw t("erased");
+		if (s.eventState !== "pending" && !i || s.namespace !== y || s.tenantId !== n.scope.tenantId || s.ownerId !== n.scope.ownerId || s.ownerKey !== G(n.scope) || f(s.receipt) !== n.canonical) throw t("conflict");
+		let c = await e.query(D(h).where(T(E("namespace", y), E("tenantId", n.scope.tenantId), E("ownerKey", G(n.scope)))).limit(w + 1).descriptor);
+		if (c.length > w || c.length !== o.rowsCount) throw t("invalid_record");
+		let l = /* @__PURE__ */ new Map();
+		for (let r of c) {
+			if (Q(r), r.ownerId !== n.scope.ownerId) throw t("invalid_record");
+			let i = a(r.orderId);
+			l.has(i) || l.set(i, (await Y(e, n.scope, i)).receipts);
+		}
+		let u = V(s.receipt), p = l.get(u.orderId)?.find((e) => e.sequence === u.sequence);
+		if (!p || f(p) !== n.canonical) throw t("invalid_record");
+		let m = S.decodeUnknownSync(d, { onExcessProperty: "error" })({
+			eventId: n.id,
+			orderId: u.orderId,
+			sequence: u.sequence,
+			state: u.state,
+			refundNumerator: u.refundNumerator,
+			refundDenominator: u.refundDenominator,
+			observedAt: u.observedAt
+		});
+		return Object.freeze({
+			namespace: y,
+			tenantId: n.scope.tenantId,
+			subjectId: n.scope.ownerId,
+			payload: Object.freeze(m),
+			observedOrders: l.size,
+			refundedOrders: [...l.values()].filter((e) => e.at(-1).refundNumerator > 0).length,
+			refundAdjustments: [...l.values()].reduce((e, t) => e + t.filter((e) => e.refundNumerator > 0).length, 0)
+		});
+	}, de = (e) => {
+		let n = typeof e == "object" && e ? ue.get(e) : void 0;
+		if (!n) throw t("forbidden");
+		return n;
+	}, fe = Object.freeze({
+		pending: (n) => b.try({
+			try: () => Z(n),
+			catch: F
+		}).pipe(b.flatMap((n) => I(() => e.transactional(async (e) => {
+			let r = (await e.query(D(g).where(E("id", W)).limit(1).descriptor))[0];
+			if (!r) return [];
+			if (r.namespace !== y || r.configurationDigest !== U || r.admission !== 0) throw t("conflict");
+			let i = await e.query(D(h).where(E("namespace", y)).limit(w + 1).descriptor);
+			if (i.length > w || i.length !== r.rowsCount) throw t("invalid_record");
+			let o = [];
+			for (let t of i) {
+				if (Q(t), t.eventState !== "pending" || n.type === "serviceAccount" && t.tenantId !== n.tenantId) continue;
+				let r = {
+					id: a(t.id),
+					scope: R({
+						tenantId: a(t.tenantId),
+						ownerId: a(t.ownerId)
+					}),
+					canonical: f(t.receipt)
+				};
+				await $(e, r, n);
+				let i = Object.freeze({ eventId: r.id });
+				ue.set(i, r), o.push(i);
+			}
+			return Object.freeze(o.sort((e, t) => e.eventId.localeCompare(t.eventId)));
+		})))),
+		read: (t, n) => b.try({
+			try: () => ({
+				who: Z(t),
+				value: de(n)
+			}),
+			catch: F
+		}).pipe(b.flatMap(({ who: t, value: n }) => I(() => e.transactional((e) => $(e, n, t))))),
+		acknowledge: (n, r, i) => b.try({
+			try: () => {
+				let e = a(i);
+				if (e === "default.v1") throw t("invalid_input");
+				return {
+					who: Z(n),
+					value: de(r),
+					version: e
+				};
+			},
+			catch: F
+		}).pipe(b.flatMap(({ who: n, value: r, version: i }) => I(() => e.transactional(async (e) => {
+			await $(e, r, n, !0);
+			let a = (await e.query(D(h).where(E("id", r.id)).limit(1).descriptor))[0];
+			if (a.eventState === "delivered") {
+				if (a.eventDeliveryVersion !== i) throw t("conflict");
+			} else await e.update(h.tableName, r.id, {
+				eventState: "delivered",
+				eventDeliveryVersion: i
+			});
+		}))))
+	});
+	return Object.freeze({
+		reconcile: ie,
+		rebuild: ae,
+		observe: oe,
+		exportSubject: ce,
+		eraseSubject: le,
+		events: fe,
+		readDisposition: re
+	});
+};
+export { j as IapRefundPort, M as captureIapRefundService, H as dataStoreIapRefunds, z as readAcceptedIapRefund };

package/dist/iapRefunds.testFixtures.js

@@ -0,0 +1,64 @@
+import { iapCurrentStatePort as e } from "./iapCurrentState.server.js";
+import { iapRefundTables as t } from "./iapRefundTables.entity.js";
+import { dataStoreIapRefunds as n } from "./iapRefunds.server.js";
+import { iapStoreFixture as r } from "./iapStore.testFixtures.js";
+import { iapSqlNoticeFixture as i } from "./iapNotificationTarget.testFixtures.js";
+import { inventoryIapRefundAssets as a } from "./iapInventoryRefunds.server.js";
+import { Effect as o } from "effect";
+import { ensureTableRegistered as s } from "@voltro/database";
+// src/iapRefunds.testFixtures.ts
+var c = async (c, l = "test.tenant", u = {}) => {
+	t.forEach(s);
+	let d = await r(c, l), f = await o.runPromise(d.iap.redeem(d.user(), d.intent)), p = i(d), m = await o.runPromise(d.iap.prepareNotification(p.options, p.evidence)), h = d.at, g = a(c, {
+		inventory: d.inventory,
+		disposition: "requireAll"
+	}), _ = {
+		realMoney: !0,
+		namespace: l,
+		debtPolicy: "blockSpend",
+		orders: d.iap,
+		economy: d.economy,
+		assets: g,
+		assetsVersion: "fixture.1",
+		...u
+	};
+	return {
+		store: c,
+		f: d,
+		n: p,
+		original: f,
+		target: m,
+		options: _,
+		assets: g,
+		refunds: n(c, _),
+		observeProvider: async (t, n = 1) => {
+			h++;
+			let r = e({
+				...p.options,
+				accounts: d.accounts,
+				now: () => h
+			}, {
+				initialize: () => o.void,
+				read: (e) => o.succeed({
+					orderId: e.orderId,
+					channel: "ios",
+					state: t === 0 ? "active" : t === n ? "revoked" : "partially-refunded",
+					refundNumerator: t,
+					refundDenominator: n,
+					observedAt: e.at,
+					revokedAt: null
+				})
+			});
+			return o.runPromise(r.read(m));
+		},
+		advance: (e) => {
+			h += e;
+		},
+		privacy: {
+			tenantId: l,
+			subjectId: d.scope.ownerId,
+			kind: "guest"
+		}
+	};
+};
+export { c as iapRefundsFixture };