@voltro/plugin-economy 0.0.0-stage → 0.87.0

package/dist/shopUiCopy.js

@@ -0,0 +1,57 @@
+//#region src/shopUiCopy.ts
+var e = Object.freeze({
+	en: Object.freeze({
+		shop: "Shop",
+		loading: "Loading offers…",
+		unavailable: "Offers are unavailable. Your saved purchase stays available for recovery.",
+		empty: "No offers are available.",
+		choose: "Choose offer",
+		free: "Free",
+		oneTime: "One purchase per account",
+		closed: "Offer is outside its availability window.",
+		providersMissing: "Real-money checkout is unavailable.",
+		confirm: "Confirm purchase",
+		cancel: "Close",
+		sending: "Sending the saved purchase…",
+		uncertain: "This purchase is awaiting confirmation. Keep its original request; closing this view does not cancel it.",
+		retry: "Retry original purchase",
+		complete: "Purchase confirmed",
+		invalid: "This selection has changed. Review the current offer before purchasing.",
+		originalRequest: "Original request",
+		originalOffer: "Original offer",
+		pricePolicy: "The current discount can change before acceptance. The server can charge at most the declared maximum for this saved offer. Limits and eligibility are checked on purchase.",
+		currentPrice: "Currently displayed",
+		maximumPrice: "Maximum charge",
+		quantity: "Quantity",
+		endsIn: (e) => `Ends in ${e} seconds`,
+		discount: (e) => `${e}% below the declared price`
+	}),
+	de: Object.freeze({
+		shop: "Shop",
+		loading: "Angebote werden geladen…",
+		unavailable: "Angebote sind nicht verfügbar. Dein gespeicherter Kauf bleibt zur Wiederaufnahme erhalten.",
+		empty: "Keine Angebote verfügbar.",
+		choose: "Angebot auswählen",
+		free: "Kostenlos",
+		oneTime: "Ein Kauf pro Konto",
+		closed: "Das Angebot liegt außerhalb seines Verfügbarkeitsfensters.",
+		providersMissing: "Echtgeld-Checkout ist nicht verfügbar.",
+		confirm: "Kauf bestätigen",
+		cancel: "Schließen",
+		sending: "Der gespeicherte Kauf wird gesendet…",
+		uncertain: "Dieser Kauf wartet auf Bestätigung. Behalte die ursprüngliche Anfrage; Schließen dieser Ansicht storniert ihn nicht.",
+		retry: "Ursprünglichen Kauf erneut senden",
+		complete: "Kauf bestätigt",
+		invalid: "Diese Auswahl hat sich geändert. Prüfe vor dem Kauf das aktuelle Angebot.",
+		originalRequest: "Ursprüngliche Anfrage",
+		originalOffer: "Ursprüngliches Angebot",
+		pricePolicy: "Der aktuelle Rabatt kann sich vor der Annahme ändern. Der Server kann höchstens den deklarierten Maximalpreis für das gespeicherte Angebot berechnen. Limits und Zulassung werden beim Kauf geprüft.",
+		currentPrice: "Aktuell angezeigt",
+		maximumPrice: "Maximale Belastung",
+		quantity: "Menge",
+		endsIn: (e) => `Endet in ${e} Sekunden`,
+		discount: (e) => `${e}% unter dem deklarierten Preis`
+	})
+});
+//#endregion
+export { e as shopUiCopy };

package/dist/spendLimits.d.ts

