@voltro/plugin-economy 0.0.0-stage → 0.88.0

package/dist/subscriptions.js

@@ -0,0 +1,212 @@
+import { economyError as e } from "./errors.js";
+import { captureBoundMethods as t, dataList as n, dataObject as r, identifier as i } from "./capture.js";
+import { captureCurrencies as a } from "./currency.js";
+import { definePrice as o } from "./price.js";
+import { defineShopOffer as s, shopInteger as c } from "./shop.js";
+import { Context as l } from "effect";
+// src/subscriptions.ts
+var u = (e, t) => {
+	let i = r(e ?? {}, ["items", "currencies"]), a = n(i.items ?? [], 16), o = n(i.currencies ?? [], 16);
+	if (!a.length && !o.length) return Object.freeze({
+		items: Object.freeze([]),
+		currencies: Object.freeze([])
+	});
+	let c = s({
+		id: "subscription.gift",
+		titleKey: "subscription.gift",
+		price: { kind: "free" },
+		items: a,
+		currencies: o
+	}, t);
+	return Object.freeze({
+		items: c.items,
+		currencies: c.currencies
+	});
+}, d = (t, n, s = !1) => {
+	let l = r(t, [
+		"id",
+		"version",
+		"titleKey",
+		"price",
+		"period",
+		"grants",
+		"graceDays",
+		"coolingOff",
+		"disclosure"
+	]), d = a(n), f = r(l.period, ["unit", "count"]);
+	if (f.unit !== "day" && f.unit !== "week" && f.unit !== "month") throw e("invalid_input");
+	let p = c(f.count, 1, 12), m = r(l.grants, ["onPurchase", "daily"]), h = c(l.graceDays ?? 0, 0, 30), g = r(l.coolingOff ?? { days: 14 }, ["days", "overrideReason"]), _ = c(g.days, 0, 365), v = g.overrideReason ?? null;
+	if (v !== null && (typeof v != "string" || v.trim() !== v || v.length < 8 || v.length > 1e3) || _ < 14 && v === null) throw e("invalid_input");
+	let y = r(l.disclosure, [
+		"durationKey",
+		"renewalKey",
+		"cancellationPath"
+	]), b = y.cancellationPath;
+	if (typeof b != "string" || b.length > 512 || !/^\/(?!\/)[A-Za-z0-9/_-]*$/.test(b) || b === "/") throw e("invalid_input");
+	return Object.freeze({
+		id: i(l.id),
+		version: i(l.version ?? "1"),
+		titleKey: i(l.titleKey),
+		price: o(l.price, d, s),
+		period: Object.freeze({
+			unit: f.unit,
+			count: p
+		}),
+		grants: Object.freeze({
+			onPurchase: u(m.onPurchase, d),
+			daily: u(m.daily, d)
+		}),
+		graceDays: h,
+		coolingOff: Object.freeze({
+			days: _,
+			overrideReason: v
+		}),
+		disclosure: Object.freeze({
+			durationKey: i(y.durationKey),
+			renewalKey: i(y.renewalKey),
+			cancellationPath: b
+		})
+	});
+}, f = (e) => c(e, 0, 864e13), p = (t) => {
+	let n = r(t, [
+		"subscription",
+		"currencies",
+		"realMoney",
+		"originAt",
+		"index",
+		"rulesVersion"
+	]), o = a(n.currencies), s = n.realMoney ?? !1;
+	if (typeof s != "boolean") throw e("invalid_input");
+	return Object.freeze({
+		subscription: d(n.subscription, o, s),
+		currencies: o,
+		realMoney: s,
+		originAt: f(n.originAt),
+		index: c(n.index, 0, 1e5),
+		rulesVersion: i(n.rulesVersion ?? "default.v1")
+	});
+}, m = (t, n, r) => {
+	if (n.unit !== "month") {
+		let i = BigInt(t) + BigInt(n.count) * BigInt(r) * BigInt(n.unit === "week" ? 7 : 1) * 86400000n;
+		if (i > 8640000000000000n) throw e("invalid_input");
+		return Number(i);
+	}
+	let i = new Date(t), a = i.getUTCFullYear() * 12 + i.getUTCMonth() + n.count * r, o = Math.floor(a / 12), s = a % 12, c = new Date(t);
+	c.setUTCDate(1), c.setUTCFullYear(o, s, 1);
+	let l = new Date(c);
+	if (l.setUTCMonth(s + 1, 0), !Number.isFinite(c.getTime()) || !Number.isFinite(l.getTime())) throw e("invalid_input");
+	return c.setUTCDate(Math.min(i.getUTCDate(), l.getUTCDate())), f(c.getTime());
+}, h = (e) => {
+	let t = p(e);
+	return Object.freeze({
+		startsAt: m(t.originAt, t.subscription.period, t.index),
+		expiresAt: m(t.originAt, t.subscription.period, t.index + 1)
+	});
+}, g = (t, n = h) => {
+	if (typeof n != "function") throw e("invalid_input");
+	let i = p(t);
+	if (n !== h && i.rulesVersion === "default.v1") throw e("invalid_input");
+	let a = h(i), o = r(n(i), ["startsAt", "expiresAt"]), s = f(o.startsAt), c = f(o.expiresAt);
+	if (s >= c || s < a.startsAt || c > a.expiresAt) throw e("invalid_input");
+	return Object.freeze({
+		startsAt: s,
+		expiresAt: c
+	});
+}, _ = ({ entitlement: e, at: t, claimedDays: n }) => t >= e.startsAt && (e.state === "active" && t < e.expiresAt || e.state === "grace" && t >= e.expiresAt && t < e.graceUntil) && !n.includes(Math.floor(t / 864e5)), v = (t, a = _) => {
+	if (typeof a != "function") throw e("invalid_input");
+	let o = r(t, [
+		"entitlement",
+		"at",
+		"claimedDays",
+		"rulesVersion"
+	]), s = r(o.entitlement, [
+		"startsAt",
+		"expiresAt",
+		"graceUntil",
+		"state"
+	]), l = i(o.rulesVersion ?? "default.v1");
+	if (a !== _ && l === "default.v1") throw e("invalid_input");
+	let u = f(s.startsAt), d = f(s.expiresAt), p = f(s.graceUntil), m = s.state;
+	if (u >= d || p < d || m !== "active" && m !== "grace" && m !== "expired") throw e("invalid_input");
+	let h = f(o.at), g = Object.freeze(n(o.claimedDays, 1e5).map((e) => c(e, 0, 1e8)));
+	if (new Set(g).size !== g.length) throw e("invalid_input");
+	let v = Object.freeze({
+		startsAt: u,
+		expiresAt: d,
+		graceUntil: p,
+		state: m
+	}), y = Object.freeze({
+		entitlement: v,
+		at: h,
+		claimedDays: g,
+		rulesVersion: l
+	}), b = a(y);
+	if (typeof b != "boolean") throw e("invalid_input");
+	return Object.freeze({
+		eligible: b && _(y),
+		day: Math.floor(h / 864e5)
+	});
+}, y = class extends l.Service()("@voltro/SubscriptionsPort") {}, b = (e) => t(e, [
+	"list",
+	"active",
+	"start",
+	"renew",
+	"claimDaily",
+	"cancel",
+	"receipt",
+	"exportSubject",
+	"eraseSubject"
+]), x = (t) => {
+	let n = r(t, [
+		"subscriptionId",
+		"subscriptionVersion",
+		"subscriptionDigest",
+		"requestId",
+		"currency"
+	]);
+	if (typeof n.subscriptionDigest != "string" || !/^[a-f0-9]{64}$/.test(n.subscriptionDigest)) throw e("invalid_input");
+	return Object.freeze({
+		subscriptionId: i(n.subscriptionId),
+		subscriptionVersion: i(n.subscriptionVersion),
+		subscriptionDigest: n.subscriptionDigest,
+		requestId: i(n.requestId),
+		currency: n.currency === void 0 ? null : i(n.currency)
+	});
+}, S = (e) => {
+	let t = r(e, ["entitlementId", "requestId"]);
+	return Object.freeze({
+		entitlementId: i(t.entitlementId),
+		requestId: i(t.requestId)
+	});
+}, C = (e) => {
+	let t = r(e, [
+		"tenantId",
+		"ownerId",
+		"entitlementId",
+		"requestId"
+	]);
+	return Object.freeze({
+		tenantId: i(t.tenantId),
+		ownerId: i(t.ownerId),
+		entitlementId: i(t.entitlementId),
+		requestId: i(t.requestId)
+	});
+}, w = (t) => {
+	let n = r(t, ["kind", "intent"]);
+	if (n.kind === "start") {
+		let e = x(n.intent);
+		return Object.freeze({
+			kind: "start",
+			intent: Object.freeze({
+				...e,
+				currency: e.currency ?? void 0
+			})
+		});
+	}
+	if (n.kind !== "renew" && n.kind !== "daily" && n.kind !== "cancel") throw e("invalid_input");
+	return Object.freeze({
+		kind: n.kind,
+		intent: S(n.intent)
+	});
+};
+export { y as SubscriptionsPort, w as captureSubscriptionReceiptIntent, b as captureSubscriptionsService, _ as defaultSubscriptionDailyGrant, h as defaultSubscriptionPeriod, d as defineSubscription, v as resolveSubscriptionDailyGrant, g as resolveSubscriptionPeriod, S as subscriptionEntitlementIntent, C as subscriptionRenewIntent, x as subscriptionStartIntent };

