@voltro/plugin-progression 0.0.0-stage → 0.87.0

package/dist/rankReader.server.js

@@ -0,0 +1,57 @@
+import { progressionError as e } from "./errors.js";
+import { captureArguments as t, identifier as n, integer as r, list as i, object as a } from "./capture.js";
+import { captureRankRating as o, defineRankLadder as s, resolveRank as c, resolveRankStrategies as l } from "./ranks.js";
+import { Effect as u } from "effect";
+//#region src/rankReader.server.ts
+var d = (t) => {
+	let n = a(t);
+	if (typeof n.myRating != "function") throw e("invalid_input");
+	let r = n.myRating;
+	return Object.freeze({ read: (n, i) => u.try({
+		try: () => r.call(t, n, i),
+		catch: () => e("unavailable")
+	}).pipe(u.flatten, u.mapError(() => e("unavailable")), u.flatMap((t) => u.try({
+		try: () => o(t, i),
+		catch: () => e("invalid_record")
+	}))) });
+}, f = (d) => {
+	let f = a(d, [
+		"ladders",
+		"source",
+		"strategies",
+		"now"
+	]), p = Object.freeze(i(f.ladders, 64).map((e) => s(e))), m = a(f.source), h = f.now ?? Date.now, g = l(f.strategies);
+	if (!p.length || new Set(p.map((e) => e.id)).size !== p.length || typeof m.read != "function" || typeof h != "function") throw e("invalid_input");
+	let _ = m.read, v = h;
+	return Object.freeze({ mine: (i) => {
+		try {
+			let a = t(i);
+			if (a.type !== "user") throw e("forbidden");
+			return n(a.id), n(a.tenantId), u.gen(function* () {
+				let t = /* @__PURE__ */ new Map();
+				for (let n of p) t.has(n.rating) || t.set(n.rating, yield* u.flatMap(u.try({
+					try: () => _.call(m, a, n.rating),
+					catch: () => e("unavailable")
+				}).pipe(u.flatten), (t) => u.try({
+					try: () => o(t, n.rating),
+					catch: () => e("invalid_record")
+				})));
+				return yield* u.try({
+					try: () => {
+						let e = r(v(), 0, 864e13);
+						return Object.freeze(p.map((n) => c({
+							ladder: n,
+							rating: t.get(n.rating),
+							at: e
+						}, g)));
+					},
+					catch: () => e("invalid_record")
+				});
+			});
+		} catch {
+			return u.fail(e("forbidden"));
+		}
+	} });
+};
+//#endregion
+export { f as makeRankReader, d as ratingSourceFromLeaderboards };

package/dist/rankRewardParent.server.js