@@ -0,0 +1,140 @@
+import { Effect } from 'effect';
+import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
+
+export declare const assertSpendBudget: (projection: ReturnType<typeof projectSpend>, input: EconomyAmountInput, budget: SpendBudget) => void;
+
+export declare const captureSpendLimitsOptions: (input: SpendLimitsOptions, currencies: readonly CurrencyDefinition[]) => Readonly<{
+    limits: readonly SpendLimit[];
+    source: SpendFactsSource;
+    version: string;
+    policy: SpendLimitPolicy;
+}>;
+
+declare interface CurrencyDefinition {
+    readonly id: string;
+    readonly kind: 'soft' | 'hard';
+    readonly cap?: EconomyAmountInput;
+    readonly premium?: boolean;
+    readonly display?: {
+        readonly nameKey: string;
+    } | null;
+}
+
+/** Currency-specific virtual limits, not an exchange rate, legal age source,
+ * provider payment limit or consent/withdrawal implementation. */
+export declare const defaultSpendLimitPolicy: SpendLimitPolicy;
+
+export declare const defineSpendLimits: (input: readonly (SpendLimitDefinition | SpendLimit)[], declarations: readonly CurrencyDefinition[]) => readonly SpendLimit[];
+
+declare type EconomyAmountInput = string | number | bigint;
+
+/** Redacted codes; never carries owners, amounts or provider payloads. */
+declare class EconomyError extends EconomyError_base {
+}
+
+declare const EconomyError_base: Schema.Class<EconomyError, Schema.TaggedStruct<"EconomyError", {
+    readonly code: Schema.Literals<readonly ["invalid_currency", "invalid_amount", "overflow", "invalid_price", "real_money_disabled", "invalid_input", "invalid_record", "currency_cap_reached", "insufficient_funds", "conflict", "forbidden", "unavailable", "not_found", "erased", "limit_exceeded", "already_redeemed"]>;
+}>, YieldableError>;
+
+/** Complete owner/currency history is supplied and validated by SQL custody.
+ * Credits/refunds never silently replenish an already consumed spend allowance. */
+export declare const projectSpend: (input: readonly SpendPosting[], at: number) => Readonly<{
+    windows: Readonly<{
+        day: Readonly<{
+            from: number;
+            until: number;
+        }>;
+        month: Readonly<{
+            from: number;
+            until: number;
+        }>;
+    }>;
+    daily: string;
+    monthly: string;
+    balance: string;
+}>;
+
+export declare const resolveSpendBudget: (input: SpendLimitContext, policy?: SpendLimitPolicy) => SpendBudget;
+
+export declare interface SpendBudget {
+    readonly daily: string | null;
+    readonly monthly: string | null;
+    readonly allowed: boolean;
+}
+
+export declare interface SpendFacts extends SpendFactsInput {
+    readonly allowed: boolean;
+    readonly minor: boolean;
+    readonly observedAt: number;
+    readonly daily?: EconomyAmountInput | null | undefined;
+    readonly monthly?: EconomyAmountInput | null;
+    readonly blockedUntil?: number | null;
+}
+
+export declare interface SpendFactsInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+    readonly ownerKind: 'player' | 'guild';
+    readonly currency: string;
+    readonly at: number;
+}
+
+export declare interface SpendFactsSource {
+    readonly read: (input: SpendFactsInput) => Effect.Effect<SpendFacts, EconomyError>;
+}
+
+export declare interface SpendLimit {
+    readonly currency: string;
+    readonly daily: string | null;
+    readonly monthly: string | null;
+    readonly minors: {
+        readonly daily: string | null;
+        readonly monthly: string | null;
+    } | null;
+}
+
+export declare interface SpendLimitContext {
+    readonly limit: SpendLimit;
+    readonly facts: SpendFacts;
+    readonly version: string;
+}
+
+export declare interface SpendLimitDefinition {
+    readonly currency: string;
+    readonly daily?: EconomyAmountInput | null | undefined;
+    readonly monthly?: EconomyAmountInput | null;
+    readonly minors?: {
+        readonly daily?: EconomyAmountInput | null | undefined;
+        readonly monthly?: EconomyAmountInput | null;
+    };
+}
+
+export declare type SpendLimitPolicy = (input: SpendLimitContext) => SpendBudget;
+
+export declare interface SpendLimitsOptions {
+    readonly limits: readonly (SpendLimitDefinition | SpendLimit)[];
+    readonly source: SpendFactsSource;
+    readonly version: string;
+    readonly policy?: SpendLimitPolicy;
+}
+
+export declare interface SpendPosting {
+    readonly id: string;
+    readonly debit: string;
+    readonly credit: string;
+    readonly at: number;
+}
+
+export declare const utcSpendWindows: (at: number) => Readonly<{
+    day: Readonly<{
+        from: number;
+        until: number;
+    }>;
+    month: Readonly<{
+        from: number;
+        until: number;
+    }>;
+}>;
+
+export { }