package/dist/subscriptionsPort.fixture.js

@@ -0,0 +1,75 @@
+import { SubscriptionsPort as e } from "./subscriptions.js";
+import { EconomyPort as t } from "./port.js";
+import { economyPlugin as n } from "./plugin.js";
+import { subscriptionFixtureStart as r, subscriptionStoreFixture as i } from "./subscriptionStore.testFixtures.js";
+import { Effect as a, Layer as o } from "effect";
+import { InMemoryDataStore as s } from "@voltro/runtime";
+// src/subscriptionsPort.fixture.ts
+var c = {
+	app: {
+		name: "subscriptions-fixture",
+		type: "api",
+		voltroVersion: "0.83.1"
+	},
+	config: {},
+	env: {},
+	logger: {
+		info() {},
+		warn() {},
+		error() {},
+		debug() {}
+	}
+}, l = a.gen(function* () {
+	let e = new s(), t = yield* a.promise(() => i(e, "fixture")), r = t.options, o = n({
+		currencies: r.currencies,
+		now: r.now,
+		subscriptions: {
+			subscriptions: r.subscriptions,
+			inventory: r.inventory,
+			accessSource: r.accessSource,
+			version: r.version,
+			period: r.period,
+			daily: r.daily,
+			priceResolver: r.priceResolver,
+			systemAccount: r.systemAccount,
+			maxHistoryRows: r.maxHistoryRows,
+			now: r.now
+		}
+	});
+	return yield* a.promise(async () => {
+		await o.bindDataStore?.(e);
+	}), Object.freeze({
+		store: e,
+		plugin: o,
+		base: t,
+		close: a.suspend(() => o.onDeactivate?.(c))
+	});
+}), u = o.effectContext(a.acquireRelease(l, (e) => e.close).pipe(a.flatMap((e) => o.build(e.plugin.services)))), d = Object.freeze({
+	kind: "port",
+	tag: e,
+	fakeLayer: u,
+	probe: {
+		run: () => a.scoped(a.gen(function* () {
+			let n = yield* e, i = yield* t, a = {
+				type: "user",
+				id: "a",
+				tenantId: "fixture",
+				kind: "guest"
+			}, o = (yield* n.list(a))[0], s = r(o), c = yield* n.start(a, s), l = yield* n.start(a, s), u = yield* n.claimDaily(a, {
+				entitlementId: c.entitlementId,
+				requestId: "daily"
+			}), d = yield* i.mine(a);
+			return {
+				same: c.operationId === l.operationId,
+				daily: u.kind,
+				balance: d[0]?.balance
+			};
+		}).pipe(a.provide(u))),
+		expected: {
+			same: !0,
+			daily: "daily",
+			balance: "93"
+		}
+	}
+});
+export { u as subscriptionsFakeLayer, l as subscriptionsPortFixture, d as subscriptionsPortSystemFixture };

