@voltro/plugin-matchmaking 0.0.0-stage → 0.88.0

package/dist/roomsAllocator.js

@@ -0,0 +1,75 @@
+import { matchmakingError as e } from "./errors.js";
+import { Effect as t } from "effect";
+import { resolveIdentityAuthority as n } from "@voltro/protocol";
+import { RoomReservePort as r } from "@voltro/plugin-rooms/ports";
+// src/roomsAllocator.ts
+var i = (i) => {
+	if (!i?.rooms?.services || typeof i.room != "function") throw e("invalid_queue");
+	let a = i.maxRetained ?? 1024;
+	if (!Number.isSafeInteger(a) || a < 1 || a > 65536) throw e("invalid_queue");
+	let o = /* @__PURE__ */ new Map(), s = (e, t) => {
+		for (o.delete(e), o.set(e, t); o.size > a;) o.delete(o.keys().next().value);
+	}, c = (r, a) => t.flatMap(t.tryPromise({
+		try: () => n({
+			type: "user",
+			id: a,
+			tenantId: r
+		}, {
+			origin: "workflow",
+			headers: {},
+			clientId: void 0,
+			store: i.getStore?.()
+		}, i.authority),
+		catch: () => e("unavailable")
+	}), (n) => n.kind === "resolved" ? t.succeed(n.subject) : t.fail(e(n.kind === "vetoed" ? "forbidden" : "unavailable"))), l = (n) => t.flatMap(r, n).pipe(t.provide(i.rooms.services), t.mapError((t) => t instanceof Error && t._tag === "MatchmakingError" ? t : e("unavailable")));
+	return {
+		allocate: (n) => t.gen(function* () {
+			let r = n.teams.flat();
+			if (r.length === 0) return yield* t.fail(e("invalid_proposal"));
+			let a = i.room(n), o = yield* t.forEach(r, (e) => c(n.tenantId, e));
+			return yield* l((r) => t.gen(function* () {
+				let i = a.pool === void 0 ? {} : { pool: a.pool }, c = [], l;
+				if (r.prepareMatch) l = (yield* r.prepareMatch({
+					requestId: n.requestId,
+					room: a.room,
+					options: a.options,
+					...i
+				}, o[0])).roomId;
+				else {
+					let e = yield* r.reserve({
+						mode: "create",
+						room: a.room,
+						options: a.options,
+						...i
+					}, o[0]);
+					l = e.roomId, c.push({
+						subject: o[0],
+						sessionId: e.sessionId,
+						token: e.token
+					});
+				}
+				for (let n of o.slice(c.length)) {
+					let i = yield* r.reserve({
+						mode: "joinById",
+						roomId: l
+					}, n);
+					if (i.roomId !== l) return yield* t.fail(e("unavailable"));
+					c.push({
+						subject: n,
+						sessionId: i.sessionId,
+						token: i.token
+					});
+				}
+				return s(n.requestId, c), Object.freeze({
+					roomId: l,
+					seats: Object.freeze(Object.fromEntries(c.map((e) => [e.subject.id, e.sessionId])))
+				});
+			}));
+		}),
+		release: (e) => t.suspend(() => {
+			let n = o.get(e.requestId);
+			return n ? (o.delete(e.requestId), l((e) => t.forEach(n, (n) => t.ignore(e.leave(n.sessionId, n.token, n.subject)), { discard: !0 }))) : t.void;
+		})
+	};
+};
+export { i as roomsAllocator };

package/dist/rpc.d.ts

