@voltro/plugin-leaderboards 0.0.0-stage → 0.88.0

package/dist/administration.js

@@ -0,0 +1,4 @@
+import { Context as e } from "effect";
+// src/administration.ts
+var t = class extends e.Service()("@voltro/LeaderboardAdministration") {};
+export { t as LeaderboardAdministration };

package/dist/bracketAdmission.js

@@ -0,0 +1,293 @@
+import { LeaderboardError as e, leaderboardError as t } from "./errors.js";
+import { canonicalLeaderboardJson as n, captureLeaderboardJson as r } from "./json.js";
+import { defineBracketAdmission as i } from "./bracketAdmissionPolicy.js";
+import { makeLeaderboardSubjectFences as a } from "./subjectFences.js";
+import { BracketAdmissionPort as o } from "./ports.js";
+import { Effect as s, Layer as c, Schema as l } from "effect";
+import { Subject as u } from "@voltro/protocol";
+import { createHash as d } from "node:crypto";
+import { and as f, eq as p, id as m, json as h, table as g, text as _, timestamp as v } from "@voltro/database";
+// src/bracketAdmission.ts
+var y = "_voltro_tournament_admissions", b = g(y, {
+	id: m({ prefix: "tadm" }),
+	tenantId: _().maxLength(120).externalId().sensitive("pii"),
+	tournamentId: _().maxLength(120).serverOnly(),
+	state: h().sensitive("pii"),
+	createdAt: v(),
+	updatedAt: v()
+}).unique("byBracketAdmission", ["tenantId", "tournamentId"]).index(["tenantId"]), x = (e) => typeof e == "string" && e.length > 0 && e.length <= 120 && e.trim() === e && e.isWellFormed() && !/[\u0000-\u001f\u007f]/.test(e) ? e : S("invalid_input");
+function S(e) {
+	throw t(e);
+}
+var C = (e) => Number.isSafeInteger(e) && e >= 0 && e <= 864e13 ? e : S("invalid_input"), w = (e) => {
+	let t = r(e, 1024);
+	return t && Object.keys(t).length === 2 && Object.hasOwn(t, "tenantId") && Object.hasOwn(t, "tournamentId") || S("invalid_input"), Object.freeze({
+		tenantId: x(t.tenantId),
+		tournamentId: x(t.tournamentId)
+	});
+}, T = l.Struct({
+	ownerId: l.String,
+	joinedAt: l.Int,
+	checkedInAt: l.NullOr(l.Int)
+}), E = l.Struct({
+	version: l.Literal(1),
+	definition: l.Struct({
+		registrationOpensAt: l.Int,
+		registrationClosesAt: l.Int,
+		checkInOpensAt: l.Int,
+		checkInClosesAt: l.Int,
+		maxEntries: l.Int
+	}),
+	phase: l.Literals([
+		"open",
+		"sealed",
+		"erasing",
+		"cancelled"
+	]),
+	entries: l.Array(T),
+	eraseRequest: l.NullOr(l.String),
+	eraseTarget: l.NullOr(l.String)
+}), D = (e, t) => {
+	(e.tenantId !== t.tenantId || e.tournamentId !== t.tournamentId) && S("unavailable");
+	let n = l.decodeUnknownSync(E)(r(e.state, 65536), { onExcessProperty: "error" });
+	i(n.definition), (n.entries.length > n.definition.maxEntries || new Set(n.entries.map((e) => e.ownerId)).size !== n.entries.length) && S("unavailable");
+	for (let e of n.entries) x(e.ownerId), C(e.joinedAt), (e.joinedAt < n.definition.registrationOpensAt || e.joinedAt >= n.definition.registrationClosesAt) && S("unavailable"), e.checkedInAt !== null && (C(e.checkedInAt) < n.definition.checkInOpensAt || e.checkedInAt >= n.definition.checkInClosesAt) && S("unavailable");
+	n.eraseRequest !== null && x(n.eraseRequest), (n.eraseRequest === null != (n.eraseTarget === null) || n.eraseTarget !== null && !/^[a-f0-9]{64}$/.test(n.eraseTarget) || n.phase === "erasing" && n.eraseRequest === null || ["open", "sealed"].includes(n.phase) && n.eraseRequest !== null) && S("unavailable");
+	for (let t of ["createdAt", "updatedAt"]) e[t] instanceof Date && Number.isFinite(e[t].getTime()) || S("unavailable");
+	return n;
+}, O = async (e, t, n = !1) => {
+	let r = await e.query({
+		table: y,
+		predicate: f(p("tenantId", t.tenantId), p("tournamentId", t.tournamentId)),
+		order: [],
+		take: 2,
+		skip: void 0,
+		projection: void 0,
+		...n ? { lock: "update" } : {}
+	});
+	return r.length !== 1 && S(r.length ? "unavailable" : "not_found"), {
+		row: r[0],
+		state: D(r[0], t)
+	};
+}, k = (n, r) => {
+	let i;
+	try {
+		i = w(r);
+	} catch (n) {
+		return s.fail(n instanceof e ? n : t("invalid_input"));
+	}
+	return s.tryPromise({
+		try: async () => {
+			let { state: e } = await O(n, i);
+			return Object.freeze({
+				phase: e.phase,
+				definition: Object.freeze({ ...e.definition })
+			});
+		},
+		catch: (n) => n instanceof e ? n : t("unavailable")
+	}).pipe(s.uninterruptible);
+}, A = (e) => {
+	let t = r(e, 2048);
+	return t && !Object.keys(t).some((e) => !["requestId", "target"].includes(e)) && t.target && !Object.keys(t.target).some((e) => ![
+		"tenantId",
+		"subjectId",
+		"kind"
+	].includes(e)) && ["user", "guest"].includes(t.target.kind) || S("invalid_input"), Object.freeze({
+		requestId: x(t.requestId),
+		target: Object.freeze({
+			tenantId: x(t.target.tenantId),
+			subjectId: x(t.target.subjectId),
+			kind: t.target.kind
+		})
+	});
+}, j = (e) => {
+	(!e || typeof e != "object" || Object.getPrototypeOf(e) !== Object.prototype || Object.getOwnPropertySymbols(e).length) && S("invalid_input");
+	let t = Object.getOwnPropertyDescriptors(e);
+	Object.entries(t).some(([e, t]) => ![
+		"epochNow",
+		"maxTenantTournaments",
+		"authorize",
+		"withdrawSubject",
+		"withdrawTournament",
+		"authorizeExport"
+	].includes(e) || !t.enumerable || !("value" in t)) && S("invalid_input");
+	let n = e.maxTenantTournaments ?? 1024;
+	return (typeof e.epochNow != "function" || !Number.isSafeInteger(n) || n < 1 || n > 4096 || [
+		"authorize",
+		"withdrawSubject",
+		"withdrawTournament",
+		"authorizeExport"
+	].some((t) => typeof Reflect.get(e, t) != "function")) && S("invalid_input"), Object.freeze({
+		epochNow: e.epochNow.bind(e),
+		maxTenantTournaments: n,
+		authorize: e.authorize.bind(e),
+		withdrawSubject: e.withdrawSubject.bind(e),
+		withdrawTournament: e.withdrawTournament.bind(e),
+		authorizeExport: e.authorizeExport.bind(e)
+	});
+}, M = (o, c) => {
+	let f = j(c), m = f.epochNow, h = f.maxTenantTournaments, { authorize: g, withdrawSubject: _, withdrawTournament: v, authorizeExport: b } = f, { seedSubject: T, subjectFence: E, eraseSubjectFence: k } = a(o), M = (n) => {
+		try {
+			return n();
+		} catch (n) {
+			return s.fail(n instanceof e ? n : t("invalid_input"));
+		}
+	}, N = (n) => s.tryPromise({
+		try: n,
+		catch: (n) => n instanceof e ? n : t("unavailable")
+	}).pipe(s.uninterruptible), P = O, F = async (e, t, n) => {
+		r(n, 65536), await e.update("_voltro_tournament_admissions", String(t.id), {
+			state: n,
+			updatedAt: new Date(C(m()))
+		}) || S("unavailable");
+	}, I = (e, t) => ((e.type !== "user" || e.tenantId !== t.tenantId || e.id === null) && S("forbidden"), x(e.id)), L = (e) => {
+		e.type !== "system" && e.type !== "service" && S("forbidden");
+	}, R = (e, t) => Object.freeze({
+		phase: e.phase,
+		entries: e.entries.length,
+		checkedIn: e.entries.filter((e) => e.checkedInAt !== null).length,
+		own: e.entries.some((e) => e.ownerId === t) ? Object.freeze({ ...e.entries.find((e) => e.ownerId === t) }) : null
+	}), z = async (e) => {
+		let t = await o.query({
+			table: y,
+			predicate: p("tenantId", e),
+			order: [],
+			take: h + 1,
+			skip: void 0,
+			projection: void 0
+		});
+		t.length > h && S("limit_exceeded");
+		let n = t.map((t) => {
+			let n = w({
+				tenantId: e,
+				tournamentId: x(t.tournamentId)
+			});
+			return {
+				scope: n,
+				state: D(t, n)
+			};
+		});
+		return new Set(n.map((e) => e.scope.tournamentId)).size !== n.length && S("unavailable"), n.sort((e, t) => e.scope.tournamentId < t.scope.tournamentId ? -1 : +(e.scope.tournamentId > t.scope.tournamentId));
+	};
+	return Object.freeze({
+		create: (e, t, r) => M(() => {
+			let a = w(t), c = l.decodeUnknownSync(l.toType(u))(structuredClone(e)), d = i(r);
+			return L(c), g(c, a, "create").pipe(s.flatMap(() => N(async () => {
+				let e = C(m());
+				await o.insertIgnore(y, {
+					...a,
+					state: {
+						version: 1,
+						definition: d,
+						phase: "open",
+						entries: [],
+						eraseRequest: null,
+						eraseTarget: null
+					},
+					createdAt: new Date(e),
+					updatedAt: new Date(e)
+				}, { conflictColumns: ["tenantId", "tournamentId"] });
+				let { state: t } = await P(o, a);
+				n(t.definition) !== n(d) && S("conflict");
+			})));
+		}),
+		register: (e, t) => M(() => {
+			let n = w(t), r = l.decodeUnknownSync(l.toType(u))(structuredClone(e)), i = I(r, n);
+			return g(r, n, "register").pipe(s.flatMap(() => N(() => T(n.tenantId, i))), s.flatMap(() => N(() => o.transactional(async (e) => {
+				await E(e, n.tenantId, i);
+				let { row: t, state: r } = await P(e, n, !0), a = C(m());
+				if (r.phase !== "open" && S("conflict"), r.entries.some((e) => e.ownerId === i)) return R(r, i);
+				(a < r.definition.registrationOpensAt || a >= r.definition.registrationClosesAt) && S("conflict"), r.entries.length >= r.definition.maxEntries && S("limit_exceeded");
+				let o = {
+					...r,
+					entries: [...r.entries, {
+						ownerId: i,
+						joinedAt: a,
+						checkedInAt: null
+					}]
+				};
+				return await F(e, t, o), R(o, i);
+			}))));
+		}),
+		checkIn: (e, t) => M(() => {
+			let n = w(t), r = l.decodeUnknownSync(l.toType(u))(structuredClone(e)), i = I(r, n);
+			return g(r, n, "checkIn").pipe(s.flatMap(() => N(() => T(n.tenantId, i))), s.flatMap(() => N(() => o.transactional(async (e) => {
+				await E(e, n.tenantId, i);
+				let { row: t, state: r } = await P(e, n, !0), a = C(m()), o = r.entries.find((e) => e.ownerId === i);
+				if (r.phase === "open" && o || S("conflict"), o.checkedInAt !== null) return R(r, i);
+				(a < r.definition.checkInOpensAt || a >= r.definition.checkInClosesAt) && S("conflict");
+				let s = {
+					...r,
+					entries: r.entries.map((e) => e.ownerId === i ? {
+						...e,
+						checkedInAt: a
+					} : e)
+				};
+				return await F(e, t, s), R(s, i);
+			}))));
+		}),
+		status: (e, t) => M(() => {
+			let n = w(t), r = l.decodeUnknownSync(l.toType(u))(structuredClone(e)), i = I(r, n);
+			return g(r, n, "status").pipe(s.flatMap(() => N(async () => R((await P(o, n)).state, i))));
+		}),
+		entrants: (e, t) => M(() => {
+			let n = w(t), r = l.decodeUnknownSync(l.toType(u))(structuredClone(e));
+			return L(r), g(r, n, "entrants").pipe(s.flatMap(() => N(async () => {
+				let e = (await P(o, n)).state;
+				return Object.freeze({
+					phase: e.phase,
+					entries: Object.freeze(e.entries.map((e) => Object.freeze({ ...e })))
+				});
+			})));
+		}),
+		seal: (e, t) => M(() => {
+			let r = w(t), i = l.decodeUnknownSync(l.toType(u))(structuredClone(e));
+			return L(i), g(i, r, "seal").pipe(s.flatMap(() => N(() => P(o, r))), s.flatMap((e) => N(() => o.transactional(async (t) => {
+				let i = e.state.entries.map((e) => e.ownerId).sort();
+				for (let e of i) await E(t, r.tenantId, e);
+				let { row: a, state: o } = await P(t, r, !0);
+				return n(o.entries.map((e) => e.ownerId).sort()) !== n(i) && S("conflict"), (!["open", "sealed"].includes(o.phase) || C(m()) < o.definition.checkInClosesAt) && S("conflict"), o.phase === "open" && await F(t, a, {
+					...o,
+					phase: "sealed"
+				}), Object.freeze({
+					checkedIn: Object.freeze(o.entries.filter((e) => e.checkedInAt !== null).map((e) => e.ownerId)),
+					noShows: Object.freeze(o.entries.filter((e) => e.checkedInAt === null).map((e) => e.ownerId))
+				});
+			}))));
+		}),
+		exportSubject: (e) => M(() => {
+			let t = A(e);
+			return b(t).pipe(s.flatMap(() => N(async () => (await z(t.target.tenantId)).flatMap(({ scope: e, state: n }) => {
+				let r = n.entries.find((e) => e.ownerId === t.target.subjectId);
+				return r ? [{
+					tournamentId: e.tournamentId,
+					phase: n.phase,
+					...r
+				}] : [];
+			}))));
+		}),
+		eraseSubject: (e) => M(() => {
+			let t = A(e), r = d("sha256").update(n(t.target)).digest("hex");
+			return _(t).pipe(s.flatMap(() => N(() => k(t.target.tenantId, t.target.subjectId))), s.flatMap(() => N(() => z(t.target.tenantId))), s.flatMap((e) => s.forEach(e.filter((e) => e.state.entries.some((e) => e.ownerId === t.target.subjectId) || e.state.eraseTarget === r && e.state.eraseRequest === t.requestId), ({ scope: e }) => N(() => o.transactional(async (n) => {
+				let { row: i, state: a } = await P(n, e, !0), o = a.entries.some((e) => e.ownerId === t.target.subjectId);
+				return !o && a.phase === "cancelled" && a.eraseRequest === t.requestId && a.eraseTarget === r || (o || S("unavailable"), a.phase === "erasing" && (a.eraseRequest !== t.requestId || a.eraseTarget !== r) && S("conflict"), await F(n, i, {
+					...a,
+					phase: "erasing",
+					eraseRequest: t.requestId,
+					eraseTarget: r
+				}), !1);
+			})).pipe(s.flatMap((n) => n ? s.void : v(e, t).pipe(s.flatMap(() => N(() => o.transactional(async (n) => {
+				let { row: i, state: a } = await P(n, e, !0);
+				(a.phase !== "erasing" || a.eraseRequest !== t.requestId || a.eraseTarget !== r) && S("conflict"), await F(n, i, {
+					...a,
+					phase: "cancelled",
+					entries: a.entries.filter((e) => e.ownerId !== t.target.subjectId)
+				});
+			})))))), {
+				concurrency: 1,
+				discard: !0
+			})));
+		})
+	});
+}, N = (e, t) => c.succeed(o, M(e, t));
+export { y as BRACKET_ADMISSIONS_TABLE, N as bracketAdmissionLayer, b as bracketAdmissionsTable, M as dataStoreBracketAdmissions, k as readBracketAdmissionWindow, j as resolveBracketAdmissionOptions };

