@voltro/plugin-leaderboards 0.0.0-stage → 0.87.0

package/dist/testing.js

@@ -0,0 +1,368 @@
+import { leaderboardError as e } from "./errors.js";
+import { applyScore as t } from "./score.js";
+import { elo as ee } from "./rating.js";
+import { resolveRatingPools as n } from "./ratingPools.js";
+import { defaultRatingDecay as r, defaultRatingPlacement as i, defaultRatingRate as a } from "./ratingStrategies.js";
+import { defaultLeaderboardTiebreak as o, defaultPeriodSummary as s, hashBucket as c, rankLeaderboardRecords as l } from "./ranking.js";
+import { defaultLeaderboardBucketAssign as u } from "./buckets.js";
+import { defaultLeaderboardRankQuery as d } from "./rankQuery.js";
+import { acceptLeaderboardSubmission as f } from "./service.js";
+import { TournamentBracketPort as p } from "./bracketMatchPorts.js";
+import { TournamentStagePort as m } from "./tournamentStagePorts.js";
+import { BracketAdmissionPort as h } from "./ports.js";
+import { advanceDoubleElimination as g, advanceSingleElimination as _, roundRobin as v, seedDoubleElimination as y, seedSingleElimination as te, swissPairings as ne } from "./brackets.js";
+import { Effect as b, Layer as x, Result as S } from "effect";
+import { systemSubject as C } from "@voltro/protocol";
+//#region src/testing.ts
+var w = (e = "player") => ({
+	id: "record-" + e,
+	tenantId: "tenant",
+	board: "weekly",
+	periodId: "period",
+	ownerId: e,
+	score: "100",
+	subscore: "0",
+	updatedAt: 1e3
+}), T = {
+	record: w,
+	applyScore: t,
+	tiebreak: o,
+	periodSummary: s,
+	hashBucket: c
+}, E = () => ({
+	rate: ee(),
+	input: {
+		teams: [[{
+			id: "a",
+			rating: 1e3
+		}], [{
+			id: "b",
+			rating: 1e3
+		}]],
+		ranks: [1, 2]
+	}
+}), D = (e) => ({
+	rankQuery: d,
+	context: Object.freeze({
+		tenantId: "tenant",
+		board: "weekly",
+		periodId: "period",
+		bucketId: null,
+		sort: "desc",
+		maxRecords: 10,
+		records: Object.freeze([Object.freeze({
+			...w("a"),
+			score: "9007199254740993"
+		}), Object.freeze({
+			...w("b"),
+			score: "9007199254740994"
+		})]),
+		tiebreak: o,
+		query: e
+	})
+}), O = () => {
+	let e = n([{
+		name: "duels",
+		algorithm: "elo"
+	}])[0];
+	return {
+		rate: a,
+		placementPolicy: i,
+		decay: r,
+		context: Object.freeze({
+			tenantId: "tenant",
+			matchId: "match",
+			pool: e,
+			at: 1e3,
+			teams: Object.freeze(["a", "b"].map((t) => Object.freeze([Object.freeze({
+				ownerId: t,
+				state: e.initial,
+				games: 0,
+				updatedAt: null,
+				weight: 1
+			})]))),
+			ranks: Object.freeze([1, 2])
+		})
+	};
+}, k = () => ({
+	bucketAssign: u,
+	context: Object.freeze({
+		tenantId: "tenant",
+		board: "weekly",
+		periodId: "period",
+		ownerId: "a",
+		assign: "hash",
+		size: 2,
+		group: null,
+		candidates: Object.freeze([Object.freeze({
+			id: "bucket-one",
+			ordinal: 0,
+			entries: 1
+		}), Object.freeze({
+			id: "bucket-two",
+			ordinal: 1,
+			entries: 1
+		})])
+	})
+}), re = () => {
+	let e = Object.freeze(Array.from({ length: 4 }, (e, t) => Object.freeze({
+		entrantId: `p${t + 1}`,
+		seed: t + 1
+	})));
+	return Object.freeze({
+		entrants: e,
+		standings: Object.freeze(e.map((e) => Object.freeze({
+			...e,
+			points: 0,
+			byes: 0,
+			opponents: Object.freeze([])
+		}))),
+		roundRobin: v,
+		swissPairings: ne,
+		seedSingleElimination: te,
+		advanceSingleElimination: _,
+		seedDoubleElimination: y,
+		advanceDoubleElimination: g
+	});
+}, A = (t = {}) => ({
+	create: () => b.fail(e("unavailable")),
+	register: () => b.fail(e("unavailable")),
+	checkIn: () => b.fail(e("unavailable")),
+	status: () => b.fail(e("unavailable")),
+	seal: () => b.fail(e("unavailable")),
+	entrants: () => b.fail(e("unavailable")),
+	exportSubject: () => b.fail(e("unavailable")),
+	eraseSubject: () => b.fail(e("unavailable")),
+	...t
+}), j = (e = {}) => x.succeed(h, A(e)), M = () => {
+	let e = j();
+	return {
+		kind: "port",
+		tag: h,
+		fakeLayer: e,
+		probe: {
+			run: () => b.runPromise(b.flatMap(h, (e) => e.seal(C("fixture"), {
+				tenantId: "tenant",
+				tournamentId: "tournament"
+			})).pipe(b.result, b.map((e) => S.isFailure(e) ? e.failure.code : "unexpected-success"), b.provide(e))),
+			expected: "unavailable"
+		}
+	};
+}, N = (t = {}) => ({
+	create: () => b.fail(e("unavailable")),
+	report: () => b.fail(e("unavailable")),
+	dispute: () => b.fail(e("unavailable")),
+	resolve: () => b.fail(e("unavailable")),
+	advance: () => b.fail(e("unavailable")),
+	status: () => b.fail(e("unavailable")),
+	exportSubject: () => b.fail(e("unavailable")),
+	eraseSubject: () => b.fail(e("unavailable")),
+	...t
+}), P = (e = {}) => x.succeed(p, N(e)), F = () => {
+	let e = P();
+	return {
+		kind: "port",
+		tag: p,
+		fakeLayer: e,
+		probe: {
+			run: () => b.runPromise(b.flatMap(p, (e) => e.status(C("fixture"), {
+				tenantId: "tenant",
+				tournamentId: "tournament"
+			})).pipe(b.result, b.map((e) => S.isFailure(e) ? e.failure.code : "unexpected-success"), b.provide(e))),
+			expected: "unavailable"
+		}
+	};
+}, I = (t = {}) => ({
+	window: () => b.fail(e("unavailable")),
+	notify: () => b.fail(e("unavailable")),
+	seed: () => b.fail(e("unavailable")),
+	...t
+}), L = (e = {}) => x.succeed(m, I(e)), R = () => {
+	let e = L();
+	return {
+		kind: "port",
+		tag: m,
+		fakeLayer: e,
+		probe: {
+			run: () => b.runPromise(b.flatMap(m, (e) => e.window(C("fixture"), {
+				tenantId: "tenant",
+				tournamentId: "tournament",
+				runKey: "run",
+				format: "single-elimination",
+				ruleVersion: "studio:rules:1"
+			})).pipe(b.result, b.map((e) => S.isFailure(e) ? e.failure.code : "unexpected-success"), b.provide(e))),
+			expected: "unavailable"
+		}
+	};
+}, z = [{
+	...w("a"),
+	subscore: "1"
+}, {
+	...w("b"),
+	subscore: "2"
+}], B = [
+	w("a"),
+	null,
+	void 0
+], V = (e) => e.map((e) => e.ownerId), H = (e) => b.map(b.result(e), (e) => S.isFailure(e) ? e.failure.code : "unexpected-success"), U = Object.freeze({
+	kind: "slot",
+	defaultImplementation: o,
+	defaultProbe: {
+		run: () => b.sync(() => V(l(z))),
+		expected: ["b", "a"]
+	},
+	overrideProbe: {
+		run: () => b.sync(() => V(l(z, { tiebreak: (e, t) => e.ownerId < t.ownerId ? -1 : 1 }))),
+		expected: ["a", "b"]
+	}
+}), W = Object.freeze({
+	kind: "slot",
+	defaultImplementation: s,
+	defaultProbe: {
+		run: () => b.sync(() => s(l(z)).participants),
+		expected: 2
+	},
+	overrideProbe: {
+		run: () => b.sync(() => ((e) => ({
+			participants: e.length * 10,
+			top: []
+		}))(l(z)).participants),
+		expected: 20
+	}
+}), G = Object.freeze({
+	kind: "slot",
+	defaultImplementation: d,
+	defaultProbe: {
+		run: () => {
+			let e = D(() => Promise.resolve([]));
+			return e.rankQuery(e.context);
+		},
+		expected: ["record-b", "record-a"]
+	},
+	overrideProbe: {
+		run: () => {
+			let e = D(() => Promise.resolve([]));
+			return b.succeed(e.context.records.map((e) => e.id));
+		},
+		expected: ["record-a", "record-b"]
+	}
+}), K = Object.freeze({
+	kind: "slot",
+	defaultImplementation: u,
+	defaultProbe: {
+		run: () => b.sync(() => {
+			let e = k();
+			return e.bucketAssign(e.context);
+		}),
+		expected: "bucket-two"
+	},
+	overrideProbe: {
+		run: () => b.sync(() => k().context.candidates[0].id),
+		expected: "bucket-one"
+	}
+}), q = Object.freeze({
+	kind: "slot",
+	defaultImplementation: f,
+	defaultProbe: {
+		run: () => b.as(f(...B), "accepted"),
+		expected: "accepted"
+	},
+	overrideProbe: {
+		run: () => H(b.fail(e("invalid_input"))),
+		expected: "invalid_input"
+	}
+}), J = Object.freeze({
+	kind: "slot",
+	defaultImplementation: a,
+	defaultProbe: {
+		run: () => b.sync(() => {
+			let e = O();
+			return e.rate(e.context).map((e) => e.ownerId);
+		}),
+		expected: ["a", "b"]
+	},
+	overrideProbe: {
+		run: () => b.sync(() => [...O().context.teams].reverse().flatMap((e) => e.map((e) => e.ownerId))),
+		expected: ["b", "a"]
+	}
+}), Y = Object.freeze({
+	kind: "slot",
+	defaultImplementation: i,
+	defaultProbe: {
+		run: () => b.sync(() => {
+			let { context: e } = O();
+			return i({
+				tenantId: e.tenantId,
+				ownerId: "a",
+				pool: e.pool,
+				at: e.at
+			});
+		}),
+		expected: O().context.pool.initial
+	},
+	overrideProbe: {
+		run: () => b.sync(() => ({ placed: !0 })),
+		expected: { placed: !0 }
+	}
+}), ie = Object.freeze({
+	kind: "slot",
+	defaultImplementation: r,
+	defaultProbe: {
+		run: () => b.sync(() => {
+			let { context: e } = O();
+			return r({
+				tenantId: e.tenantId,
+				ownerId: "a",
+				pool: e.pool,
+				at: e.at,
+				state: e.pool.initial,
+				games: 3,
+				updatedAt: 0,
+				elapsedMs: 1e3
+			});
+		}),
+		expected: O().context.pool.initial
+	},
+	overrideProbe: {
+		run: () => b.sync(() => ({ decayed: !0 })),
+		expected: { decayed: !0 }
+	}
+}), X = j(), Z = P(), Q = L(), $ = C("leaderboards.system.fixture"), ae = Object.freeze({
+	kind: "port",
+	tag: h,
+	fakeLayer: X,
+	probe: {
+		run: () => H(b.flatMap(h, (e) => e.seal($, {
+			tenantId: "tenant",
+			tournamentId: "tournament"
+		}))).pipe(b.provide(X)),
+		expected: "unavailable"
+	}
+}), oe = Object.freeze({
+	kind: "port",
+	tag: p,
+	fakeLayer: Z,
+	probe: {
+		run: () => H(b.flatMap(p, (e) => e.status($, {
+			tenantId: "tenant",
+			tournamentId: "tournament"
+		}))).pipe(b.provide(Z)),
+		expected: "unavailable"
+	}
+}), se = Object.freeze({
+	kind: "port",
+	tag: m,
+	fakeLayer: Q,
+	probe: {
+		run: () => H(b.flatMap(m, (e) => e.window($, {
+			tenantId: "tenant",
+			tournamentId: "tournament",
+			runKey: "run",
+			format: "single-elimination",
+			ruleVersion: "studio:rules:1"
+		}))).pipe(b.provide(Q)),
+		expected: "unavailable"
+	}
+});
+//#endregion
+export { j as bracketAdmissionFakeLayer, M as bracketAdmissionPortFixture, ae as bracketAdmissionPortSystemFixture, X as bracketAdmissionSystemFakeLayer, K as bucketAssignSystemFixture, E as eloFixture, A as fakeBracketAdmissionService, N as fakeTournamentBracketService, I as fakeTournamentStageService, k as leaderboardBucketAssignFixture, T as leaderboardPureFixture, D as leaderboardRankQueryFixture, w as leaderboardRecordFixture, W as periodSummarySystemFixture, G as rankQuerySystemFixture, ie as ratingDecaySystemFixture, Y as ratingPlacementSystemFixture, J as ratingRateSystemFixture, O as ratingStrategiesFixture, U as tiebreakSystemFixture, P as tournamentBracketFakeLayer, F as tournamentBracketPortFixture, oe as tournamentBracketPortSystemFixture, Z as tournamentBracketSystemFakeLayer, re as tournamentPairingFixture, L as tournamentStageFakeLayer, R as tournamentStagePortFixture, se as tournamentStagePortSystemFixture, Q as tournamentStageSystemFakeLayer, q as validateSystemFixture };

