@voltro/plugin-economy 0.0.0-stage → 0.88.0

package/dist/iapRecovery.js

@@ -0,0 +1,89 @@
+import { economyError as e } from "./errors.js";
+import { captureBoundMethods as t, dataObject as n, identifier as r } from "./capture.js";
+import { captureIapCompletionReceipt as i, captureIapObservation as a, captureIapOrderReceipt as o, createIapReceiptReference as s, iapReceiptIntent as c, iapReceiptReference as l } from "./iap.js";
+import { browserIntentionJournal as u, createIntentionRecovery as d } from "./intentionRecovery.js";
+// src/iapRecovery.ts
+var f = (t) => {
+	let s = n(t, [
+		"requestId",
+		"state",
+		"receipt",
+		"completion",
+		"refund"
+	], "invalid_record");
+	if (s.state !== "completed") return a(t);
+	if (Object.hasOwn(s, "refund")) throw e("invalid_record");
+	return Object.freeze({
+		requestId: r(s.requestId, "invalid_record"),
+		state: "completed",
+		receipt: o(s.receipt),
+		completion: i(s.completion)
+	});
+}, p = (t, n) => {
+	if (t.requestId !== n.requestId) throw e("conflict");
+	if (n.state !== "not-observed" && n.state !== "pending" && "receipt" in n) {
+		if (n.receipt.offerId !== t.offerId || n.receipt.offerVersion !== t.offerVersion) throw e("conflict");
+		if (n.state === "completed") {
+			if (n.completion.orderId !== n.receipt.orderId || n.completion.channel !== t.channel || n.completion.observedAt < n.receipt.at) throw e("conflict");
+			return Object.freeze({
+				receipt: n.receipt,
+				completion: n.completion
+			});
+		}
+	}
+}, m = (n, a, u) => {
+	let m = t(a, ["restore"]), h = t(u, [
+		"read",
+		"redeem",
+		"complete"
+	]), g = 0, _, v = d(n, async (t, n) => {
+		let r = f(await h.read(t));
+		if (n(), p(t, r), r.state === "completed") throw e("invalid_record");
+		let a = c(await m.restore(t));
+		n();
+		let l = await s(a);
+		if (n(), JSON.stringify(t) !== JSON.stringify(l)) throw e("conflict");
+		let u = "receipt" in r ? r.receipt : o(await h.redeem(a));
+		n(), p(t, {
+			requestId: t.requestId,
+			state: "fulfilled",
+			receipt: u
+		});
+		let d = i(await h.complete(a, u));
+		n();
+		let g = p(t, {
+			requestId: t.requestId,
+			state: "completed",
+			receipt: u,
+			completion: d
+		});
+		if (!g) throw e("invalid_record");
+		return g;
+	}, {
+		request: (e) => l(e),
+		observation: f,
+		fulfilled: (e, t) => ({
+			requestId: e.requestId,
+			state: "completed",
+			...t
+		}),
+		resolve: p
+	});
+	return Object.freeze({
+		selectScope: (e) => {
+			let t = e === void 0 ? void 0 : r(e);
+			g++, _ = t, v.selectScope(t);
+		},
+		pending: v.pending,
+		retry: v.retry,
+		observe: v.observe,
+		begin: async (t) => {
+			let n = c(t), r = g, i = _;
+			if (i === void 0) throw e("forbidden");
+			let a = await s(n);
+			if (g !== r || _ !== i) throw e("conflict");
+			return v.begin(a);
+		}
+	});
+}, h = (e, t) => u(e, t, "voltro:iap-purchase:v1:", 2048, (e) => l(e));
+export { h as browserIapPurchaseJournal, m as createIapPurchaseRecovery };

package/dist/iapRefundEventDelivery.server.js