package/dist/bracketAdmissionPolicy.js

@@ -0,0 +1,21 @@
+import { leaderboardError as e } from "./errors.js";
+import { captureLeaderboardJson as t } from "./json.js";
+import { Schema as n } from "effect";
+// src/bracketAdmissionPolicy.ts
+var r = n.Struct({
+	registrationOpensAt: n.Int,
+	registrationClosesAt: n.Int,
+	checkInOpensAt: n.Int,
+	checkInClosesAt: n.Int,
+	maxEntries: n.Int
+}), i = (i) => {
+	let a;
+	try {
+		a = n.decodeUnknownSync(r)(t(i, 1024), { onExcessProperty: "error" });
+	} catch {
+		throw e("invalid_input");
+	}
+	if (a.registrationOpensAt < 0 || a.registrationClosesAt <= a.registrationOpensAt || a.checkInOpensAt < a.registrationClosesAt || a.checkInClosesAt <= a.checkInOpensAt || a.checkInClosesAt > 864e13 || a.maxEntries < 2 || a.maxEntries > 256) throw e("invalid_input");
+	return Object.freeze(a);
+};
+export { i as defineBracketAdmission };

package/dist/bracketInstallation.js

@@ -0,0 +1,132 @@
+import { LeaderboardError as e, leaderboardError as t } from "./errors.js";
+import { captureLeaderboardJson as n } from "./json.js";
+import { defineBracketAdmission as r } from "./bracketAdmissionPolicy.js";
+import { dataStoreBracketAdmissions as i, resolveBracketAdmissionOptions as a } from "./bracketAdmission.js";
+import { Effect as o, Schema as s } from "effect";
+import { Subject as c } from "@voltro/protocol";
+// src/bracketInstallation.ts
+var l = [
+	"create",
+	"register",
+	"checkIn",
+	"status",
+	"seal",
+	"entrants",
+	"exportSubject",
+	"eraseSubject"
+];
+function u() {
+	throw t("invalid_input");
+}
+var d = (e) => {
+	e && typeof e == "object" || u();
+	for (let t of l) {
+		let n = Object.getOwnPropertyDescriptor(e, t);
+		n && "value" in n && typeof n.value == "function" || u();
+	}
+	return Object.freeze({
+		create: e.create.bind(e),
+		register: e.register.bind(e),
+		checkIn: e.checkIn.bind(e),
+		status: e.status.bind(e),
+		seal: e.seal.bind(e),
+		entrants: e.entrants.bind(e),
+		exportSubject: e.exportSubject.bind(e),
+		eraseSubject: e.eraseSubject.bind(e)
+	});
+}, f = (l) => {
+	let f, p, m = null, h = Object.freeze([]);
+	if (l !== void 0) {
+		(!l || Object.getPrototypeOf(l) !== Object.prototype || Object.getOwnPropertySymbols(l).length) && u();
+		let e = Object.getOwnPropertyDescriptors(l);
+		Object.values(e).some((e) => !e.enumerable || !("value" in e)) && u(), l.backend === "sql" && Object.keys(e).length === 2 && Object.hasOwn(e, "options") ? (f = a(l.options), h = Object.freeze(["_voltro_tournament_admissions"]), m = Object.freeze({
+			backend: "sql",
+			version: "voltro:bracket-admission:1",
+			maxTenantTournaments: f.maxTenantTournaments
+		})) : l.backend === "custom" && Object.keys(e).length === 4 && Object.hasOwn(e, "version") && Object.hasOwn(e, "service") && Object.hasOwn(e, "sources") ? ((typeof l.version != "string" || !/^[a-zA-Z0-9][a-zA-Z0-9:._-]{0,119}$/.test(l.version) || l.version.startsWith("voltro:")) && u(), p = d(l.service), h = n(l.sources, 4096), (!Array.isArray(h) || h.length < 1 || h.length > 32 || new Set(h).size !== h.length || h.some((e) => typeof e != "string" || !/^[a-zA-Z_][a-zA-Z0-9_]{0,119}$/.test(e))) && u(), m = Object.freeze({
+			backend: "custom",
+			version: l.version,
+			maxTenantTournaments: null
+		})) : u();
+	}
+	let g, _ = !1, v = 0, y = /* @__PURE__ */ new Set(), b = () => {
+		if (v--, v === 0) for (let e of [...y]) e();
+	}, x = (n) => {
+		let r;
+		try {
+			r = n();
+		} catch (n) {
+			return o.fail(n instanceof e ? n : t("invalid_input"));
+		}
+		return o.acquireUseRelease(o.suspend(() => g === void 0 || _ ? o.fail(t("unavailable")) : (v++, o.succeed(g))), (e) => o.suspend(() => r(e)), () => o.sync(b)).pipe(o.uninterruptible);
+	}, S = (e) => s.decodeUnknownSync(s.toType(c))(structuredClone(e)), C = (e) => s.decodeUnknownSync(s.Struct({
+		requestId: s.NonEmptyString,
+		target: s.Struct({
+			subjectId: s.NonEmptyString,
+			tenantId: s.NullOr(s.NonEmptyString),
+			kind: s.Literals(["user", "guest"])
+		})
+	}))(n(e, 2048), { onExcessProperty: "error" }), w = Object.freeze({
+		create: (e, t, i) => x(() => {
+			let a = S(e), o = n(t, 1024), s = r(i);
+			return (e) => e.create(a, o, s);
+		}),
+		register: (e, t) => x(() => {
+			let r = S(e), i = n(t, 1024);
+			return (e) => e.register(r, i);
+		}),
+		checkIn: (e, t) => x(() => {
+			let r = S(e), i = n(t, 1024);
+			return (e) => e.checkIn(r, i);
+		}),
+		status: (e, t) => x(() => {
+			let r = S(e), i = n(t, 1024);
+			return (e) => e.status(r, i);
+		}),
+		seal: (e, t) => x(() => {
+			let r = S(e), i = n(t, 1024);
+			return (e) => e.seal(r, i);
+		}),
+		entrants: (e, t) => x(() => {
+			let r = S(e), i = n(t, 1024);
+			return (e) => e.entrants(r, i);
+		}),
+		exportSubject: (e) => x(() => {
+			let t = C(e);
+			return (e) => e.exportSubject(t);
+		}),
+		eraseSubject: (e) => x(() => {
+			let t = C(e);
+			return (e) => e.eraseSubject(t);
+		})
+	});
+	return Object.freeze({
+		configuration: m,
+		sources: h,
+		service: w,
+		isBound: () => g !== void 0 && !_,
+		boundService: () => _ ? void 0 : g,
+		bind: (e) => {
+			if (_) throw t("unavailable");
+			g = f === void 0 ? p : i(e, f);
+		},
+		close: () => {
+			_ = !0, g = void 0;
+		},
+		deactivate: () => o.sync(() => {
+			_ = !0, g = void 0;
+		}).pipe(o.flatMap(() => o.callback((e) => {
+			if (v === 0) {
+				e(o.void);
+				return;
+			}
+			let t = () => {
+				y.delete(t), e(o.void);
+			};
+			return y.add(t), o.sync(() => {
+				y.delete(t);
+			});
+		})))
+	});
+};
+export { f as makeBracketAdmissionInstallation };

package/dist/bracketMatchPorts.js

@@ -0,0 +1,4 @@
+import { Context as e } from "effect";
+// src/bracketMatchPorts.ts
+var t = class extends e.Service()("@voltro/TournamentBracketPort") {};
+export { t as TournamentBracketPort };