package/dist/tournament-app/tournament.advance.workflow.server.tsx

@@ -0,0 +1,3 @@
+import type { AppContext } from '@voltro/runtime'
+import { tournamentAdvanceExecutor } from '@voltro/plugin-leaderboards/server'
+export default (context: AppContext): ReturnType<typeof tournamentAdvanceExecutor> => tournamentAdvanceExecutor(context)

package/dist/tournament-app/tournament.advance.workflow.tsx

@@ -0,0 +1,12 @@
+import { workflow } from '@voltro/workflow/define'
+import { TournamentAdvancePayload, TournamentWorkflowSummary } from '@voltro/plugin-leaderboards/rpc'
+import { LeaderboardError } from '@voltro/plugin-leaderboards/errors'
+
+export const TournamentAdvance = workflow({ name: 'tournament.advance', payload: TournamentAdvancePayload,
+  success: TournamentWorkflowSummary, error: LeaderboardError, internal: true,
+  controls: { guards: [{ scope: 'tournaments:operate' }] },
+  idempotencyKey: payload => 'tournament.advance:' + JSON.stringify([payload.tenantId, payload.tournamentId, payload.runKey]),
+  // One run per tournament at a time; a start during a run waits and then drains what that run
+  // could not see, so no result is left without its next Room.
+  concurrency: { limit: 1, key: payload => JSON.stringify([payload.tenantId, payload.tournamentId]) },
+})