package/dist/spendLimits.fixture.js

@@ -0,0 +1,53 @@
+import { defaultSpendLimitPolicy as e, defineSpendLimits as t, resolveSpendBudget as n } from "./spendLimits.js";
+import { Effect as r } from "effect";
+//#region src/spendLimits.fixture.ts
+var i = () => Object.freeze({
+	limit: t([{
+		currency: "test.gold",
+		daily: "100",
+		monthly: "1000",
+		minors: {
+			daily: "10",
+			monthly: "100"
+		}
+	}], [{
+		id: "test.gold",
+		kind: "soft"
+	}])[0],
+	facts: Object.freeze({
+		tenantId: "fixture",
+		ownerId: "a",
+		ownerKind: "player",
+		currency: "test.gold",
+		at: 100,
+		observedAt: 100,
+		allowed: !0,
+		minor: !0
+	}),
+	version: "test.spend.v1"
+}), a = i(), o = Object.freeze({
+	kind: "slot",
+	defaultImplementation: e,
+	defaultProbe: {
+		run: () => r.sync(() => n(a)),
+		expected: {
+			daily: "10",
+			monthly: "100",
+			allowed: !0
+		}
+	},
+	overrideProbe: {
+		run: () => r.sync(() => n(a, () => ({
+			daily: "5",
+			monthly: "50",
+			allowed: !0
+		}))),
+		expected: {
+			daily: "5",
+			monthly: "50",
+			allowed: !0
+		}
+	}
+});
+//#endregion
+export { i as spendLimitFixture, o as spendLimitPolicySystemFixture };

package/dist/spendLimits.js