@@ -0,0 +1,65 @@
+import { progressionError as e } from "./errors.js";
+import { identifier as t, integer as n, object as r } from "./capture.js";
+import { capturePlayerRank as i, captureRankRating as a, defineRankLadder as o } from "./ranks.js";
+import { captureReward as s } from "./reward.js";
+import { acceptRankObservation as c, closeRankSeasonState as l, defineRankSeason as u, initialRankSeasonState as d } from "./rankSeasons.js";
+import { questHash as f } from "./questStore.js";
+import { rankDefinitionsTable as p, rankLedgerTable as m, rankOperationsTable as h } from "./rankTables.entity.js";
+import { and as g, eq as _, queryFor as v } from "@voltro/database";
+//#region src/rankRewardParent.server.ts
+var y = (e, ...t) => e + f(t).slice(0, 56), b = (e) => n(e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN, 0, 864e13), x = async (x, S, C, w, T) => {
+	let E = r(w.receipt, [
+		"operationId",
+		"kind",
+		"after",
+		"rewardsQueued",
+		"at"
+	]), D = t(S.seasonId), O = n(r(E.after).version, 1, 1e6), k = b(S.createdAt), A = (await x.query(v(p).where(_("id", y("prd_", C.tenantId, D, String(O)))).limit(1).descriptor))[0];
+	if (!A || A.tenantId !== C.tenantId || A.seasonId !== D || E.kind !== "close" || E.at !== k) throw e("invalid_record");
+	let j = r(A.config, ["season", "ladder"]), M = o(j.ladder), N = u(j.season, M), P = t(A.rulesVersion);
+	if (N.id !== D || N.version !== O) throw e("invalid_record");
+	let F = await x.query(v(m).where(g(_("tenantId", C.tenantId), _("ownerKey", C.ownerKey), _("seasonId", D))).orderBy("sequence", "asc").limit(100001).descriptor), I = await x.query(v(h).where(g(_("tenantId", C.tenantId), _("ownerKey", C.ownerKey))).limit(100001).descriptor);
+	if (!F.length || F.length > 1e5 || I.length > 1e5) throw e("limit_exceeded");
+	let L = new Map(I.map((e) => [String(e.id), e])), R = /* @__PURE__ */ new Set(), z = d(N), B = 0, V = null;
+	for (let o of F) {
+		let s = r(o.intent, [
+			"request",
+			"rating",
+			"rank",
+			"resetScore"
+		]), u = r(s.request, [
+			"seasonId",
+			"kind",
+			"requestId"
+		]), d = b(o.at), p = t(o.operationId), m = L.get(p);
+		if (o.tenantId !== C.tenantId || o.ownerId !== C.ownerId || o.ownerKey !== C.ownerKey || o.seasonId !== D || u.seasonId !== D || u.kind !== "observe" && u.kind !== "close" || o.id !== y("prl_", p) || p !== y("pro_", C.tenantId, C.ownerId, t(u.requestId)) || !m || m.state !== "committed" || m.linkedOperationId !== null || m.tenantId !== C.tenantId || m.ownerKey !== C.ownerKey || m.digest !== f({
+			tenant: C.tenantId,
+			owner: C.ownerId,
+			request: u
+		}) || f(m.intent) !== f(u) || f(o.before) !== f(z)) throw e("invalid_record");
+		B = n(o.sequence, B + 1, n(T, 1, 2147483647));
+		let h;
+		if (u.kind === "observe") {
+			let t = a(s.rating, M.rating), n = i(s.rank, M, P);
+			if (s.resetScore !== null || n.games !== t.games || n.ratingUpdatedAt !== t.updatedAt || n.observedAt !== d) throw e("invalid_record");
+			h = y("pri_", C.tenantId, C.ownerId, D, "observe", f(t)), z = c(N, M, z, n, P);
+		} else {
+			if (s.rating !== null || s.rank !== null) throw e("invalid_record");
+			h = y("pri_", C.tenantId, C.ownerId, D, "close", ""), z = l(N, M, z, d, s.resetScore, P), V = p;
+		}
+		let g = r(m.receipt, [
+			"operationId",
+			"kind",
+			"after",
+			"rewardsQueued",
+			"at"
+		]), _ = u.kind === "close" && z.highest ? N.rewards[z.highest.tierIndex].length : 0;
+		if (o.claimKey !== h || m.claimKey !== h || R.has(h) || f(o.after) !== f(z) || f(g.after) !== f(z) || g.operationId !== p || g.kind !== u.kind || g.at !== d || b(m.at) !== d || g.rewardsQueued !== _) throw e("invalid_record");
+		R.add(h);
+	}
+	if (V !== w.id || !z.highest || z.closedAt !== k || f(E.after) !== f(z)) throw e("invalid_record");
+	let H = N.rewards[z.highest.tierIndex], U = H.findIndex((e, n) => y("prr_", t(w.id), String(n)) === S.id);
+	if (U < 0 || E.rewardsQueued !== H.length || f(s(S.reward)) !== f(H[U])) throw e("invalid_record");
+};
+//#endregion
+export { x as admitRankRewardParent };

package/dist/rankSeasons.d.ts

