@voltro/plugin-matchmaking 0.0.0-stage → 0.87.0

package/dist/admission.entity.js

@@ -0,0 +1,18 @@
+import { CLAIMS_TABLE as e, QUEUES_TABLE as t } from "./ticketContract.js";
+import { boolean as n, id as r, integer as i, table as a, text as o } from "@voltro/database";
+//#region src/admission.entity.ts
+var s = a(e, {
+	id: r({ prefix: "mms" }),
+	tenantId: o().maxLength(256).externalId().sensitive("pii"),
+	subjectId: o().maxLength(256).nullable().externalId().sensitive("pii"),
+	activeTicketId: o().maxLength(64).nullable().serverOnly(),
+	admission: i().serverOnly(),
+	erased: n().serverOnly()
+}).index(["tenantId", "subjectId"]), c = a(t, {
+	id: r({ prefix: "mmq" }),
+	tenantId: o().maxLength(256).externalId().sensitive("pii"),
+	queue: o().maxLength(256).safe(),
+	admission: i().serverOnly()
+}).index(["tenantId", "queue"]);
+//#endregion
+export { c as matchmakingQueuesTable, s as matchmakingSubjectsTable };

package/dist/assignment.js

@@ -0,0 +1,126 @@
+import { MatchmakingError as e, matchmakingError as t } from "./errors.js";
+import { identifier as n } from "./contract.js";
+import { matchmakingAssignmentsTable as r, matchmakingTicketsTable as i } from "./tickets.entity.js";
+import { matchmakingSubjectsTable as a } from "./admission.entity.js";
+import { matchmakingSubjectKey as o } from "./service.js";
+import { Effect as s, Result as c } from "effect";
+import { and as l, eq as u, inSet as d, queryFor as f } from "@voltro/database";
+import { createHash as p } from "node:crypto";
+//#region src/assignment.ts
+var m = (e) => p("sha256").update(JSON.stringify(e)).digest("hex"), h = (n) => n instanceof e ? n : t("unavailable"), g = (e) => s.tryPromise({
+	try: e,
+	catch: h
+}), _ = class extends Error {}, v = (e, p) => {
+	if (!p || typeof p.allocator?.allocate != "function" || typeof p.allocator.release != "function") throw t("invalid_queue");
+	let h = p.allocator, v = p.maxAttempts ?? 3, y = p.now ?? Date.now;
+	if (!Number.isSafeInteger(v) || v < 1 || v > 100) throw t("invalid_queue");
+	let b = () => {
+		let e = y();
+		if (!Number.isSafeInteger(e) || e < 0) throw t("unavailable");
+		return e;
+	}, x = async (e, t, n) => {
+		for (let r of [...n].sort()) if (await e.updateMany(a.tableName, { admission: 0 }, { where: u("id", o(t, r)) }) !== 1) throw new _();
+	}, S = (t, n, r) => e.transactional(async (e) => {
+		await x(e, t, r);
+		let s = new Date(b());
+		for (let r of await e.query(f(i).where(l(u("tenantId", t), d("id", [...n]))).descriptor)) {
+			if (r.state !== "matched") continue;
+			let n = Number(r.attempts ?? 0) + 1;
+			if (n >= v) {
+				await e.update(i.tableName, String(r.id), {
+					state: "expired",
+					attempts: n,
+					closedAt: s
+				});
+				for (let n of r.members) await e.updateMany(a.tableName, { activeTicketId: null }, { where: l(u("id", o(t, n)), u("activeTicketId", String(r.id))) });
+			} else await e.update(i.tableName, String(r.id), {
+				state: "open",
+				attempts: n,
+				matchedAt: null
+			});
+		}
+	});
+	return { assign: (d, f) => {
+		if (d?.type !== "system") return s.fail(t("identity_required"));
+		if (!n(f?.tenantId) || !n(f.queue)) return s.fail(t("invalid_input"));
+		let p = f.tenantId, v = f.queue;
+		return s.gen(function* () {
+			let d = [], y = 0, C = 0;
+			for (let w of f.proposals) {
+				let f = w.teams.flat(), T = f.map((e) => e.id), E = f.flatMap((e) => e.members), D = Object.freeze({
+					tenantId: p,
+					queue: v,
+					requestId: "mmr_" + m([
+						p,
+						v,
+						[...T].sort()
+					]).slice(0, 48),
+					teams: Object.freeze(w.teams.map((e) => Object.freeze(e.flatMap((e) => e.members))))
+				});
+				if (!(yield* g(() => e.transactional(async (e) => {
+					await x(e, p, E);
+					let t = new Date(b());
+					for (let n of T) if (await e.updateMany(i.tableName, {
+						state: "matched",
+						matchedAt: t
+					}, { where: l(u("id", n), u("tenantId", p), u("queue", v), u("state", "open")) }) !== 1) throw new _();
+					return !0;
+				}).catch((e) => {
+					if (e instanceof _) return !1;
+					throw e;
+				})))) {
+					y++;
+					continue;
+				}
+				let O = yield* s.result(s.suspend(() => h.allocate(D)).pipe(s.catchDefect(() => s.fail(t("unavailable")))));
+				if (c.isFailure(O) || !n(O.success.roomId) || E.some((e) => !n(O.success.seats[e]))) {
+					c.isSuccess(O) && (yield* s.ignore(s.suspend(() => h.release(D, O.success)))), yield* g(() => S(p, T, E)), C++;
+					continue;
+				}
+				let { roomId: k, seats: A } = O.success, j = yield* s.result(g(() => e.transactional(async (e) => {
+					await x(e, p, E);
+					let t = new Date(b());
+					for (let n of f) {
+						if (await e.updateMany(i.tableName, {
+							state: "assigned",
+							closedAt: t
+						}, { where: l(u("id", n.id), u("tenantId", p), u("state", "matched")) }) !== 1) throw new _();
+						for (let i of n.members) await e.insert(r.tableName, {
+							id: "mma_" + m([
+								p,
+								n.id,
+								i
+							]).slice(0, 56),
+							tenantId: p,
+							subjectId: i,
+							ticketId: n.id,
+							queue: v,
+							roomId: k,
+							sessionId: A[i],
+							createdAt: t
+						});
+						for (let t of n.members) await e.updateMany(a.tableName, { activeTicketId: null }, { where: l(u("id", o(p, t)), u("activeTicketId", n.id)) });
+					}
+				})));
+				c.isFailure(j) ? (yield* s.ignore(s.suspend(() => h.release(D, O.success))), yield* g(() => S(p, T, E)), C++) : d.push(Object.freeze({
+					requestId: D.requestId,
+					roomId: k,
+					tickets: Object.freeze(T)
+				}));
+			}
+			return Object.freeze({
+				assigned: Object.freeze(d),
+				skipped: y,
+				failed: C
+			});
+		});
+	} };
+}, y = async (e, t, n, i = 20) => (await e.query(f(r).where(l(u("tenantId", t), u("subjectId", n))).orderBy("createdAt", "desc").orderBy("id", "asc").limit(i).descriptor)).filter((e) => e.tenantId === t && e.subjectId === n).map((e) => Object.freeze({
+	ticketId: String(e.ticketId),
+	queue: String(e.queue),
+	roomId: String(e.roomId),
+	sessionId: String(e.sessionId),
+	createdAt: e.createdAt instanceof Date ? e.createdAt.getTime() : Date.parse(String(e.createdAt))
+}));
+//#endregion
+export { v as dataStoreMatchmakingAssigner, y as readMatchmakingAssignments };