@@ -0,0 +1,155 @@
+import { economyError as e } from "./errors.js";
+import { captureBoundMethods as t, dataList as n, dataObject as r, identifier as i } from "./capture.js";
+import { nonNegativeAmount as a, positiveAmount as o } from "./amount.js";
+import { captureCurrencies as s } from "./currency.js";
+import { shopInteger as c } from "./shop.js";
+//#region src/spendLimits.ts
+var l = (e) => e == null ? null : a(e).toString(), u = (e, t) => e === null || t !== null && BigInt(t) <= BigInt(e), d = (e, t) => e === null ? t : t === null || BigInt(e) < BigInt(t) ? e : t, f = (t, a) => {
+	let o = s(a), c = Object.freeze(n(t, 128).map((t) => {
+		let n = r(t, [
+			"currency",
+			"daily",
+			"monthly",
+			"minors"
+		]), a = i(n.currency);
+		if (!o.some((e) => e.id === a)) throw e("invalid_currency");
+		let s = l(n.daily), c = l(n.monthly), u = n.minors == null ? null : r(n.minors, ["daily", "monthly"]), f = u ? Object.freeze({
+			daily: d(s, l(u.daily)),
+			monthly: d(c, l(u.monthly))
+		}) : null;
+		if (s === null && c === null && (f === null || f.daily === null && f.monthly === null)) throw e("invalid_input");
+		return Object.freeze({
+			currency: a,
+			daily: s,
+			monthly: c,
+			minors: f
+		});
+	}).sort((e, t) => e.currency < t.currency ? -1 : +(e.currency > t.currency)));
+	if (!c.length || new Set(c.map((e) => e.currency)).size !== c.length) throw e("invalid_input");
+	return c;
+}, p = ({ limit: e, facts: t }) => {
+	let n = t.minor && e.minors ? e.minors : e;
+	return Object.freeze({
+		daily: d(n.daily, l(t.daily)),
+		monthly: d(n.monthly, l(t.monthly)),
+		allowed: t.allowed && (t.blockedUntil == null || t.at >= t.blockedUntil)
+	});
+}, m = (t, n = p) => {
+	let a = r(t, [
+		"limit",
+		"facts",
+		"version"
+	]), o = r(a.limit, [
+		"currency",
+		"daily",
+		"monthly",
+		"minors"
+	]), s = o.minors == null ? null : r(o.minors, ["daily", "monthly"]), f = l(o.daily), m = l(o.monthly), h = Object.freeze({
+		currency: i(o.currency),
+		daily: f,
+		monthly: m,
+		minors: s ? Object.freeze({
+			daily: d(f, l(s.daily)),
+			monthly: d(m, l(s.monthly))
+		}) : null
+	}), g = r(a.facts, [
+		"tenantId",
+		"ownerId",
+		"ownerKind",
+		"currency",
+		"at",
+		"allowed",
+		"minor",
+		"observedAt",
+		"daily",
+		"monthly",
+		"blockedUntil"
+	]);
+	if (typeof g.allowed != "boolean" || typeof g.minor != "boolean" || g.ownerKind !== "player" && g.ownerKind !== "guild") throw e("invalid_record");
+	let _ = c(g.at, 0, 8639999999999999), v = c(g.observedAt, 0, _), y = Object.freeze({
+		tenantId: i(g.tenantId),
+		ownerId: i(g.ownerId),
+		ownerKind: g.ownerKind,
+		currency: i(g.currency),
+		at: _,
+		observedAt: v,
+		allowed: g.allowed,
+		minor: g.minor,
+		daily: l(g.daily),
+		monthly: l(g.monthly),
+		blockedUntil: g.blockedUntil == null ? null : c(g.blockedUntil, 0, 864e13)
+	}), b = i(a.version);
+	if (y.currency !== h.currency || typeof n != "function" || b === "default.v1") throw e("invalid_input");
+	let x = Object.freeze({
+		limit: h,
+		facts: y,
+		version: b
+	}), S = p(x), C = r(n(x), [
+		"daily",
+		"monthly",
+		"allowed"
+	]), w = l(C.daily), T = l(C.monthly);
+	if (typeof C.allowed != "boolean" || C.allowed && !S.allowed || !u(S.daily, w) || !u(S.monthly, T)) throw e("invalid_input");
+	return Object.freeze({
+		daily: w,
+		monthly: T,
+		allowed: C.allowed
+	});
+}, h = (n, a) => {
+	let o = r(n, [
+		"limits",
+		"source",
+		"version",
+		"policy"
+	]), s = f(o.limits, a), c = t(o.source, ["read"]), l = i(o.version), u = o.policy ?? p;
+	if (l === "default.v1" || typeof u != "function") throw e("invalid_input");
+	return Object.freeze({
+		limits: s,
+		source: c,
+		version: l,
+		policy: u
+	});
+}, g = (e) => {
+	c(e, 0, 8639999999999999);
+	let t = Math.floor(e / 864e5) * 864e5, n = new Date(e);
+	n.setUTCDate(1), n.setUTCHours(0, 0, 0, 0);
+	let r = new Date(n);
+	return r.setUTCMonth(r.getUTCMonth() + 1), Object.freeze({
+		day: Object.freeze({
+			from: t,
+			until: Math.min(t + 864e5, 864e13)
+		}),
+		month: Object.freeze({
+			from: n.getTime(),
+			until: Number.isFinite(r.getTime()) ? Math.min(r.getTime(), 864e13) : 864e13
+		})
+	});
+}, _ = (t, o) => {
+	let s = g(o), l = /* @__PURE__ */ new Set(), u = 0n, d = 0n, f = 0n, p = (t) => {
+		if (typeof t != "string" || a(t).toString() !== t) throw e("invalid_record");
+		return BigInt(t);
+	};
+	for (let a of n(t, 1e5, "invalid_record")) {
+		let t = r(a, [
+			"id",
+			"debit",
+			"credit",
+			"at"
+		], "invalid_record"), n = i(t.id), m = p(t.debit), h = p(t.credit), g = c(t.at, 0, o);
+		if (l.has(n) || m === 0n == (h === 0n)) throw e("invalid_record");
+		l.add(n), f += h - m, g >= s.day.from && (u += m), g >= s.month.from && (d += m);
+	}
+	if (f < 0n) throw e("invalid_record");
+	return Object.freeze({
+		windows: s,
+		daily: u.toString(),
+		monthly: d.toString(),
+		balance: f.toString()
+	});
+}, v = (t, n, r) => {
+	let i = o(n);
+	if (!r.allowed) throw e("forbidden");
+	if (r.daily !== null && BigInt(t.daily) + i > BigInt(r.daily) || r.monthly !== null && BigInt(t.monthly) + i > BigInt(r.monthly)) throw e("limit_exceeded");
+};
+//#endregion
+export { v as assertSpendBudget, h as captureSpendLimitsOptions, p as defaultSpendLimitPolicy, f as defineSpendLimits, _ as projectSpend, m as resolveSpendBudget, g as utcSpendWindows };