@@ -0,0 +1,82 @@
+import { economyError as e } from "./errors.js";
+import { captureBoundMethods as t, dataObject as n, identifier as r } from "./capture.js";
+import { shopInteger as i } from "./shop.js";
+import { economyRefundReversed as a, economyRefunded as o } from "./iapRefundEvents.js";
+import { Effect as s } from "effect";
+import { systemSubject as c } from "@voltro/protocol";
+import { createHash as l } from "node:crypto";
+import { defineSchedule as u, publishEvent as d } from "@voltro/runtime";
+// src/iapRefundEventDelivery.server.ts
+var f = () => null, p = (u) => {
+	let p = n(u, [
+		"events",
+		"publisher",
+		"version",
+		"maxEvents",
+		"sanctions",
+		"abusePolicy"
+	]), m = t(p.events, [
+		"pending",
+		"read",
+		"acknowledge"
+	]), h = t(p.publisher, ["read"]), g = r(p.version), _ = i(p.maxEvents ?? 1e3, 1, 1e5);
+	if (g === "default.v1" || p.abusePolicy !== void 0 && typeof p.abusePolicy != "function" || p.abusePolicy !== void 0 && p.sanctions === void 0) throw e("invalid_input");
+	let v = p.abusePolicy ?? f, y = p.sanctions === void 0 ? void 0 : t(p.sanctions, ["recordSignal"]), b = c("economy.refund-events");
+	return s.gen(function* () {
+		let t = yield* m.pending(b);
+		if (t.length > _) return yield* s.fail(e("limit_exceeded"));
+		let r = 0, i = 0;
+		for (let c of t) {
+			let t = yield* m.read(b, c), u = t.payload.refundNumerator === 0 ? null : v(structuredClone(t)), f = u === null ? null : n(u, ["confidence"], "invalid_record");
+			if (f && (typeof f.confidence != "number" || !Number.isFinite(f.confidence) || f.confidence < 0 || f.confidence > 1)) return yield* s.fail(e("invalid_record"));
+			if (f && !y) return yield* s.fail(e("unavailable"));
+			if (yield* m.read(b, c), f && y) {
+				let n = "refund_" + l("sha256").update(JSON.stringify([t.namespace, t.payload.orderId])).digest("hex").slice(0, 56);
+				yield* y.recordSignal(b, {
+					tenantId: t.tenantId,
+					targetId: t.subjectId,
+					requestId: n,
+					category: "rmt",
+					confidence: f.confidence
+				}).pipe(s.mapError(() => e("unavailable"))), i++;
+			}
+			let p = yield* m.read(b, c), _ = yield* h.read(p.tenantId);
+			if (_.tenantId !== p.tenantId || _.deferToCommit !== void 0) return yield* s.fail(e("forbidden"));
+			if (yield* m.read(b, c), (yield* d(_, p.payload.refundNumerator === 0 ? a : o, { subjectId: p.subjectId }, p.payload).pipe(s.mapError(() => e("unavailable")))).deferred) return yield* s.fail(e("unavailable"));
+			yield* m.acknowledge(b, c, g), r++;
+		}
+		return Object.freeze({
+			scannedRows: t.length,
+			deliveredEvents: r,
+			classifiedSignals: i
+		});
+	}).pipe(s.catchDefect(() => s.fail(e("unavailable"))));
+}, m = (t) => {
+	let i = n(t, [
+		"events",
+		"publisher",
+		"version",
+		"maxEvents",
+		"sanctions",
+		"abusePolicy",
+		"name",
+		"cron",
+		"timezone"
+	]), a = r(i.name), o = i.cron, c = i.timezone ?? "UTC";
+	if (typeof o != "string" || !o.length || o.length > 120 || typeof c != "string" || !c.length || c.length > 120) throw e("invalid_input");
+	let l = p({
+		events: i.events,
+		publisher: i.publisher,
+		version: i.version,
+		maxEvents: i.maxEvents,
+		sanctions: i.sanctions,
+		abusePolicy: i.abusePolicy
+	});
+	return u({
+		name: a,
+		cron: o,
+		timezone: c,
+		handler: () => l.pipe(s.asVoid)
+	});
+};
+export { p as deliverIapRefundEvents, m as iapRefundEventSchedule, f as noRefundAbuseSignal };

package/dist/iapRefundEvents.js

@@ -0,0 +1,44 @@
+import { economyError as e } from "./errors.js";
+import { Context as t, Effect as n, Schema as r } from "effect";
+import { defineEvent as i } from "@voltro/protocol";
+// src/iapRefundEvents.ts
+var a = r.String.pipe(r.check(r.makeFilter((e) => e.length <= 120 && /^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(e)))), o = r.Struct({
+	eventId: a,
+	orderId: a,
+	sequence: r.Number.pipe(r.check(r.isInt()), r.check(r.isBetween({
+		minimum: 1,
+		maximum: 1e5
+	}))),
+	state: r.Literals([
+		"active",
+		"partially-refunded",
+		"revoked"
+	]),
+	refundNumerator: r.Number.pipe(r.check(r.isInt()), r.check(r.isBetween({
+		minimum: 0,
+		maximum: 1e5
+	}))),
+	refundDenominator: r.Number.pipe(r.check(r.isInt()), r.check(r.isBetween({
+		minimum: 1,
+		maximum: 1e5
+	}))),
+	observedAt: r.Number.pipe(r.check(r.isInt()), r.check(r.isBetween({
+		minimum: 0,
+		maximum: 864e13
+	})))
+}).pipe(r.check(r.makeFilter((e) => e.refundNumerator <= e.refundDenominator && e.state === (e.refundNumerator === 0 ? "active" : e.refundNumerator === e.refundDenominator ? "revoked" : "partially-refunded")))), s = i({
+	name: "economy.refunded",
+	key: r.Struct({ subjectId: a }),
+	payload: o,
+	guards: [{ scope: "economy:events:read" }]
+}), c = i({
+	name: "economy.refundReversed",
+	key: r.Struct({ subjectId: a }),
+	payload: o,
+	guards: [{ scope: "economy:events:read" }]
+}), l = class extends t.Service()("@voltro/IapRefundEventsPort") {}, u = () => n.fail(e("unavailable")), d = Object.freeze({
+	pending: u,
+	read: u,
+	acknowledge: u
+});
+export { o as IapRefundEventPayloadSchema, l as IapRefundEventsPort, c as economyRefundReversed, s as economyRefunded, d as unavailableIapRefundEvents };