package/dist/tournament-app/tournament.stage.workflow.server.tsx

@@ -0,0 +1,3 @@
+import type { AppContext } from '@voltro/runtime'
+import { tournamentStageExecutor } from '@voltro/plugin-leaderboards/server'
+export default (context: AppContext): ReturnType<typeof tournamentStageExecutor> => tournamentStageExecutor(context)

package/dist/tournament-app/tournament.stage.workflow.tsx

@@ -0,0 +1,10 @@
+import { workflow } from '@voltro/workflow/define'
+import { TournamentStagePayload, TournamentWorkflowSummary } from '@voltro/plugin-leaderboards/rpc'
+import { LeaderboardError } from '@voltro/plugin-leaderboards/errors'
+
+export const TournamentStage = workflow({ name: 'tournament.stage', payload: TournamentStagePayload,
+  success: TournamentWorkflowSummary, error: LeaderboardError, internal: true,
+  controls: { guards: [{ scope: 'tournaments:operate' }] },
+  idempotencyKey: payload => 'tournament.stage:' + JSON.stringify([payload.tenantId, payload.tournamentId, payload.runKey, payload.format, payload.ruleVersion]),
+  singleton: { key: payload => JSON.stringify([payload.tenantId, payload.tournamentId]), mode: 'skip' },
+})