@@ -0,0 +1,144 @@
+import { Context } from 'effect';
+import { Effect } from 'effect';
+import { PluginPrivacyTarget } from '@voltro/protocol';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
+
+export declare const acceptRankObservation: (season: RankSeason, ladder: RankLadder, beforeInput: RankSeasonState, rankInput: PlayerRank, rulesVersion: string) => RankSeasonState;
+
+export declare const captureRankSeasonState: (input: unknown, season: RankSeason, ladder: RankLadder, rulesVersion: string) => RankSeasonState;
+
+export declare const closeRankSeasonState: (season: RankSeason, ladder: RankLadder, beforeInput: RankSeasonState, at: number, resetScore: number | null, rulesVersion: string) => RankSeasonState;
+
+export declare const defineRankSeason: (input: RankSeasonDefinition | RankSeason, ladder: RankLadder) => RankSeason;
+
+export declare const initialRankSeasonState: (season: RankSeason) => RankSeasonState;
+
+declare interface PlayerRank {
+    readonly ladderId: string;
+    readonly version: number;
+    readonly pool: string;
+    readonly games: number;
+    readonly placementsRemaining: number;
+    readonly rawScore: number;
+    readonly score: number;
+    readonly grade: RankGrade | null;
+    readonly ratingUpdatedAt: number | null;
+    readonly observedAt: number;
+    readonly rulesVersion: string;
+}
+
+declare class ProgressionError extends ProgressionError_base {
+}
+
+declare const ProgressionError_base: Schema.Class<ProgressionError, Schema.TaggedStruct<"ProgressionError", {
+    readonly code: Schema.Literals<readonly ["invalid_input", "invalid_record", "invalid_curve", "invalid_reward", "invalid_track", "invalid_stat", "overflow", "insufficient_resource", "forbidden", "conflict", "erased", "not_found", "limit_exceeded", "unavailable"]>;
+}>, YieldableError>;
+
+declare type ProgressionReward = {
+    readonly kind: 'currency';
+    readonly currency: string;
+    readonly amount: string;
+} | {
+    readonly kind: 'item';
+    readonly itemId: string;
+    readonly qty: number;
+} | {
+    readonly kind: 'xp';
+    readonly trackId: string;
+    readonly amount: string;
+};
+
+export declare interface RankCloseInput extends RankObserveInput {
+    readonly tenantId: string;
+    readonly ownerId: string;
+}
+
+declare interface RankDecayDefinition {
+    readonly afterDays: number;
+    readonly perDay: number;
+    readonly floor: number;
+}
+
+declare interface RankGrade {
+    readonly index: number;
+    readonly tier: string;
+    readonly tierIndex: number;
+    readonly division: number;
+}
+
+declare interface RankLadder {
+    readonly id: string;
+    readonly version: number;
+    readonly rating: string;
+    readonly tiers: readonly string[];
+    readonly divisions: number;
+    readonly thresholds: readonly number[];
+    readonly placements: number;
+    readonly confidence: number;
+    readonly decay: RankDecayDefinition | null;
+    readonly softReset: RankResetDefinition | null;
+}
+
+export declare interface RankObserveInput {
+    readonly seasonId: string;
+    readonly requestId: string;
+}
+
+export declare class RankPort extends RankPort_base {
+}
+
+declare const RankPort_base: Context.ServiceClass<RankPort, "@voltro/RankPort", RankSeasonService>;
+
+declare interface RankResetDefinition {
+    readonly target: number;
+    readonly retain: number;
+}
+
+export declare interface RankSeason {
+    readonly id: string;
+    readonly version: number;
+    readonly ladderId: string;
+    readonly from: number;
+    readonly until: number;
+    readonly rewards: readonly (readonly ProgressionReward[])[];
+}
+
+export declare interface RankSeasonDefinition {
+    readonly id: string;
+    readonly version?: number;
+    readonly ladderId: string;
+    readonly from: number;
+    readonly until: number;
+    readonly rewards: readonly (readonly ProgressionReward[])[];
+}
+
+export declare interface RankSeasonReceipt {
+    readonly operationId: string;
+    readonly kind: 'observe' | 'close';
+    readonly after: RankSeasonState;
+    readonly rewardsQueued: number;
+    readonly at: number;
+}
+
+export declare interface RankSeasonService {
+    readonly observe: (subject: Subject, input: RankObserveInput) => Effect.Effect<RankSeasonReceipt, ProgressionError>;
+    readonly close: (subject: Subject, input: RankCloseInput) => Effect.Effect<RankSeasonReceipt, ProgressionError>;
+    readonly mine: (subject: Subject) => Effect.Effect<readonly RankSeasonState[], ProgressionError>;
+    readonly exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, ProgressionError>;
+    readonly eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, ProgressionError>;
+}
+
+export declare interface RankSeasonState {
+    readonly seasonId: string;
+    readonly version: number;
+    readonly ladderId: string;
+    readonly observations: number;
+    readonly last: PlayerRank | null;
+    readonly highest: RankGrade | null;
+    readonly closedAt: number | null;
+    readonly resetScore: number | null;
+}
+
+export { }