package/dist/systemFixtures.js

@@ -0,0 +1,88 @@
+import { defaultPriceResolver as e, resolvePrice as t } from "./price.js";
+import { EconomyPort as n } from "./port.js";
+import { priceResolverFixture as r } from "./declarationFixtures.js";
+import { economyPortFixture as i } from "./economyPort.fixture.js";
+import { Effect as a, Layer as o } from "effect";
+import { systemSubject as s } from "@voltro/protocol";
+// src/systemFixtures.ts
+var c = r(), l = Object.freeze({
+	kind: "slot",
+	defaultImplementation: e,
+	defaultProbe: {
+		run: () => a.sync(() => t(c.context)),
+		expected: {
+			kind: "virtual",
+			options: [{
+				currency: "test.gold",
+				amount: "6"
+			}]
+		}
+	},
+	overrideProbe: {
+		run: () => a.sync(() => t(c.context, (t) => e({
+			...t,
+			adjustments: [{
+				currency: "test.gold",
+				discountBps: 6e3,
+				minimum: "2"
+			}]
+		}))),
+		expected: {
+			kind: "virtual",
+			options: [{
+				currency: "test.gold",
+				amount: "5"
+			}]
+		}
+	}
+}), u = o.effect(n, a.acquireRelease(a.sync(() => i({
+	currencies: [{
+		id: "test.gold",
+		kind: "soft",
+		cap: "1000"
+	}],
+	now: () => 0
+})), (e) => e.close).pipe(a.map((e) => e.service))), d = s("economy.system.fixture"), f = {
+	type: "user",
+	id: "a",
+	tenantId: "fixture"
+}, p = Object.freeze({
+	kind: "port",
+	tag: n,
+	fakeLayer: u,
+	probe: {
+		run: () => a.scoped(a.gen(function* () {
+			let e = yield* n, t = {
+				tenantId: "fixture",
+				requestId: "reward",
+				currency: "test.gold",
+				amount: "7",
+				from: {
+					kind: "system",
+					id: "fixture"
+				},
+				to: {
+					kind: "wallet",
+					ownerKind: "player",
+					ownerId: "a"
+				},
+				reason: "fixture",
+				ref: {
+					kind: "fixture",
+					id: "reward"
+				}
+			}, r = yield* e.transfer(d, t), i = yield* e.transfer(d, t), a = yield* e.mine(f), o = yield* e.auditWallet(d, "fixture", t.to, t.currency);
+			return {
+				original: r.txId === i.txId,
+				balance: a[0]?.balance,
+				matches: o.matches
+			};
+		}).pipe(a.provide(u))),
+		expected: {
+			original: !0,
+			balance: "7",
+			matches: !0
+		}
+	}
+});
+export { u as economyFakeLayer, p as economyPortSystemFixture, l as priceResolverSystemFixture };