package/dist/tournamentInstallation.js

@@ -0,0 +1,168 @@
+import { leaderboardError as e } from "./errors.js";
+import { captureLeaderboardJson as t } from "./json.js";
+import { dataStoreTournamentBrackets as n, resolveTournamentBracketOptions as r } from "./bracketMatches.js";
+import { dataStoreTournamentStages as i, resolveTournamentStageOptions as a } from "./tournamentStage.js";
+import { assertPortBindingKeys as o, capturePortMethods as s, capturePortPrivacyRequest as c, capturePortSources as l, capturePortSubject as u, capturePortVersion as d, invalidPortBinding as f, makeLeaderboardPortLifetime as p } from "./portLifetime.js";
+import { Effect as m } from "effect";
+import { fileURLToPath as h } from "node:url";
+import { isAbsolute as g } from "node:path";
+//#region src/tournamentInstallation.ts
+var _ = [
+	"create",
+	"report",
+	"dispute",
+	"resolve",
+	"advance",
+	"status",
+	"exportSubject",
+	"eraseSubject"
+], v = [
+	"window",
+	"notify",
+	"seed"
+], y = (y, b, x) => {
+	let S = p(), C = p(), w = S.call, T = C.call, E = Object.freeze({
+		create: (e, n, r) => w(() => {
+			let i = u(e), a = t(n, 1024), o = t(r, 16384);
+			return (e) => e.create(i, a, o);
+		}),
+		report: (e, n, r) => w(() => {
+			let i = u(e), a = t(n, 1024), o = t(r, 2048);
+			return (e) => e.report(i, a, o);
+		}),
+		dispute: (e, n, r) => w(() => {
+			let i = u(e), a = t(n, 1024), o = t(r, 2048);
+			return (e) => e.dispute(i, a, o);
+		}),
+		resolve: (e, n, r) => w(() => {
+			let i = u(e), a = t(n, 1024), o = t(r, 2048);
+			return (e) => e.resolve(i, a, o);
+		}),
+		advance: (e, n) => w(() => {
+			let r = u(e), i = t(n, 1024);
+			return (e) => e.advance(r, i);
+		}),
+		status: (e, n) => w(() => {
+			let r = u(e), i = t(n, 1024);
+			return (e) => e.status(r, i);
+		}),
+		exportSubject: (e) => w(() => {
+			let t = c(e);
+			return (e) => e.exportSubject(t);
+		}),
+		eraseSubject: (e) => w(() => {
+			let t = c(e);
+			return (e) => e.eraseSubject(t);
+		})
+	}), D = Object.freeze({
+		window: (e, n) => T(() => {
+			let r = u(e), i = t(n, 2048);
+			return (e) => e.window(r, i);
+		}),
+		notify: (e, n, r) => T(() => {
+			let i = u(e), a = t(n, 2048);
+			return (e) => e.notify(i, a, r);
+		}),
+		seed: (e, n) => T(() => {
+			let r = u(e), i = t(n, 2048);
+			return (e) => e.seed(r, i);
+		})
+	}), O, k, A, j, M, N = null, P = Object.freeze([]), F;
+	if (y !== void 0) {
+		o(y, ["backend"], [
+			"options",
+			"version",
+			"service",
+			"sources",
+			"stage",
+			"workflowSources"
+		]);
+		let e, t;
+		y.backend === "sql" ? (o(y, ["backend", "options"], ["stage", "workflowSources"]), O = r(y.options), e = "voltro:tournament-brackets:1", t = O.maxTenantTournaments, P = Object.freeze(["_voltro_brackets"])) : y.backend === "custom" ? (o(y, [
+			"backend",
+			"version",
+			"service",
+			"sources"
+		], ["stage", "workflowSources"]), e = d(y.version), t = null, k = s(y.service, _), P = l(y.sources)) : f();
+		let n = null;
+		if (y.stage !== void 0) {
+			let e = y.stage;
+			o(e, ["backend", "privacy"], [
+				"options",
+				"version",
+				"service"
+			]), M = s(e.privacy, ["exportSubject", "eraseSubject"]), e.backend === "sql" ? (o(e, [
+				"backend",
+				"options",
+				"privacy"
+			]), x !== "sql" && f(), o(e.options, [
+				"epochNow",
+				"authorize",
+				"seedRoster",
+				"notifyEntrants"
+			]), A = a({
+				...e.options,
+				admissions: b,
+				brackets: E
+			}), n = Object.freeze({
+				backend: "sql",
+				version: "voltro:tournament-stage:1"
+			})) : e.backend === "custom" ? (o(e, [
+				"backend",
+				"version",
+				"service",
+				"privacy"
+			]), j = s(e.service, v), n = Object.freeze({
+				backend: "custom",
+				version: d(e.version)
+			})) : f();
+		}
+		n === null && y.workflowSources !== void 0 && f(), y.workflowSources !== void 0 && (typeof y.workflowSources != "string" || !g(y.workflowSources) || y.workflowSources.includes("\0")) && f(), F = n === null ? void 0 : y.workflowSources ?? h(new URL("./tournament-app", "" + import.meta.url)), N = Object.freeze({
+			backend: y.backend,
+			version: e,
+			maxTenantTournaments: t,
+			stage: n,
+			workflowSource: n === null ? null : y.workflowSources === void 0 ? "default" : "custom"
+		});
+	}
+	let I = M;
+	return Object.freeze({
+		configuration: N,
+		sources: P,
+		sourceRoot: F,
+		service: E,
+		stageService: D,
+		isBound: S.isBound,
+		isStageBound: C.isBound,
+		bind: (e, t) => {
+			let r = O === void 0 ? k : n(e, O);
+			A !== void 0 && (r === void 0 || t === void 0) && f();
+			let a = A === void 0 ? j : i(e, {
+				...A,
+				admissions: t,
+				brackets: r
+			});
+			r !== void 0 && S.bind(r), a !== void 0 && C.bind(a);
+		},
+		exportStageSubject: (n) => T(() => {
+			let r = c(n);
+			return () => I.exportSubject(r).pipe(m.flatMap((n) => m.try({
+				try: () => t(n, 65536),
+				catch: () => e("unavailable")
+			})));
+		}),
+		eraseStageSubject: (e) => T(() => {
+			let t = c(e);
+			return () => I.eraseSubject(t);
+		}),
+		close: () => {
+			C.close(), S.close();
+		},
+		awaitIdle: () => m.all([C.awaitIdle(), S.awaitIdle()], {
+			concurrency: "unbounded",
+			discard: !0
+		})
+	});
+};
+//#endregion
+export { y as makeTournamentInstallation };