@@ -0,0 +1,247 @@
+import { ActionProcedureDescriptor } from '@voltro/protocol';
+import { PluginRpcClientDescriptor } from '@voltro/protocol';
+import { QueryProcedureDescriptor } from '@voltro/protocol';
+import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
+
+/** The caller's own Room seats from matches; redeem `sessionId` with `rooms.resume`. */
+export declare const assignmentsDescriptor: QueryProcedureDescriptor<"matchmaking.assignments", Schema.Struct<{}>, Schema.$Array<Schema.Struct<{
+    readonly ticketId: Schema.String;
+    readonly queue: Schema.String;
+    readonly roomId: Schema.String;
+    readonly sessionId: Schema.String;
+    readonly createdAt: Schema.Number;
+}>>, typeof MatchmakingError>;
+
+export declare const BASE_NAME = "@voltro/plugin-matchmaking";
+
+export declare const cancelDescriptor: ActionProcedureDescriptor<"matchmaking.cancel", Schema.Struct<{
+    readonly ticketId: Schema.NonEmptyString;
+}>, Schema.Void, typeof MatchmakingError>;
+
+export declare const enqueueDescriptor: ActionProcedureDescriptor<"matchmaking.enqueue", Schema.Struct<{
+    readonly queue: Schema.NonEmptyString;
+    readonly requestId: Schema.NonEmptyString;
+    readonly preferences: Schema.$Record<Schema.String, Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly queue: Schema.String;
+    readonly state: Schema.Literals<readonly ["open", "matched", "assigned", "cancelled", "expired"]>;
+    readonly members: Schema.$Array<Schema.String>;
+    readonly attributes: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly createdAt: Schema.Number;
+    readonly expiresAt: Schema.Number;
+    readonly closedAt: Schema.NullOr<Schema.Number>;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>, typeof MatchmakingError>;
+
+/** Expected wait for a declared queue from recent matched searches of the caller's tenant; no identity is exposed. */
+export declare const estimateDescriptor: QueryProcedureDescriptor<"matchmaking.estimate", Schema.Struct<{
+    readonly queue: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly queue: Schema.String;
+    readonly waitMs: Schema.NullOr<Schema.Number>;
+    readonly samples: Schema.Number;
+}>, typeof MatchmakingError>;
+
+/** A scheduled Director run: `runKey` makes the run idempotent; `maxPairs` bounds tenant×queue work per run. */
+export declare const MatchmakingDirectorPayload: Schema.Struct<{
+    readonly runKey: Schema.NonEmptyString;
+    readonly maxPairs: Schema.Number;
+}>;
+
+export declare type MatchmakingDirectorPayload = typeof MatchmakingDirectorPayload.Type;
+
+export declare const MatchmakingDirectorResult: Schema.Struct<{
+    readonly cycles: Schema.Number;
+    readonly assigned: Schema.Number;
+    readonly skipped: Schema.Number;
+    readonly failed: Schema.Number;
+}>;
+
+export declare type MatchmakingDirectorResult = typeof MatchmakingDirectorResult.Type;
+
+declare class MatchmakingError extends MatchmakingError_base {
+}
+
+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 declare const matchmakingRpcClientImports: ReadonlyArray<PluginRpcClientDescriptor>;
+
+export declare const partyCancelSearchDescriptor: ActionProcedureDescriptor<"matchmaking.parties.cancelSearch", Schema.Struct<{
+    readonly partyId: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly leaderId: Schema.String;
+    readonly maxSize: Schema.Number;
+    readonly approval: Schema.Literals<readonly ["open", "leader"]>;
+    readonly createdAt: Schema.Number;
+    readonly members: Schema.$Array<Schema.Struct<{
+        readonly subjectId: Schema.String;
+        readonly role: Schema.Literals<readonly ["leader", "member"]>;
+        readonly ready: Schema.Boolean;
+        readonly joinedAt: Schema.Number;
+    }>>;
+    readonly searchTicketId: Schema.NullOr<Schema.String>;
+}>, typeof MatchmakingError>;
+
+export declare const partyCreateDescriptor: ActionProcedureDescriptor<"matchmaking.parties.create", Schema.Struct<{
+    readonly requestId: Schema.NonEmptyString;
+    readonly maxSize: Schema.optional<Schema.Number>;
+    readonly approval: Schema.optional<Schema.Literals<readonly ["open", "leader"]>>;
+}>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly leaderId: Schema.String;
+    readonly maxSize: Schema.Number;
+    readonly approval: Schema.Literals<readonly ["open", "leader"]>;
+    readonly createdAt: Schema.Number;
+    readonly members: Schema.$Array<Schema.Struct<{
+        readonly subjectId: Schema.String;
+        readonly role: Schema.Literals<readonly ["leader", "member"]>;
+        readonly ready: Schema.Boolean;
+        readonly joinedAt: Schema.Number;
+    }>>;
+    readonly searchTicketId: Schema.NullOr<Schema.String>;
+}>, typeof MatchmakingError>;
+
+export declare const partyInviteDescriptor: ActionProcedureDescriptor<"matchmaking.parties.invite", Schema.Struct<{
+    readonly partyId: Schema.NonEmptyString;
+    readonly subjectId: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly partyId: Schema.String;
+    readonly inviterId: Schema.String;
+    readonly expiresAt: Schema.Number;
+}>, typeof MatchmakingError>;
+
+export declare const partyInvitesDescriptor: QueryProcedureDescriptor<"matchmaking.parties.invites", Schema.Struct<{}>, Schema.$Array<Schema.Struct<{
+    readonly partyId: Schema.String;
+    readonly inviterId: Schema.String;
+    readonly expiresAt: Schema.Number;
+}>>, typeof MatchmakingError>;
+
+export declare const partyJoinDescriptor: ActionProcedureDescriptor<"matchmaking.parties.join", Schema.Struct<{
+    readonly partyId: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly leaderId: Schema.String;
+    readonly maxSize: Schema.Number;
+    readonly approval: Schema.Literals<readonly ["open", "leader"]>;
+    readonly createdAt: Schema.Number;
+    readonly members: Schema.$Array<Schema.Struct<{
+        readonly subjectId: Schema.String;
+        readonly role: Schema.Literals<readonly ["leader", "member"]>;
+        readonly ready: Schema.Boolean;
+        readonly joinedAt: Schema.Number;
+    }>>;
+    readonly searchTicketId: Schema.NullOr<Schema.String>;
+}>, typeof MatchmakingError>;
+
+export declare const partyKickDescriptor: ActionProcedureDescriptor<"matchmaking.parties.kick", Schema.Struct<{
+    readonly partyId: Schema.NonEmptyString;
+    readonly subjectId: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly leaderId: Schema.String;
+    readonly maxSize: Schema.Number;
+    readonly approval: Schema.Literals<readonly ["open", "leader"]>;
+    readonly createdAt: Schema.Number;
+    readonly members: Schema.$Array<Schema.Struct<{
+        readonly subjectId: Schema.String;
+        readonly role: Schema.Literals<readonly ["leader", "member"]>;
+        readonly ready: Schema.Boolean;
+        readonly joinedAt: Schema.Number;
+    }>>;
+    readonly searchTicketId: Schema.NullOr<Schema.String>;
+}>, typeof MatchmakingError>;
+
+export declare const partyLeaveDescriptor: ActionProcedureDescriptor<"matchmaking.parties.leave", Schema.Struct<{
+    readonly partyId: Schema.NonEmptyString;
+}>, Schema.Void, typeof MatchmakingError>;
+
+export declare const partyMineDescriptor: QueryProcedureDescriptor<"matchmaking.parties.mine", Schema.Struct<{}>, Schema.NullOr<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly leaderId: Schema.String;
+    readonly maxSize: Schema.Number;
+    readonly approval: Schema.Literals<readonly ["open", "leader"]>;
+    readonly createdAt: Schema.Number;
+    readonly members: Schema.$Array<Schema.Struct<{
+        readonly subjectId: Schema.String;
+        readonly role: Schema.Literals<readonly ["leader", "member"]>;
+        readonly ready: Schema.Boolean;
+        readonly joinedAt: Schema.Number;
+    }>>;
+    readonly searchTicketId: Schema.NullOr<Schema.String>;
+}>>, typeof MatchmakingError>;
+
+export declare const partyRpcClientImports: ReadonlyArray<PluginRpcClientDescriptor>;
+
+export declare const partySearchDescriptor: ActionProcedureDescriptor<"matchmaking.parties.search", Schema.Struct<{
+    readonly partyId: Schema.NonEmptyString;
+    readonly queue: Schema.NonEmptyString;
+    readonly requestId: Schema.NonEmptyString;
+    readonly preferences: Schema.$Record<Schema.String, Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly queue: Schema.String;
+    readonly state: Schema.Literals<readonly ["open", "matched", "assigned", "cancelled", "expired"]>;
+    readonly members: Schema.$Array<Schema.String>;
+    readonly attributes: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly createdAt: Schema.Number;
+    readonly expiresAt: Schema.Number;
+    readonly closedAt: Schema.NullOr<Schema.Number>;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>, typeof MatchmakingError>;
+
+export declare const partySetReadyDescriptor: ActionProcedureDescriptor<"matchmaking.parties.setReady", Schema.Struct<{
+    readonly partyId: Schema.NonEmptyString;
+    readonly ready: Schema.Boolean;
+}>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly leaderId: Schema.String;
+    readonly maxSize: Schema.Number;
+    readonly approval: Schema.Literals<readonly ["open", "leader"]>;
+    readonly createdAt: Schema.Number;
+    readonly members: Schema.$Array<Schema.Struct<{
+        readonly subjectId: Schema.String;
+        readonly role: Schema.Literals<readonly ["leader", "member"]>;
+        readonly ready: Schema.Boolean;
+        readonly joinedAt: Schema.Number;
+    }>>;
+    readonly searchTicketId: Schema.NullOr<Schema.String>;
+}>, typeof MatchmakingError>;
+
+export declare const partyTransferLeaderDescriptor: ActionProcedureDescriptor<"matchmaking.parties.transferLeader", Schema.Struct<{
+    readonly partyId: Schema.NonEmptyString;
+    readonly subjectId: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly leaderId: Schema.String;
+    readonly maxSize: Schema.Number;
+    readonly approval: Schema.Literals<readonly ["open", "leader"]>;
+    readonly createdAt: Schema.Number;
+    readonly members: Schema.$Array<Schema.Struct<{
+        readonly subjectId: Schema.String;
+        readonly role: Schema.Literals<readonly ["leader", "member"]>;
+        readonly ready: Schema.Boolean;
+        readonly joinedAt: Schema.Number;
+    }>>;
+    readonly searchTicketId: Schema.NullOr<Schema.String>;
+}>, typeof MatchmakingError>;
+
+export declare const statusDescriptor: QueryProcedureDescriptor<"matchmaking.status", Schema.Struct<{
+    readonly ticketId: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly id: Schema.String;
+    readonly queue: Schema.String;
+    readonly state: Schema.Literals<readonly ["open", "matched", "assigned", "cancelled", "expired"]>;
+    readonly members: Schema.$Array<Schema.String>;
+    readonly attributes: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly createdAt: Schema.Number;
+    readonly expiresAt: Schema.Number;
+    readonly closedAt: Schema.NullOr<Schema.Number>;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>, typeof MatchmakingError>;
+
+export { }

package/dist/rpc.js

@@ -0,0 +1,201 @@
+import { MatchmakingError as e } from "./errors.js";
+import { PARTIES_TABLE as t, PARTY_INVITES_TABLE as n, PARTY_MEMBERS_TABLE as r, PartyInviteSchema as i, PartySchema as a } from "./partyContract.js";
+import { ASSIGNMENTS_TABLE as o, MatchmakingAssignmentSchema as s, MatchmakingEstimateSchema as c, MatchmakingTicketSchema as l, TICKETS_TABLE as u } from "./ticketContract.js";
+import { MatchmakingDirectorPayload as d, MatchmakingDirectorResult as f } from "./directorContract.js";
+import { Schema as p } from "effect";
+import { defineAction as m, defineQuery as h } from "@voltro/protocol";
+// src/rpc.ts
+var g = "@voltro/plugin-matchmaking", _ = "Verified human identity and tenant come from the request; the service admits and reads only the caller-owned search.", v = m({
+	name: "matchmaking.enqueue",
+	input: p.Struct({
+		queue: p.NonEmptyString,
+		requestId: p.NonEmptyString,
+		preferences: p.Record(p.String, p.Unknown)
+	}),
+	output: l,
+	error: e,
+	openAccess: _
+}), y = m({
+	name: "matchmaking.cancel",
+	input: p.Struct({ ticketId: p.NonEmptyString }),
+	output: p.Void,
+	error: e,
+	openAccess: _
+}), b = h({
+	name: "matchmaking.status",
+	input: p.Struct({ ticketId: p.NonEmptyString }),
+	output: l,
+	source: u,
+	error: e,
+	openAccess: _
+}), x = h({
+	name: "matchmaking.estimate",
+	input: p.Struct({ queue: p.NonEmptyString }),
+	output: c,
+	source: u,
+	error: e,
+	openAccess: "An aggregate over matched searches of the verified caller's tenant for a declared queue: a median wait and a sample count, never ticket rows or identities."
+}), S = h({
+	name: "matchmaking.assignments",
+	input: p.Struct({}),
+	output: p.Array(s),
+	source: o,
+	error: e,
+	openAccess: _
+}), C = "The handler takes the verified caller as leader/member; inputs are intentions and the server owns roster, leader and capacity.", w = p.Struct({ partyId: p.NonEmptyString.pipe(p.check(p.isMaxLength(64))) }), T = p.Struct({
+	partyId: p.NonEmptyString.pipe(p.check(p.isMaxLength(64))),
+	subjectId: p.NonEmptyString.pipe(p.check(p.isMaxLength(256)))
+}), E = m({
+	name: "matchmaking.parties.create",
+	input: p.Struct({
+		requestId: p.NonEmptyString.pipe(p.check(p.isMaxLength(256))),
+		maxSize: p.optional(p.Number.pipe(p.check(p.isInt()), p.check(p.isBetween({
+			minimum: 1,
+			maximum: 256
+		})))),
+		approval: p.optional(p.Literals(["open", "leader"]))
+	}),
+	output: a,
+	error: e,
+	openAccess: C
+}), D = m({
+	name: "matchmaking.parties.invite",
+	input: T,
+	output: i,
+	error: e,
+	openAccess: C
+}), O = m({
+	name: "matchmaking.parties.join",
+	input: w,
+	output: a,
+	error: e,
+	openAccess: C
+}), k = m({
+	name: "matchmaking.parties.leave",
+	input: w,
+	output: p.Void,
+	error: e,
+	openAccess: C
+}), A = m({
+	name: "matchmaking.parties.kick",
+	input: T,
+	output: a,
+	error: e,
+	openAccess: C
+}), j = m({
+	name: "matchmaking.parties.setReady",
+	input: p.Struct({
+		partyId: p.NonEmptyString.pipe(p.check(p.isMaxLength(64))),
+		ready: p.Boolean
+	}),
+	output: a,
+	error: e,
+	openAccess: C
+}), M = m({
+	name: "matchmaking.parties.transferLeader",
+	input: T,
+	output: a,
+	error: e,
+	openAccess: C
+}), N = m({
+	name: "matchmaking.parties.search",
+	input: p.Struct({
+		partyId: p.NonEmptyString.pipe(p.check(p.isMaxLength(64))),
+		queue: p.NonEmptyString,
+		requestId: p.NonEmptyString,
+		preferences: p.Record(p.String, p.Unknown)
+	}),
+	output: l,
+	error: e,
+	openAccess: C
+}), P = m({
+	name: "matchmaking.parties.cancelSearch",
+	input: w,
+	output: a,
+	error: e,
+	openAccess: C
+}), F = h({
+	name: "matchmaking.parties.mine",
+	input: p.Struct({}),
+	output: p.NullOr(a),
+	source: [
+		t,
+		r,
+		u
+	],
+	error: e,
+	openAccess: C
+}), I = h({
+	name: "matchmaking.parties.invites",
+	input: p.Struct({}),
+	output: p.Array(i),
+	source: [n],
+	error: e,
+	openAccess: C
+}), L = [...[
+	"create",
+	"invite",
+	"join",
+	"leave",
+	"kick",
+	"setReady",
+	"transferLeader",
+	"search",
+	"cancelSearch"
+].map((e) => ({
+	tag: "matchmaking.parties." + e,
+	kind: "action",
+	import: {
+		module: "@voltro/plugin-matchmaking/rpc",
+		name: "party" + e[0].toUpperCase() + e.slice(1) + "Descriptor"
+	}
+})), ...["mine", "invites"].map((e) => ({
+	tag: "matchmaking.parties." + e,
+	kind: "query",
+	import: {
+		module: "@voltro/plugin-matchmaking/rpc",
+		name: "party" + e[0].toUpperCase() + e.slice(1) + "Descriptor"
+	}
+}))], R = [
+	{
+		tag: "matchmaking.enqueue",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-matchmaking/rpc",
+			name: "enqueueDescriptor"
+		}
+	},
+	{
+		tag: "matchmaking.cancel",
+		kind: "action",
+		import: {
+			module: "@voltro/plugin-matchmaking/rpc",
+			name: "cancelDescriptor"
+		}
+	},
+	{
+		tag: "matchmaking.status",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-matchmaking/rpc",
+			name: "statusDescriptor"
+		}
+	},
+	{
+		tag: "matchmaking.estimate",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-matchmaking/rpc",
+			name: "estimateDescriptor"
+		}
+	},
+	{
+		tag: "matchmaking.assignments",
+		kind: "query",
+		import: {
+			module: "@voltro/plugin-matchmaking/rpc",
+			name: "assignmentsDescriptor"
+		}
+	}
+];
+export { g as BASE_NAME, d as MatchmakingDirectorPayload, f as MatchmakingDirectorResult, S as assignmentsDescriptor, y as cancelDescriptor, v as enqueueDescriptor, x as estimateDescriptor, R as matchmakingRpcClientImports, P as partyCancelSearchDescriptor, E as partyCreateDescriptor, D as partyInviteDescriptor, I as partyInvitesDescriptor, O as partyJoinDescriptor, A as partyKickDescriptor, k as partyLeaveDescriptor, F as partyMineDescriptor, L as partyRpcClientImports, N as partySearchDescriptor, j as partySetReadyDescriptor, M as partyTransferLeaderDescriptor, b as statusDescriptor };