@voltro/plugin-economy 0.0.0-stage → 0.88.0

package/dist/iapStore.testFixtures.js

@@ -0,0 +1,127 @@
+import { economyError as e } from "./errors.js";
+import { economyTables as t } from "./tables.entity.js";
+import { dataStoreEconomy as n } from "./walletStore.js";
+import { iapAccountTables as r } from "./iapAccountTables.entity.js";
+import { dataStoreIapAccounts as i } from "./iapAccounts.server.js";
+import { iapVerificationPort as a } from "./iapVerification.server.js";
+import { iapTables as o } from "./iapTables.entity.js";
+import { dataStoreIap as s } from "./iapStore.server.js";
+import { iapTestFixture as c } from "./iap.testFixtures.js";
+import { Effect as l } from "effect";
+import { systemSubject as u } from "@voltro/protocol";
+import { randomBytes as d, randomUUID as f } from "node:crypto";
+import { boolean as p, ensureTableRegistered as m, eq as h, id as g, integer as _, queryFor as v, table as y, text as b } from "@voltro/database";
+import { prepareSqlMutation as x } from "@voltro/database/sql";
+import { dataStoreCatalog as S, dataStoreInventory as C, inventoryTables as w } from "@voltro/plugin-inventory/server";
+import { inventoryFixture as T } from "@voltro/plugin-inventory/testing";
+// src/iapStore.testFixtures.ts
+var E = y("_voltro_test_iap_policy", {
+	id: g({ prefix: "tip" }),
+	tenantId: b().maxLength(120).externalId(),
+	allowed: p(),
+	admission: _()
+}).index(["tenantId"]), D = [
+	...t,
+	...w,
+	...o,
+	...r,
+	E
+], O = async (t, r = "test.tenant", o = 4096, p = {}) => {
+	D.forEach(m);
+	let g = c(), _ = f(), { item: y, content: b } = T(), w = u("iap.fixture"), O = S(t, {
+		items: [y],
+		now: () => g.at
+	});
+	await l.runPromise(O.importSnapshot(w, {
+		tenantId: r,
+		channel: "live",
+		locale: "en",
+		revision: "iap.fixture.r1",
+		items: [b]
+	}));
+	let k = C(t, {
+		items: [y],
+		catalogSource: O,
+		channel: "live",
+		locale: "en",
+		maxInstances: o,
+		now: () => g.at
+	}), A = n(t, {
+		currencies: g.currencies,
+		now: () => g.at
+	}), j = {
+		...g.definition,
+		offer: {
+			...g.definition.offer,
+			items: [{
+				itemId: y.id,
+				qty: 2
+			}]
+		}
+	}, M = 0, N = i(t, {
+		realMoney: !0,
+		applicationId: g.options.applicationId,
+		channel: "ios",
+		environment: "sandbox"
+	}), P = {
+		...g.options,
+		products: [j],
+		accounts: N
+	}, F = a(P, {
+		initialize: () => l.void,
+		verify: () => (M++, l.succeed({
+			...g.facts,
+			transactionId: _
+		}))
+	}), I = "tip_" + d(16).toString("hex");
+	await t.insert(E.tableName, {
+		id: I,
+		tenantId: r,
+		allowed: !0,
+		admission: 0
+	});
+	let L = {
+		realMoney: !0,
+		namespace: r,
+		currencies: g.currencies,
+		verification: F,
+		admission: { prepare: () => l.succeed(x(t, async (t) => {
+			if (await t.updateMany(E.tableName, { admission: 0 }, { where: h("id", I) }) !== 1) throw e("forbidden");
+			let n = (await t.query(v(E).where(h("id", I)).limit(1).descriptor))[0];
+			if (!n || n.tenantId !== r || n.allowed !== !0) throw e("forbidden");
+			return null;
+		})) },
+		economy: A,
+		inventory: k,
+		systemAccount: "test.iap",
+		now: () => g.at,
+		...p
+	}, R = (e = "test.player", t = r) => ({
+		type: "user",
+		kind: "guest",
+		id: e,
+		tenantId: t
+	});
+	return {
+		...g,
+		scope: {
+			tenantId: r,
+			ownerId: "test.player"
+		},
+		transactionId: _,
+		definition: j,
+		catalog: O,
+		inventory: k,
+		economy: A,
+		accounts: N,
+		options: L,
+		verificationOptions: P,
+		iap: s(t, L),
+		user: R,
+		machine: w,
+		policyId: I,
+		item: y,
+		verificationCalls: () => M
+	};
+};
+export { E as iapPolicyFixtureTable, O as iapStoreFixture, D as iapStoreFixtureTables };