package/dist/tournamentPrizes.js

@@ -0,0 +1,34 @@
+import { leaderboardError as e } from "./errors.js";
+import { Effect as t } from "effect";
+import { systemSubject as n } from "@voltro/protocol";
+import { createHash as r } from "node:crypto";
+//#region src/tournamentPrizes.ts
+var i = (r, i) => {
+	if (!r || typeof r.inbox != "function" || !i || typeof i.templateId != "string" || !i.templateId || i.expiresInMs !== void 0 && (!Number.isSafeInteger(i.expiresInMs) || i.expiresInMs < 1)) throw e("invalid_input");
+	let a = Object.freeze([...i.attachments ?? []].map((e) => Object.freeze({ ...e }))), o = i.now ?? Date.now, s = n("tournament-prizes");
+	return (n) => t.suspend(() => r.inbox().send(s, n.tenantId, n.winnerId, {
+		requestId: n.requestId,
+		templateId: i.templateId,
+		params: { tournamentId: n.tournamentId },
+		attachments: a,
+		expiresAt: i.expiresInMs === void 0 ? null : o() + i.expiresInMs
+	})).pipe(t.asVoid, t.mapError(() => e("unavailable")));
+}, a = (i, a, o) => {
+	if (!i || typeof i.inbox != "function" || typeof a != "function" || !o?.templates || !["registration", "check-in"].every((e) => typeof o.templates[e] == "string" && o.templates[e])) throw e("invalid_input");
+	let s = Object.freeze({ ...o.templates }), c = n("tournament-notices"), l = (e, t) => "tn:" + r("sha256").update(JSON.stringify([e, t])).digest("hex").slice(0, 48);
+	return (n) => t.suspend(() => a().entrants(c, {
+		tenantId: n.tenantId,
+		tournamentId: n.tournamentId
+	})).pipe(t.flatMap((e) => t.forEach(e.entries.filter((e) => n.phase === "registration" || e.checkedInAt === null), (e) => i.inbox().send(c, n.tenantId, e.ownerId, {
+		requestId: l(n.requestId, e.ownerId),
+		templateId: s[n.phase],
+		params: {
+			tournamentId: n.tournamentId,
+			phase: n.phase
+		},
+		attachments: [],
+		expiresAt: null
+	}), { discard: !0 })), t.mapError(() => e("unavailable")));
+};
+//#endregion
+export { a as tournamentInboxNotice, i as tournamentInboxPrize };