package/dist/spendLimitsPort.fixture.js

@@ -0,0 +1,120 @@
+import { economyTables as e } from "./tables.entity.js";
+import { EconomyPort as t } from "./port.js";
+import { economyPlugin as n } from "./plugin.js";
+import { shopAt as r, shopMachine as i, shopUser as a } from "./shop.testFixtures.js";
+import { Effect as o, Layer as s, Result as c } from "effect";
+import { ensureTableRegistered as l } from "@voltro/database";
+import { InMemoryDataStore as u } from "@voltro/runtime";
+//#region src/spendLimitsPort.fixture.ts
+var d = {
+	app: {
+		name: "spend-fixture",
+		type: "api",
+		voltroVersion: "0.83.1"
+	},
+	config: {},
+	env: {},
+	logger: {
+		info() {},
+		warn() {},
+		error() {},
+		debug() {}
+	}
+}, f = o.gen(function* () {
+	e.forEach(l);
+	let t = new u(), s = [{
+		id: "test.gold",
+		kind: "soft"
+	}], c = n({
+		currencies: s,
+		now: () => r,
+		spendLimits: {
+			limits: [{
+				currency: "test.gold",
+				daily: "10",
+				monthly: "100"
+			}],
+			version: "fixture.spend.v1",
+			source: { read: (e) => o.succeed({
+				...e,
+				observedAt: e.at,
+				allowed: !0,
+				minor: !1
+			}) }
+		}
+	});
+	yield* o.promise(async () => {
+		await c.bindDataStore?.(t);
+	});
+	let f = a("a", "fixture");
+	return yield* c.economy.service().transfer(i, {
+		tenantId: "fixture",
+		requestId: "fund",
+		currency: "test.gold",
+		amount: "100",
+		from: {
+			kind: "system",
+			id: "fixture"
+		},
+		to: {
+			kind: "wallet",
+			ownerKind: "player",
+			ownerId: "a"
+		},
+		reason: "fixture.fund",
+		ref: {
+			kind: "fixture",
+			id: "fund"
+		}
+	}), Object.freeze({
+		store: t,
+		plugin: c,
+		currencies: s,
+		who: f,
+		close: o.suspend(() => c.onDeactivate?.(d))
+	});
+}), p = s.effectContext(o.acquireRelease(f, (e) => e.close).pipe(o.flatMap((e) => s.build(e.plugin.services)))), m = Object.freeze({
+	kind: "port",
+	tag: t,
+	fakeLayer: p,
+	probe: {
+		run: () => o.scoped(o.gen(function* () {
+			let e = yield* t, n = a("a", "fixture"), r = {
+				tenantId: "fixture",
+				requestId: "spend",
+				currency: "test.gold",
+				amount: "7",
+				from: {
+					kind: "wallet",
+					ownerKind: "player",
+					ownerId: "a"
+				},
+				to: {
+					kind: "system",
+					id: "fixture"
+				},
+				reason: "fixture.spend",
+				ref: {
+					kind: "fixture",
+					id: "spend"
+				}
+			}, s = yield* e.transfer(i, r), l = yield* e.transfer(i, r), u = yield* o.result(e.transfer(i, {
+				...r,
+				requestId: "excess",
+				amount: "4"
+			})), d = yield* e.mine(n);
+			return {
+				same: s.txId === l.txId,
+				refusal: c.isFailure(u) ? u.failure.code : "unexpected",
+				balance: d[0].balance
+			};
+		}).pipe(o.provide(p))),
+		expected: {
+			same: !0,
+			refusal: "limit_exceeded",
+			balance: "93"
+		}
+	}
+});
+//#endregion
+export { p as spendLimitsFakeLayer, f as spendLimitsPortFixture, m as spendLimitsPortSystemFixture };