package/dist/avoidPairs.js

@@ -0,0 +1,5 @@
+import { Effect as e } from "effect";
+//#region src/avoidPairs.ts
+var t = () => e.succeed(Object.freeze([]));
+//#endregion
+export { t as defaultMatchmakingAvoidPairs };

package/dist/contract.js

@@ -0,0 +1,106 @@
+import { matchmakingError as e } from "./errors.js";
+//#region src/contract.ts
+var t = (e) => typeof e == "string" && e.length > 0 && e.length <= 256 && e.trim().length > 0 && !e.includes("\0") && e !== "~", n = (e, t) => Number.isSafeInteger(e) && e >= 1 && e <= t, r = (r) => {
+	if (!r || !t(r.name) || !r.teams || !n(r.teams.count, 64) || !n(r.teams.size, 256) || r.teams.count * r.teams.size > 4096 || !n(r.maxTickets, 1e4) || !n(r.maxSearchNodes, 1e6) || !n(r.maxAvoidPairs, 1e5) || !n(r.maxAttributeBytes, 65536) || !r.minQuality || !Number.isFinite(r.minQuality.initial) || r.minQuality.initial < 0 || r.minQuality.initial > 1 || !Array.isArray(r.minQuality.after) || r.minQuality.after.length > 256) throw e("invalid_queue");
+	let i = 0, a = r.minQuality.initial, o = Array.from(r.minQuality.after, (t) => {
+		if (!Array.isArray(t) || t.length !== 2 || !Number.isSafeInteger(t[0]) || t[0] <= i || !Number.isFinite(t[1]) || t[1] < 0 || t[1] > a) throw e("invalid_queue");
+		return i = t[0], a = t[1], Object.freeze([t[0], t[1]]);
+	});
+	return Object.freeze({
+		name: r.name,
+		teams: Object.freeze({
+			count: r.teams.count,
+			size: r.teams.size
+		}),
+		maxTickets: r.maxTickets,
+		maxSearchNodes: r.maxSearchNodes,
+		maxAvoidPairs: r.maxAvoidPairs,
+		maxAttributeBytes: r.maxAttributeBytes,
+		minQuality: Object.freeze({
+			initial: r.minQuality.initial,
+			after: Object.freeze(o)
+		})
+	});
+}, i = (t, n, r, a = !0) => {
+	if (r > 32) throw e("invalid_input");
+	if (t !== null && typeof t != "string" && typeof t != "boolean" && !(typeof t == "number" && Number.isFinite(t))) {
+		if (typeof t != "object" || n.has(t) || (n.add(t), !Array.isArray(t) && Object.getPrototypeOf(t) !== Object.prototype && Object.getPrototypeOf(t) !== null) || Object.getOwnPropertySymbols(t).length > 0) throw e("invalid_input");
+		if (Array.isArray(t)) {
+			for (let n = 0; n < t.length; n++) if (!Object.hasOwn(t, n)) throw e("invalid_input");
+		}
+		if (Array.isArray(t) ? Object.keys(t).length !== t.length : Object.getOwnPropertyNames(t).length !== Object.keys(t).length) throw e("invalid_input");
+		for (let e of Object.values(t)) i(e, n, r + 1, a);
+		n.delete(t), a && Object.freeze(t);
+	}
+}, a = (n) => {
+	if (!n || typeof n != "object") throw e("invalid_input");
+	let a = r(n.queue);
+	if (!Number.isSafeInteger(n.now) || n.now < 0 || n.now > 864e13 || !Array.isArray(n.tickets) || n.tickets.length > a.maxTickets || !Array.isArray(n.avoid) || n.avoid.length > a.maxAvoidPairs) throw e("invalid_input");
+	let o = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set(), c, l = Array.from(n.tickets, (r) => {
+		if (!r || !t(r.id) || !t(r.tenantId) || r.queue !== a.name || o.has(r.id) || c !== void 0 && c !== r.tenantId || !Number.isSafeInteger(r.createdAt) || r.createdAt < 0 || r.createdAt > n.now || !Array.isArray(r.members) || r.members.length < 1 || r.members.length > 256) throw e("invalid_input");
+		o.add(r.id), c = r.tenantId;
+		let l = Array.from(r.members, (n) => {
+			if (!t(n) || s.has(n)) throw e("invalid_input");
+			return s.add(n), n;
+		}), u;
+		try {
+			i(r.attributes, /* @__PURE__ */ new Set(), 0, !1);
+			let t = structuredClone(r.attributes);
+			i(t, /* @__PURE__ */ new Set(), 0);
+			let n = JSON.stringify(t);
+			if (n === void 0 || new TextEncoder().encode(n).byteLength > a.maxAttributeBytes) throw e("invalid_input");
+			u = t;
+		} catch {
+			throw e("invalid_input");
+		}
+		return Object.freeze({
+			id: r.id,
+			tenantId: r.tenantId,
+			queue: r.queue,
+			members: Object.freeze(l),
+			createdAt: r.createdAt,
+			attributes: u
+		});
+	}).sort((e, t) => e.createdAt - t.createdAt || (e.id < t.id ? -1 : +(e.id > t.id))), u = Array.from(n.avoid, (n) => {
+		if (!Array.isArray(n) || n.length !== 2 || !t(n[0]) || !t(n[1]) || n[0] === n[1]) throw e("invalid_input");
+		return Object.freeze([n[0], n[1]]);
+	});
+	return Object.freeze({
+		tickets: Object.freeze(l),
+		now: n.now,
+		queue: a,
+		avoid: Object.freeze(u)
+	});
+}, o = (t, r) => {
+	if (!n(r, 65536)) throw e("invalid_input");
+	try {
+		i(t, /* @__PURE__ */ new Set(), 0, !1);
+		let n = structuredClone(t);
+		i(n, /* @__PURE__ */ new Set(), 0);
+		let a = JSON.stringify(n);
+		if (a === void 0 || new TextEncoder().encode(a).byteLength > r) throw e("invalid_input");
+		return n;
+	} catch {
+		throw e("invalid_input");
+	}
+}, s = (e, t) => {
+	let n = (e) => {
+		let t = structuredClone(e);
+		return i(t, /* @__PURE__ */ new Set(), 0), JSON.stringify(t, (e, t) => typeof t == "object" && t && !Array.isArray(t) ? Object.fromEntries(Object.entries(t).sort(([e], [t]) => e < t ? -1 : +(e > t))) : t);
+	};
+	try {
+		return n(e) === n(t);
+	} catch {
+		return !1;
+	}
+}, c = (t, n) => {
+	if (!Number.isSafeInteger(n) || n < 0) throw e("invalid_input");
+	let r = t.minQuality.initial;
+	for (let [e, i] of t.minQuality.after) {
+		if (n < e) break;
+		r = i;
+	}
+	return r;
+};
+//#endregion
+export { o as captureJsonData, a as captureMatchInput, r as captureQueueRules, t as identifier, c as minimumQuality, s as sameJson };