package/dist/tables.entity.js

@@ -0,0 +1,82 @@
+import { bigint as e, boolean as t, id as n, integer as r, json as i, table as a, text as o, timestamp as s } from "@voltro/database";
+// src/tables.entity.ts
+var c = () => o().maxLength(120).externalId().sensitive("pii"), l = a("_voltro_eco_currencies", {
+	id: n({ prefix: "ecc" }),
+	tenantId: c(),
+	currency: o().maxLength(120).safe(),
+	config: i().safe(),
+	admission: r().serverOnly()
+}).index(["tenantId", "currency"]), u = a("_voltro_eco_wallets", {
+	id: n({ prefix: "ecw" }),
+	tenantId: c(),
+	ownerId: o().maxLength(120).externalId().sensitive("pii"),
+	ownerKind: o().maxLength(16).oneOf(["player", "guild"]).safe(),
+	currency: o().maxLength(120).safe(),
+	balance: e().safe(),
+	updatedAt: s().safe(),
+	debtPolicy: o().maxLength(16).oneOf(["allowNegative", "blockSpend"]).nullable().serverOnly()
+}).index([
+	"tenantId",
+	"ownerKind",
+	"ownerId",
+	"currency"
+]), d = a("_voltro_eco_ledger", {
+	id: n({ prefix: "ecl" }),
+	tenantId: c(),
+	txId: o().maxLength(64).safe(),
+	currency: o().maxLength(120).safe(),
+	accountKind: o().maxLength(16).oneOf(["wallet", "system"]).safe(),
+	ownerId: o().maxLength(120).nullable().externalId().sensitive("pii"),
+	ownerKind: o().maxLength(16).oneOf(["player", "guild"]).nullable().safe(),
+	walletKey: o().maxLength(64).nullable().serverOnly(),
+	systemAccount: o().maxLength(120).nullable().safe(),
+	ownerSequence: r().nullable().serverOnly(),
+	debtPolicy: o().maxLength(16).oneOf(["allowNegative", "blockSpend"]).nullable().serverOnly(),
+	debit: e().safe(),
+	credit: e().safe(),
+	reason: o().maxLength(120).safe(),
+	refKind: o().maxLength(120).nullable().sensitive("pii"),
+	refId: o().maxLength(120).nullable().sensitive("pii"),
+	actor: o().maxLength(120).nullable().sensitive("pii"),
+	at: s().safe()
+}).index([
+	"tenantId",
+	"ownerKind",
+	"ownerId"
+]).index(["tenantId", "txId"]).index([
+	"tenantId",
+	"currency",
+	"walletKey"
+]), f = a("_voltro_eco_tx", {
+	id: n({ prefix: "ect" }),
+	tenantId: c(),
+	state: o().maxLength(16).oneOf([
+		"pending",
+		"committed",
+		"erased"
+	]).serverOnly(),
+	digest: o().maxLength(64).nullable().serverOnly(),
+	receipt: i().nullable().safe(),
+	escrow: i().nullable().serverOnly(),
+	admission: r().serverOnly(),
+	createdAt: s().safe()
+}).index(["tenantId", "state"]), p = a("_voltro_eco_subjects", {
+	id: n({ prefix: "ecs" }),
+	tenantId: c(),
+	ownerKind: o().maxLength(16).oneOf(["player", "guild"]).safe(),
+	ownerId: o().maxLength(120).nullable().externalId().sensitive("pii"),
+	erased: t().serverOnly(),
+	admission: r().serverOnly(),
+	entriesCount: r().serverOnly()
+}).index([
+	"tenantId",
+	"ownerKind",
+	"ownerId"
+]), m = [
+	l,
+	u,
+	d,
+	f,
+	p
+];
+export { l as economyCurrenciesTable, d as economyLedgerTable, p as economySubjectsTable, m as economyTables, f as economyTransactionsTable, u as economyWalletsTable };