package/dist/iapRefundEventsPort.fixture.js

@@ -0,0 +1,59 @@
+import { economyError as e } from "./errors.js";
+import { IapRefundEventsPort as t } from "./iapRefundEvents.js";
+import { iapRefundsFixture as n } from "./iapRefunds.testFixtures.js";
+import { Effect as r, Layer as i } from "effect";
+import { systemSubject as a } from "@voltro/protocol";
+import { InMemoryDataStore as o } from "@voltro/runtime";
+// src/iapRefundEventsPort.fixture.ts
+var s = /* @__PURE__ */ new WeakMap(), c = r.tryPromise({
+	try: () => n(new o(), "fixture.refund.events"),
+	catch: () => e("unavailable")
+}).pipe(r.map((t) => {
+	let n = !1, i = (t) => r.suspend(() => n ? r.fail(e("unavailable")) : t()), a = Object.freeze({
+		pending: (e) => i(() => t.refunds.events.pending(e)),
+		read: (e, n) => i(() => t.refunds.events.read(e, n)),
+		acknowledge: (e, n, r) => i(() => t.refunds.events.acknowledge(e, n, r))
+	});
+	s.set(a, t);
+	let o = r.sync(() => {
+		n = !0;
+	}).pipe(r.flatMap(() => t.f.accounts.eraseSubject(t.privacy)), r.flatMap(() => t.refunds.eraseSubject(t.privacy)));
+	return Object.freeze({
+		service: a,
+		privacy: t.privacy,
+		create: () => r.tryPromise({
+			try: () => t.observeProvider(1),
+			catch: () => e("unavailable")
+		}).pipe(r.flatMap(t.refunds.reconcile)),
+		close: o
+	});
+})), l = i.effect(t, r.acquireRelease(c, (e) => e.close.pipe(r.orDie)).pipe(r.map((e) => e.service))), u = Object.freeze({
+	kind: "port",
+	tag: t,
+	fakeLayer: l,
+	probe: {
+		run: () => r.scoped(r.gen(function* () {
+			let n = yield* t, i = s.get(n), o = a("fixture.refund.events");
+			if (!i) return yield* r.fail(e("unavailable"));
+			let c = yield* r.tryPromise({
+				try: () => i.observeProvider(1),
+				catch: () => e("unavailable")
+			});
+			yield* i.refunds.reconcile(c);
+			let [l] = yield* n.pending(o);
+			if (!l) return yield* r.fail(e("unavailable"));
+			let u = yield* n.read(o, l);
+			return yield* n.acknowledge(o, l, "fixture.delivery.v1"), {
+				state: u.payload.state,
+				originals: u.refundedOrders,
+				pending: (yield* n.pending(o)).length
+			};
+		}).pipe(r.provide(l))),
+		expected: {
+			state: "revoked",
+			originals: 1,
+			pending: 0
+		}
+	}
+});
+export { l as iapRefundEventsFakeLayer, c as iapRefundEventsPortFixture, u as iapRefundEventsPortSystemFixture };

package/dist/iapRefundPort.fixture.js