package/dist/director-app/matchmaking.director.workflow.server.tsx

@@ -0,0 +1,5 @@
+import type { AppContext } from '@voltro/runtime'
+import { matchmakingDirectorWorkflowExecutor } from '@voltro/plugin-matchmaking'
+
+/** Services come from the normal app workflow runtime, not globals. */
+export default (_context: AppContext): typeof matchmakingDirectorWorkflowExecutor => matchmakingDirectorWorkflowExecutor

package/dist/director-app/matchmaking.director.workflow.tsx

@@ -0,0 +1,13 @@
+import { workflow } from '@voltro/workflow/define'
+import { MatchmakingDirectorPayload, MatchmakingDirectorResult } from '@voltro/plugin-matchmaking/rpc'
+import { MatchmakingError } from '@voltro/plugin-matchmaking/errors'
+
+/** Internal API-lane Director. The scheduler owns firing and overlap; one run at a time. */
+export const MatchmakingDirector = workflow({ name: 'matchmaking.director', payload: MatchmakingDirectorPayload,
+  success: MatchmakingDirectorResult, error: MatchmakingError,
+  internal: true, controls: { guards: [{ scope: 'matchmaking:operate' }] },
+  idempotencyKey: ({ runKey }) => `matchmaking.director:${runKey}`,
+  singleton: { key: () => 'matchmaking.director', mode: 'skip' },
+  schedule: { cron: '*/2 * * * * *', timezone: 'UTC', onOverlap: 'skip', backfill: 'skip',
+    payload: ({ scheduledAt }) => ({ runKey: scheduledAt.toISOString(), maxPairs: 64 }) },
+})