package/dist/rankSeasons.js

@@ -0,0 +1,91 @@
+import { progressionError as e } from "./errors.js";
+import { identifier as t, integer as n, list as r, object as i } from "./capture.js";
+import { capturePlayerRank as a } from "./ranks.js";
+import { captureRewards as o } from "./reward.js";
+import { Context as s } from "effect";
+//#region src/rankSeasons.ts
+var c = (a, s) => {
+	let c = i(a, [
+		"id",
+		"version",
+		"ladderId",
+		"from",
+		"until",
+		"rewards"
+	]), l = n(c.from, 0, 864e13 - 1), u = n(c.until, l + 1, 864e13), d = Object.freeze(r(c.rewards, s.tiers.length).map((e) => o(e, 64)));
+	if (c.ladderId !== s.id || d.length !== s.tiers.length) throw e("invalid_input");
+	return Object.freeze({
+		id: t(c.id),
+		version: n(c.version ?? 1, 1, 1e6),
+		ladderId: s.id,
+		from: l,
+		until: u,
+		rewards: d
+	});
+}, l = (e) => Object.freeze({
+	seasonId: e.id,
+	version: e.version,
+	ladderId: e.ladderId,
+	observations: 0,
+	last: null,
+	highest: null,
+	closedAt: null,
+	resetScore: null
+}), u = (t, r, o, s) => {
+	let c = i(t, [
+		"seasonId",
+		"version",
+		"ladderId",
+		"observations",
+		"last",
+		"highest",
+		"closedAt",
+		"resetScore"
+	]), l = n(c.observations, 0, 2147483647);
+	if (c.seasonId !== r.id || c.version !== r.version || c.ladderId !== o.id) throw e("invalid_record");
+	let u = c.last === null ? null : a(c.last, o, s), d = c.closedAt === null ? null : n(c.closedAt, r.until, 864e13);
+	if (!!l != (u !== null) || u && (u.observedAt < r.from || u.observedAt >= r.until)) throw e("invalid_record");
+	let f = null;
+	if (c.highest !== null) {
+		if (!u || (f = a({
+			...u,
+			games: Math.max(u.games, o.placements),
+			placementsRemaining: 0,
+			ratingUpdatedAt: u.ratingUpdatedAt ?? u.observedAt,
+			grade: c.highest
+		}, o, s).grade, u.grade && f.index < u.grade.index)) throw e("invalid_record");
+	} else if (u?.grade) throw e("invalid_record");
+	if (u && u.placementsRemaining > 0 && f !== null) throw e("invalid_record");
+	let p = c.resetScore === null ? null : c.resetScore;
+	if (p !== null && (d === null || u === null || typeof p != "number" || !Number.isFinite(p) || Math.abs(p) > 1e9 || Object.is(p, -0)) || d !== null && u !== null && p === null) throw e("invalid_record");
+	return Object.freeze({
+		seasonId: r.id,
+		version: r.version,
+		ladderId: o.id,
+		observations: l,
+		last: u,
+		highest: f,
+		closedAt: d,
+		resetScore: p
+	});
+}, d = (t, r, i, o, s) => {
+	let c = u(i, t, r, s), l = a(o, r, s);
+	if (c.closedAt !== null || l.observedAt < t.from || l.observedAt >= t.until || c.last && (l.observedAt < c.last.observedAt || l.games < c.last.games || (l.ratingUpdatedAt ?? 0) < (c.last.ratingUpdatedAt ?? 0))) throw e("conflict");
+	let d = l.grade && (c.highest === null || l.grade.index > c.highest.index) ? l.grade : c.highest;
+	return u({
+		...c,
+		observations: n(c.observations + 1, 1, 2147483647),
+		last: l,
+		highest: d
+	}, t, r, s);
+}, f = (t, r, i, a, o, s) => {
+	let c = u(i, t, r, s);
+	if (c.closedAt !== null) throw e("conflict");
+	return u({
+		...c,
+		closedAt: n(a, t.until, 864e13),
+		resetScore: o
+	}, t, r, s);
+}, p = class extends s.Service()("@voltro/RankPort") {};
+//#endregion
+export { p as RankPort, d as acceptRankObservation, u as captureRankSeasonState, f as closeRankSeasonState, c as defineRankSeason, l as initialRankSeasonState };