@@ -0,0 +1,54 @@
+import { economyError as e } from "./errors.js";
+import { IapRefundPort as t } from "./iapRefunds.server.js";
+import { iapRefundsFixture as n } from "./iapRefunds.testFixtures.js";
+import { Effect as r, Layer as i } from "effect";
+import { InMemoryDataStore as a } from "@voltro/runtime";
+// src/iapRefundPort.fixture.ts
+var o = /* @__PURE__ */ new WeakMap(), s = r.tryPromise({
+	try: () => n(new a()),
+	catch: () => e("unavailable")
+}).pipe(r.map((t) => {
+	let n = !1, i = (t) => r.suspend(() => n ? r.fail(e("unavailable")) : t()), a = Object.freeze({
+		reconcile: (e) => i(() => t.refunds.reconcile(e)),
+		rebuild: (e) => i(() => t.refunds.rebuild(e)),
+		observe: (e, n) => i(() => t.refunds.observe(e, n)),
+		exportSubject: (e) => i(() => t.refunds.exportSubject(e)),
+		eraseSubject: (e) => i(() => t.refunds.eraseSubject(e))
+	});
+	return o.set(a, t), Object.freeze({
+		service: a,
+		fixture: t,
+		close: r.sync(() => {
+			n = !0;
+		})
+	});
+})), c = i.effect(t, r.acquireRelease(s, (e) => e.close).pipe(r.map((e) => e.service))), l = Object.freeze({
+	kind: "port",
+	tag: t,
+	fakeLayer: c,
+	probe: {
+		run: () => r.scoped(r.gen(function* () {
+			let n = yield* t, i = o.get(n);
+			if (!i) return yield* r.fail(e("unavailable"));
+			let a = yield* r.tryPromise({
+				try: () => i.observeProvider(1),
+				catch: () => e("unavailable")
+			}), s = yield* n.reconcile(a), c = yield* n.reconcile(a), l = yield* n.rebuild(a), u = yield* i.f.economy.mine(i.f.user()), d = yield* i.f.inventory.mine(i.f.user());
+			return {
+				refunded: s.currencies[0]?.refunded,
+				wallet: u[0]?.balance,
+				stock: d.length,
+				replay: c.sequence === s.sequence,
+				rebuilt: l?.sequence === s.sequence
+			};
+		}).pipe(r.provide(c))),
+		expected: {
+			refunded: "20",
+			wallet: "0",
+			stock: 0,
+			replay: !0,
+			rebuilt: !0
+		}
+	}
+});
+export { c as iapRefundFakeLayer, s as iapRefundPortFixture, l as iapRefundPortSystemFixture };

package/dist/iapRefundTables.entity.js

@@ -0,0 +1,55 @@
+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/iapRefundTables.entity.ts
+var s = () => a().maxLength(120).serverOnly(), c = () => a().maxLength(120).externalId().sensitive("pii"), l = i("_voltro_eco_iap_refund_namespaces", {
+	id: t({ prefix: "ifn" }),
+	namespace: s(),
+	admission: n().serverOnly(),
+	configurationDigest: a().maxLength(64).serverOnly(),
+	rowsCount: n().serverOnly()
+}), u = i("_voltro_eco_iap_refund_subjects", {
+	id: t({ prefix: "ifs" }),
+	namespace: s(),
+	tenantId: c(),
+	ownerId: a().maxLength(120).nullable().externalId().sensitive("pii"),
+	erased: e().serverOnly(),
+	admission: n().serverOnly(),
+	rowsCount: n().serverOnly()
+}).index(["namespace", "tenantId"]), d = i("_voltro_eco_iap_refund_orders", {
+	id: t({ prefix: "ifo" }),
+	namespace: s(),
+	tenantId: c(),
+	ownerKey: a().maxLength(64).serverOnly(),
+	ownerId: a().maxLength(120).nullable().externalId().sensitive("pii"),
+	orderId: a().maxLength(64).serverOnly(),
+	admission: n().serverOnly(),
+	configurationDigest: a().maxLength(64).serverOnly(),
+	receipt: r().nullable().serverOnly(),
+	erased: e().serverOnly(),
+	rowsCount: n().serverOnly()
+}).index("voltro_eco_iap_refund_orders_owner_idx", [
+	"namespace",
+	"tenantId",
+	"ownerKey"
+]), f = i("_voltro_eco_iap_refund_adjustments", {
+	id: t({ prefix: "ifa" }),
+	namespace: s(),
+	tenantId: c(),
+	ownerKey: a().maxLength(64).serverOnly(),
+	ownerId: a().maxLength(120).nullable().externalId().sensitive("pii"),
+	orderId: a().maxLength(64).serverOnly(),
+	sequence: n().serverOnly(),
+	receipt: r().nullable().serverOnly(),
+	at: o().serverOnly(),
+	eventState: a().maxLength(16).serverOnly(),
+	eventDeliveryVersion: a().maxLength(120).nullable().serverOnly()
+}).index(["namespace"]).index("voltro_eco_iap_refund_adjustments_owner_idx", [
+	"namespace",
+	"tenantId",
+	"ownerKey"
+]).index(["namespace", "orderId"]), p = [
+	l,
+	u,
+	d,
+	f
+];
+export { f as iapRefundAdjustmentsTable, l as iapRefundNamespacesTable, d as iapRefundOrdersTable, u as iapRefundSubjectsTable, p as iapRefundTables };