package/dist/director.js

@@ -0,0 +1,73 @@
+import { MatchmakingError as e, matchmakingError as t } from "./errors.js";
+import { captureJsonData as n, captureMatchInput as r, identifier as i } from "./contract.js";
+import { runQueueMatch as a } from "./queue.js";
+import { matchmakingTicketsTable as o } from "./tickets.entity.js";
+import { captureQueueDeclarations as s } from "./queueDeclarations.js";
+import { Effect as c, Result as l } from "effect";
+import { and as u, eq as d, gt as f, queryFor as p } from "@voltro/database";
+//#region src/director.ts
+var m = (n) => n instanceof e ? n : t("unavailable"), h = (e) => {
+	let n = e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN;
+	if (!Number.isSafeInteger(n) || n < 0 || n > 864e13) throw t("unavailable");
+	return n;
+}, g = (e, g) => {
+	if (!g || typeof g.now != "function" || typeof g.avoidPairs != "function") throw t("invalid_queue");
+	let _ = new Map(s(g.queues).map((e) => [e.name, e])), v = g.now, y = g.avoidPairs;
+	return { plan: (s, g) => {
+		let b, x;
+		try {
+			if (s?.type !== "system") throw t("identity_required");
+			if (b = n(g, 4096), !b || Object.keys(b).length !== 2 || !i(b.tenantId) || !i(b.queue)) throw t("invalid_input");
+			let e = _.get(b.queue);
+			if (!e) throw t("not_found");
+			x = e;
+		} catch (e) {
+			return c.fail(m(e));
+		}
+		return c.tryPromise({
+			try: async () => {
+				let n = v();
+				if (!Number.isSafeInteger(n) || n < 0 || n > 864e13) throw t("unavailable");
+				let s = await e.query(p(o).where(u(d("tenantId", b.tenantId), d("queue", b.queue), d("state", "open"), f("expiresAt", new Date(n)))).orderBy("createdAt", "asc").orderBy("id", "asc").limit(x.maxTickets + 1).descriptor);
+				if (s.length > x.maxTickets) throw t("queue_full");
+				let m = s.map((e) => {
+					if (e.tenantId !== b.tenantId || e.queue !== b.queue || e.state !== "open" || h(e.expiresAt) <= n || !Array.isArray(e.members) || !e.members.includes(e.subjectId) || !i(e.id) || (e.partyId === null || e.partyId === void 0) && e.members.length !== 1) throw t("unavailable");
+					return {
+						id: e.id,
+						tenantId: b.tenantId,
+						queue: b.queue,
+						members: e.members,
+						createdAt: h(e.createdAt),
+						attributes: e.attributes
+					};
+				}), g = r({
+					queue: x,
+					now: n,
+					tickets: m,
+					avoid: []
+				}), _ = Object.freeze({
+					tenantId: b.tenantId,
+					queue: b.queue,
+					tickets: g.tickets,
+					maxPairs: x.maxAvoidPairs,
+					query: e.query.bind(e)
+				}), S = await c.runPromise(c.result(c.suspend(() => y(_))));
+				if (l.isFailure(S)) throw S.failure;
+				let C = a(x, {
+					tickets: g.tickets,
+					now: n,
+					avoid: S.success
+				});
+				return Object.freeze({
+					...C,
+					tenantId: b.tenantId,
+					queue: b.queue,
+					observedAt: n
+				});
+			},
+			catch: m
+		}).pipe(c.catchDefect(() => c.fail(t("unavailable"))));
+	} };
+};
+//#endregion
+export { g as dataStoreMatchmakingPlanner };