package/dist/iapTables.entity.js

@@ -0,0 +1,80 @@
+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/iapTables.entity.ts
+var s = () => a().maxLength(120).externalId().sensitive("pii"), c = () => a().maxLength(120).serverOnly(), l = i("_voltro_eco_iap_namespaces", {
+	id: t({ prefix: "ein" }),
+	namespace: c(),
+	admission: n().serverOnly(),
+	ordersCount: n().serverOnly(),
+	receiptsCount: n().serverOnly()
+}), u = i("_voltro_eco_iap_subjects", {
+	id: t({ prefix: "eis" }),
+	namespace: c(),
+	tenantId: s(),
+	ownerId: a().maxLength(120).nullable().externalId().sensitive("pii"),
+	erased: e().serverOnly(),
+	admission: n().serverOnly(),
+	ordersCount: n().serverOnly()
+}).index([
+	"namespace",
+	"tenantId",
+	"ownerId"
+]), d = i("_voltro_eco_iap_orders", {
+	id: t({ prefix: "eio" }),
+	namespace: c(),
+	tenantId: s(),
+	ownerId: a().maxLength(120).nullable().externalId().sensitive("pii"),
+	ownerKey: a().maxLength(64).serverOnly(),
+	state: a().maxLength(16).oneOf([
+		"pending",
+		"fulfilled",
+		"erased"
+	]).serverOnly(),
+	accepted: e().serverOnly(),
+	offerId: a().maxLength(120).serverOnly(),
+	acceptedQuantity: n().nullable().serverOnly(),
+	acceptedDay: n().nullable().serverOnly(),
+	offerVersion: a().maxLength(120).serverOnly(),
+	channel: a().maxLength(16).oneOf([
+		"ios",
+		"android",
+		"steam",
+		"web"
+	]).serverOnly(),
+	configurationDigest: a().maxLength(64).serverOnly(),
+	intentDigest: a().maxLength(64).nullable().serverOnly(),
+	receiptKey: a().maxLength(64).nullable().serverOnly(),
+	snapshot: r().nullable().serverOnly(),
+	receipt: r().nullable().serverOnly(),
+	createdAt: o().serverOnly(),
+	fulfilledAt: o().nullable().serverOnly()
+}).index([
+	"namespace",
+	"tenantId",
+	"ownerKey"
+]), f = i("_voltro_eco_iap_receipts", {
+	id: t({ prefix: "eir" }),
+	namespace: c(),
+	tenantId: s(),
+	ownerKey: a().maxLength(64).serverOnly(),
+	orderKey: a().maxLength(64).serverOnly(),
+	identity: a().maxLength(64).serverOnly(),
+	state: a().maxLength(16).oneOf([
+		"pending",
+		"fulfilled",
+		"erased"
+	]).serverOnly(),
+	accepted: e().serverOnly(),
+	factsDigest: a().maxLength(64).serverOnly(),
+	createdAt: o().serverOnly(),
+	fulfilledAt: o().nullable().serverOnly()
+}).index(["namespace"]).index([
+	"namespace",
+	"tenantId",
+	"ownerKey"
+]), p = [
+	l,
+	u,
+	d,
+	f
+];
+export { l as iapNamespacesTable, d as iapOrdersTable, f as iapReceiptsTable, u as iapSubjectsTable, p as iapTables };

package/dist/iapVerification.server.js