package/dist/directorContract.js

@@ -0,0 +1,16 @@
+import { Schema as e } from "effect";
+//#region src/directorContract.ts
+var t = e.Number.pipe(e.check(e.isInt()), e.check(e.isGreaterThanOrEqualTo(0))), n = e.Struct({
+	runKey: e.NonEmptyString,
+	maxPairs: t.pipe(e.check(e.isBetween({
+		minimum: 1,
+		maximum: 1024
+	})))
+}), r = e.Struct({
+	cycles: t,
+	assigned: t,
+	skipped: t,
+	failed: t
+});
+//#endregion
+export { n as MatchmakingDirectorPayload, r as MatchmakingDirectorResult };

package/dist/directorWorkflow.js

@@ -0,0 +1,6 @@
+import { MatchmakingDirectorPort as e } from "./port.js";
+import { Effect as t } from "effect";
+//#region src/directorWorkflow.ts
+var n = (n) => e.pipe(t.flatMap((e) => e.run(n)));
+//#endregion
+export { n as matchmakingDirectorWorkflowExecutor };

package/dist/errors.d.ts

@@ -0,0 +1,13 @@
+import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
+
+export declare class MatchmakingError extends MatchmakingError_base {
+}
+
+export declare const matchmakingError: (code: MatchmakingError["code"]) => MatchmakingError;
+
+declare const MatchmakingError_base: Schema.Class<MatchmakingError, Schema.TaggedStruct<"MatchmakingError", {
+    readonly code: Schema.Literals<readonly ["invalid_input", "invalid_queue", "invalid_proposal", "unavailable", "identity_required", "not_found", "already_searching", "conflict", "queue_full", "erased", "export_limit", "forbidden", "party_full", "already_in_party", "party_not_ready"]>;
+}>, YieldableError>;
+
+export { }

package/dist/errors.js

@@ -0,0 +1,21 @@
+import { Schema as e } from "effect";
+//#region src/errors.ts
+var t = class extends e.TaggedError()("MatchmakingError", { code: e.Literals([
+	"invalid_input",
+	"invalid_queue",
+	"invalid_proposal",
+	"unavailable",
+	"identity_required",
+	"not_found",
+	"already_searching",
+	"conflict",
+	"queue_full",
+	"erased",
+	"export_limit",
+	"forbidden",
+	"party_full",
+	"already_in_party",
+	"party_not_ready"
+]) }) {}, n = (e) => new t({ code: e });
+//#endregion
+export { t as MatchmakingError, n as matchmakingError };