@@ -0,0 +1,120 @@
+import { EconomyError as e, economyError as t } from "./errors.js";
+import { captureBoundMethods as n, dataObject as r, identifier as i } from "./capture.js";
+import { captureCurrencies as a } from "./currency.js";
+import { shopInteger as o } from "./shop.js";
+import { captureIapPaidAmount as s, captureIapScope as c, defineIapCatalog as l, iapChannel as u, iapEnvironment as d, iapProductKind as f, iapReceiptIntent as p, iapTimestamp as m } from "./iap.js";
+import { Context as h, Effect as g } from "effect";
+import { createHash as _ } from "node:crypto";
+// src/iapVerification.server.ts
+var v = class extends h.Service()("@voltro/IapVerificationPort") {}, y = /* @__PURE__ */ new WeakMap(), b = (e, n) => {
+	if (typeof e != "string" || e.length === 0 || e.length > n || /[\u0000-\u0020\u007f]/.test(e)) throw t("invalid_record");
+	return e;
+}, x = (e) => {
+	let n = r(e, [
+		"channel",
+		"environment",
+		"applicationId",
+		"transactionId",
+		"originalTransactionId",
+		"storeProductId",
+		"kind",
+		"quantity",
+		"purchasedAt",
+		"expiresAt",
+		"paid",
+		"acknowledgement",
+		"consumption"
+	], "invalid_record"), a = m(n.purchasedAt), c = n.expiresAt === null ? null : m(n.expiresAt), l = f(n.kind);
+	if ((l === "subscription" ? c === null || c <= a : c !== null) || l === "subscription" && (n.quantity !== 1 || n.consumption !== "none")) throw t("invalid_record");
+	let p = s(n.paid);
+	if (n.acknowledgement !== "none" && n.acknowledgement !== "pending" && n.acknowledgement !== "acknowledged" || n.consumption !== "none" && n.consumption !== "available" && n.consumption !== "consumed") throw t("invalid_record");
+	return Object.freeze({
+		channel: u(n.channel),
+		environment: d(n.environment),
+		applicationId: i(n.applicationId),
+		transactionId: b(n.transactionId, 512),
+		originalTransactionId: n.originalTransactionId === null ? null : b(n.originalTransactionId, 512),
+		storeProductId: i(n.storeProductId),
+		kind: l,
+		quantity: o(n.quantity, 1, 1e3),
+		purchasedAt: a,
+		expiresAt: c,
+		paid: p,
+		acknowledgement: n.acknowledgement,
+		consumption: n.consumption
+	});
+}, S = (e) => {
+	let n = typeof e == "object" && e ? y.get(e) : void 0;
+	if (!n) throw t("forbidden");
+	return n;
+}, C = (o, s) => {
+	let f = r(o, [
+		"realMoney",
+		"channel",
+		"environment",
+		"applicationId",
+		"products",
+		"currencies",
+		"accounts",
+		"now"
+	]);
+	if (f.realMoney !== !0) throw t(f.realMoney === !1 ? "real_money_disabled" : "invalid_input");
+	let h = u(f.channel), v = d(f.environment), S = i(f.applicationId), C = a(f.currencies), w = l(f.products, C, !0);
+	if (w.length === 0 || w.some((e) => e.channel !== h)) throw t("invalid_input");
+	let T = n(f.accounts, ["read", "prepareBinding"]), E = n(s, ["initialize", "verify"]), D = f.now ?? Date.now;
+	if (typeof D != "function") throw t("invalid_input");
+	return Object.freeze({
+		initialize: () => g.suspend(() => E.initialize()).pipe(g.catchDefect(() => g.fail(t("unavailable")))),
+		verify: (n, r) => {
+			try {
+				let i = c(n), a = p(r), o = w.find((e) => e.channel === a.channel && e.offer.id === a.offerId && e.offer.version === a.offerVersion);
+				return !o || a.channel !== h ? g.fail(t("forbidden")) : g.suspend(() => {
+					let n = m(D());
+					return T.read(i, h, v).pipe(g.flatMap((e) => {
+						let t = b(e, 128);
+						return E.verify(Object.freeze({
+							scope: i,
+							intent: a,
+							product: o,
+							accountToken: t,
+							at: n
+						})).pipe(g.map((e) => ({
+							facts: e,
+							accountToken: t
+						})));
+					}), g.flatMap((r) => g.try({
+						try: () => {
+							let e = x(r.facts);
+							if (e.channel !== h || e.environment !== v || e.applicationId !== S || e.storeProductId !== o.storeProductId || e.kind !== o.kind || e.quantity > o.offer.maxQuantity || e.purchasedAt > n || e.expiresAt !== null && e.expiresAt <= n) throw t("forbidden");
+							let s = _("sha256").update(JSON.stringify([
+								h,
+								v,
+								S,
+								e.transactionId
+							])).digest("hex"), c = Object.freeze({
+								scope: i,
+								offerId: a.offerId,
+								offerVersion: a.offerVersion,
+								requestId: a.requestId,
+								verifiedAt: n,
+								identity: s,
+								facts: e
+							});
+							return y.set(c, Object.freeze({
+								...c,
+								product: o,
+								currencies: C,
+								accounts: T,
+								accountToken: r.accountToken
+							})), c;
+						},
+						catch: (n) => n instanceof e ? n : t("invalid_record")
+					})));
+				}).pipe(g.catchDefect(() => g.fail(t("unavailable"))));
+			} catch (n) {
+				return g.fail(n instanceof e ? n : t("invalid_input"));
+			}
+		}
+	});
+};
+export { v as IapVerificationPort, x as captureIapTransactionFacts, C as iapVerificationPort, S as readVerifiedIapPurchase };