@voltro/plugin-social 0.0.0-stage → 0.87.0

package/dist/service.js

@@ -0,0 +1,354 @@
+import { SocialError as e, socialError as t } from "./errors.js";
+import { RecentPlayerSchema as n, SocialRelationSchema as r, SocialSettingsSchema as i, SuggestionSchema as a } from "./contract.js";
+import { socialRelationsTable as o } from "./relations.entity.js";
+import { socialRecentTable as s } from "./recent.entity.js";
+import { socialSettingsTable as c } from "./settings.entity.js";
+import { Effect as l, Schema as u } from "effect";
+import { createHash as d } from "node:crypto";
+import { and as f, eq as p, gte as m, lt as h, or as g, queryFor as _ } from "@voltro/database";
+//#region src/service.ts
+var v = (e) => d("sha256").update(JSON.stringify(e)).digest("hex"), y = (n) => n instanceof e ? n : t("unavailable"), b = (e) => l.tryPromise({
+	try: e,
+	catch: y
+}), x = (e) => {
+	if (typeof e != "string" || !e.trim() || e.length > 256 || e.includes("\0") || e === "~") throw t("invalid_input");
+}, S = (e) => {
+	if (e.type !== "user") throw t("identity_required");
+	return x(e.tenantId), x(e.id), {
+		tenantId: e.tenantId,
+		ownerId: e.id
+	};
+}, C = (e) => {
+	let n = e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : NaN;
+	if (!Number.isSafeInteger(n) || n < 0) throw t("unavailable");
+	return n;
+}, w = (e) => u.decodeUnknownSync(r)({
+	...e,
+	createdAt: C(e.createdAt),
+	respondedAt: e.respondedAt === null ? null : C(e.respondedAt)
+}), T = (e) => u.decodeUnknownSync(n)({
+	...e,
+	at: C(e.at)
+}), E = (e) => ({
+	ownerId: e,
+	requestsFrom: "anyone",
+	showOnline: !1,
+	showActivity: !1,
+	allowPartyInvites: "friends",
+	metadata: {}
+}), D = (e, n, r) => {
+	let d = () => {
+		let e = n.now();
+		if (!Number.isSafeInteger(e) || e < 0 || e > 864e13) throw t("unavailable");
+		return e;
+	}, D = (e, t) => e < t ? [e, t] : [t, e], O = (e, t, n, r) => v([e, ...r === "friend" ? D(t, n) : [t, n]]), k = (e, t, n, r) => "srel_" + v([O(e, t, n, r), r]).slice(0, 56), A = (e, t) => "sset_" + v([e, t]).slice(0, 56), j = async (e, n, r) => {
+		let a = (await e.query(_(c).where(p("id", A(n, r))).limit(1).descriptor))[0];
+		if (!a) return E(r);
+		if (a.tenantId !== n || a.ownerId !== r) throw t("unavailable");
+		return u.decodeUnknownSync(i)(a);
+	}, M = async (t, n) => {
+		for (let r of [...new Set(n)].sort()) {
+			let n = A(t, r);
+			try {
+				await e.insertIgnore(c.tableName, {
+					...E(r),
+					id: n,
+					tenantId: t,
+					admission: 0
+				}, { conflictColumns: ["id"] });
+			} catch (i) {
+				let a = (await e.query(_(c).where(p("id", n)).limit(1).descriptor))[0];
+				if (!a || a.tenantId !== t || a.ownerId !== r) throw i;
+			}
+		}
+	}, N = async (n, r, i) => (await M(n, r), e.transactional(async (e) => {
+		for (let i of [...new Set(r)].sort((e, t) => A(n, e).localeCompare(A(n, t)))) {
+			let r = A(n, i);
+			if (await e.updateMany(c.tableName, { admission: 0 }, { where: p("id", r) }) !== 1) throw t("unavailable");
+			let a = (await e.query(_(c).where(p("id", r)).forUpdate().limit(1).descriptor))[0];
+			if (!a || a.tenantId !== n || a.ownerId !== i) throw t("unavailable");
+		}
+		return i(e);
+	})), P = async (e, n, r, i, a) => {
+		let s = (await e.query(_(o).where(p("id", k(n, r, i, a))).limit(1).descriptor))[0], [c, l] = a === "friend" ? D(r, i) : [r, i];
+		if (s && (s.tenantId !== n || s.fromId !== c || s.toId !== l || s.kind !== a || s.pairKey !== O(n, r, i, a))) throw t("unavailable");
+		return s;
+	}, F = async (e, t, n, r) => await P(e, t, n, r, "block") !== void 0 || await P(e, t, r, n, "block") !== void 0, I = async (e, n, r, i, a) => {
+		let s = f(p("tenantId", n), p("kind", i), i === "block" || i === "favorite" ? p("fromId", r) : g(p("fromId", r), p("toId", r))), c = await e.query(_(o).where(s).orderBy("id", "asc").limit(a + 1).descriptor);
+		if (c.length > a || c.some((e) => e.tenantId !== n || e.kind !== i || (i === "block" || i === "favorite" ? e.fromId !== r : e.fromId !== r && e.toId !== r))) throw t("unavailable");
+		return c;
+	}, L = async (e, r, i) => (await I(e, r, i, "friend", n.maxFriends)).map((e) => {
+		let n = e.fromId === i ? e.toId : e.fromId;
+		if (typeof n != "string") throw t("unavailable");
+		return n;
+	}), R = async (e, t, n, r) => {
+		let i = new Set(await L(e, t, n));
+		return (await L(e, t, r)).filter((e) => i.has(e)).length;
+	}, z = async (e, t, n, r, i) => {
+		let a = await P(e, t, n, r, i);
+		if (a) return a;
+		let [s, c] = i === "friend" ? D(n, r) : [n, r];
+		return e.insert(o.tableName, {
+			id: k(t, n, r, i),
+			tenantId: t,
+			fromId: s,
+			toId: c,
+			pairKey: O(t, n, r, i),
+			kind: i,
+			createdAt: new Date(d()),
+			respondedAt: i === "friend" ? new Date(d()) : null,
+			note: null,
+			metadata: {}
+		});
+	}, B = async (e, t, n, r, i) => {
+		let a = await P(e, t, n, r, i);
+		a && await e.delete(o.tableName, String(a.id));
+	}, V = (e, n, r) => b(async () => {
+		let { tenantId: i, ownerId: a } = S(e);
+		if (x(n), a === n) throw t("invalid_input");
+		return N(i, [a, n], (e) => r(e, i, a));
+	}), H = async (e, t, n, r) => {
+		await B(e, t, n, r, "request"), await B(e, t, r, n, "request");
+	}, U = {
+		request: (e, i) => l.gen(function* () {
+			let a = yield* l.try({
+				try: () => {
+					let n = S(e);
+					if (x(i), n.ownerId === i) throw t("invalid_input");
+					return n;
+				},
+				catch: y
+			}), o = yield* l.try({
+				try: d,
+				catch: y
+			}), s = yield* r.consume("social:request:" + v([a.tenantId, a.ownerId]), {
+				limit: n.requestLimit,
+				windowMs: n.requestWindowMs,
+				algorithm: "fixed-window",
+				burst: n.requestLimit
+			}, o).pipe(l.catchDefect(() => l.fail(t("unavailable"))));
+			return s.failOpenReason === void 0 ? s.allowed ? yield* V(e, i, async (e, r, a) => {
+				if (await F(e, r, a, i)) throw t("blocked");
+				let o = await P(e, r, a, i, "friend");
+				if (o) return w(o);
+				let s = await P(e, r, a, i, "request");
+				if (s) return w(s);
+				let c = await j(e, r, i);
+				if (n.strategies.requestPolicy({
+					settings: c,
+					mutualFriends: await R(e, r, a, i)
+				}) !== !0) throw t("request_refused");
+				for (let o of [a, i]) {
+					if ((await I(e, r, o, "friend", n.maxFriends)).length >= n.maxFriends) throw t("friend_limit");
+					if ((await I(e, r, o, "request", n.maxPendingRequests)).length >= n.maxPendingRequests) throw t("pending_limit");
+				}
+				return w(await z(e, r, a, i, "request"));
+			}) : yield* l.fail(t("rate_limited")) : yield* l.fail(t("unavailable"));
+		}),
+		accept: (e, r) => V(e, r, async (e, i, a) => {
+			if (await F(e, i, a, r)) throw t("blocked");
+			let o = await P(e, i, a, r, "friend");
+			if (o) return w(o);
+			if (!await P(e, i, r, a, "request")) throw t("not_found");
+			for (let o of [a, r]) if ((await L(e, i, o)).length >= n.maxFriends) throw t("friend_limit");
+			let s = w(await z(e, i, a, r, "friend"));
+			return await H(e, i, a, r), s;
+		}),
+		decline: (e, t) => V(e, t, (e, n, r) => B(e, n, t, r, "request")),
+		cancel: (e, t) => V(e, t, (e, n, r) => B(e, n, r, t, "request")),
+		remove: (e, t) => V(e, t, async (e, n, r) => {
+			await B(e, n, r, t, "friend"), await B(e, n, r, t, "favorite"), await B(e, n, t, r, "favorite");
+		}),
+		block: (e, t) => V(e, t, async (e, n, r) => {
+			await z(e, n, r, t, "block"), await H(e, n, r, t), await B(e, n, r, t, "friend"), await B(e, n, r, t, "favorite"), await B(e, n, t, r, "favorite");
+		}),
+		unblock: (e, t) => V(e, t, (e, n, r) => B(e, n, r, t, "block")),
+		favorite: (e, n, r) => V(e, n, async (e, i, a) => {
+			if (typeof r != "boolean") throw t("invalid_input");
+			if (!r) return B(e, i, a, n, "favorite");
+			if (await F(e, i, a, n)) throw t("blocked");
+			if (!await P(e, i, a, n, "friend")) throw t("not_found");
+			await z(e, i, a, n, "favorite");
+		}),
+		setSettings: (e, n) => b(async () => {
+			let { tenantId: r, ownerId: a } = S(e);
+			if (Object.keys(n).some((e) => ![
+				"requestsFrom",
+				"showOnline",
+				"showActivity",
+				"allowPartyInvites"
+			].includes(e))) throw t("invalid_input");
+			return N(r, [a], async (e) => {
+				let t = u.decodeUnknownSync(i)({
+					...await j(e, r, a),
+					...n,
+					ownerId: a
+				});
+				return await e.update(c.tableName, A(r, a), t), t;
+			});
+		}),
+		getSettings: (t) => b(() => {
+			let { tenantId: n, ownerId: r } = S(t);
+			return j(e, n, r);
+		}),
+		friends: (t) => b(async () => {
+			let { tenantId: r, ownerId: i } = S(t);
+			return (await I(e, r, i, "friend", n.maxFriends)).map(w);
+		}),
+		favorites: (t) => b(async () => {
+			let { tenantId: r, ownerId: i } = S(t);
+			return (await I(e, r, i, "favorite", n.maxFriends)).map(w);
+		}),
+		requests: (t) => b(async () => {
+			let { tenantId: r, ownerId: i } = S(t);
+			return (await I(e, r, i, "request", n.maxPendingRequests)).map(w);
+		}),
+		blocked: (t) => b(async () => {
+			let { tenantId: r, ownerId: i } = S(t);
+			return (await I(e, r, i, "block", n.maxExportRows)).map(w);
+		}),
+		recent: (r) => b(async () => {
+			let { tenantId: i, ownerId: a } = S(r), o = await e.query(_(s).where(f(p("tenantId", i), p("ownerId", a), m("at", new Date(Math.max(0, d() - n.recentRetentionMs))))).orderBy("at", "desc").orderBy("id", "asc").limit(n.recentLimit).descriptor), c = [];
+			for (let n of o) {
+				if (n.tenantId !== i || n.ownerId !== a || typeof n.otherId != "string") throw t("unavailable");
+				await F(e, i, a, n.otherId) || c.push(T(n));
+			}
+			return c;
+		}),
+		suggestions: (r) => b(async () => {
+			let { tenantId: i, ownerId: o } = S(r), c = new Set(await L(e, i, o)), l = /* @__PURE__ */ new Map();
+			for (let r of c) for (let a of await L(e, i, r)) {
+				if (a === o || c.has(a) || await F(e, i, o, a)) continue;
+				let r = l.get(a), u = await e.query(_(s).where(f(p("tenantId", i), p("ownerId", o), p("otherId", a), m("at", new Date(Math.max(0, d() - n.recentRetentionMs))))).limit(n.recentLimit).descriptor);
+				if (u.some((e) => e.tenantId !== i || e.ownerId !== o || e.otherId !== a)) throw t("unavailable");
+				l.set(a, {
+					subjectId: a,
+					mutualFriends: (r?.mutualFriends ?? 0) + 1,
+					recentMatches: u.length
+				});
+			}
+			let h = n.strategies.suggestions([...l.values()], n.suggestionLimit);
+			if (h.length > n.suggestionLimit || new Set(h.map((e) => e.subjectId)).size !== h.length) throw t("unavailable");
+			for (let e of h) {
+				u.decodeUnknownSync(a)(e);
+				let n = l.get(e.subjectId);
+				if (!n || n.mutualFriends !== e.mutualFriends || n.recentMatches !== e.recentMatches) throw t("unavailable");
+			}
+			return h;
+		})
+	}, W = {
+		isBlocked: (t, n) => b(async () => {
+			let { tenantId: r, ownerId: i } = S(t);
+			return x(n), F(e, r, i, n);
+		}),
+		blockPairs: (r, i) => b(async () => {
+			if (r.type !== "user" && !(r.type === "serviceAccount" && r.scopes?.includes("social:blocks:read"))) throw t("identity_required");
+			if (x(r.tenantId), i.length > n.maxMatchParticipants || new Set(i).size !== i.length) throw t("invalid_input");
+			i.forEach(x);
+			let a = [];
+			for (let t = 0; t < i.length; t++) for (let n = t + 1; n < i.length; n++) {
+				let o = i[t], s = i[n];
+				(r.type !== "user" || o === r.id || s === r.id) && await F(e, r.tenantId, o, s) && a.push(D(o, s));
+			}
+			return a;
+		}),
+		canMessage: (t, r) => b(async () => {
+			let { tenantId: i, ownerId: a } = S(t);
+			if (x(r), r === a || await F(e, i, a, r)) return !1;
+			if (await P(e, i, a, r, "friend")) return !0;
+			let o = await j(e, i, r);
+			return n.strategies.requestPolicy({
+				settings: o,
+				mutualFriends: await R(e, i, a, r)
+			}) === !0;
+		}),
+		canInvite: (t, n) => b(async () => {
+			let { tenantId: r, ownerId: i } = S(t);
+			return x(n), n === i || await F(e, r, i, n) ? !1 : (await j(e, r, n)).allowPartyInvites === "anyone" || await P(e, r, i, n, "friend") !== void 0;
+		}),
+		recordRecent: (e, r) => b(async () => {
+			if (e.type !== "system" && !(e.type === "serviceAccount" && e.tenantId === r.tenantId && e.scopes?.includes("social:recent:write"))) throw t("identity_required");
+			if (x(r.tenantId), x(r.context), r.participants.length > n.maxMatchParticipants || new Set(r.participants).size !== r.participants.length) throw t("invalid_input");
+			r.participants.forEach(x);
+			let i = r.at ?? d(), a = d();
+			if (!Number.isSafeInteger(i) || i < 0 || i > a || i < a - n.recentRetentionMs) throw t("invalid_input");
+			await N(r.tenantId, r.participants, async (e) => {
+				for (let o of r.participants) {
+					for (let a of r.participants) {
+						if (o === a || n.strategies.recentPolicy({
+							ownerId: o,
+							otherId: a,
+							context: r.context,
+							at: i
+						}) !== !0 || await F(e, r.tenantId, o, a)) continue;
+						let c = "srec_" + v([
+							r.tenantId,
+							o,
+							a,
+							r.context
+						]).slice(0, 56), l = (await e.query(_(s).where(p("id", c)).limit(1).descriptor))[0];
+						if (l) {
+							if (l.tenantId !== r.tenantId || l.ownerId !== o || l.otherId !== a || l.context !== r.context) throw t("unavailable");
+							C(l.at) < i && await e.update(s.tableName, c, { at: new Date(i) });
+						} else await e.insert(s.tableName, {
+							id: c,
+							tenantId: r.tenantId,
+							ownerId: o,
+							otherId: a,
+							context: r.context,
+							at: new Date(i),
+							metadata: {}
+						});
+					}
+					await e.deleteMany(s.tableName, { where: f(p("tenantId", r.tenantId), p("ownerId", o), h("at", new Date(Math.max(0, a - n.recentRetentionMs)))) });
+					let c = await e.query(_(s).where(f(p("tenantId", r.tenantId), p("ownerId", o))).orderBy("at", "desc").orderBy("id", "asc").descriptor);
+					for (let i of c.slice(n.recentLimit)) {
+						if (i.tenantId !== r.tenantId || i.ownerId !== o) throw t("unavailable");
+						await e.delete(s.tableName, String(i.id));
+					}
+				}
+			});
+		})
+	}, G = async (e, r) => {
+		if (r.tenantId === null) throw t("identity_required");
+		x(r.tenantId), x(r.subjectId);
+		let i = [
+			o,
+			s,
+			c
+		], a = [], l = 0;
+		for (let c of i) {
+			let i = c === o ? g(p("fromId", r.subjectId), p("toId", r.subjectId)) : c === s ? g(p("ownerId", r.subjectId), p("otherId", r.subjectId)) : p("ownerId", r.subjectId), u = await e.query(_(c).where(f(p("tenantId", r.tenantId), i)).orderBy("id", "asc").limit(n.maxExportRows + 1).descriptor);
+			if (l += u.length, l > n.maxExportRows) throw t("export_limit");
+			if (u.some((e) => e.tenantId !== r.tenantId || (c === o ? e.fromId !== r.subjectId && e.toId !== r.subjectId : c === s ? e.ownerId !== r.subjectId && e.otherId !== r.subjectId : e.ownerId !== r.subjectId))) throw t("unavailable");
+			a.push({
+				table: c.tableName,
+				rows: u
+			});
+		}
+		return a;
+	};
+	return {
+		service: U,
+		blockPort: W,
+		exportSubject: (t) => b(() => e.transactional(async (e) => {
+			let n = await G(e, t);
+			return JSON.parse(JSON.stringify(n.map(({ table: e, rows: t }) => ({
+				table: e,
+				rows: t.map(({ admission: e, ...t }) => t)
+			}))));
+		})),
+		eraseSubject: (e) => b(async () => {
+			if (e.tenantId === null) throw t("identity_required");
+			await N(e.tenantId, [e.subjectId], async (t) => {
+				for (let { table: n, rows: r } of await G(t, e)) for (let e of r) await t.delete(n, String(e.id));
+			});
+		}),
+		pruneRecent: (r) => b(async () => {
+			if (r.type !== "serviceAccount" || !r.scopes?.includes("social:recent:write")) throw t("identity_required");
+			x(r.tenantId), await e.deleteMany(s.tableName, { where: f(p("tenantId", r.tenantId), h("at", new Date(Math.max(0, d() - n.recentRetentionMs)))) });
+		})
+	};
+};
+//#endregion
+export { D as dataStoreSocial };

package/dist/settings.entity.js

@@ -0,0 +1,20 @@
+import { SETTINGS_TABLE as e } from "./contract.js";
+import { boolean as t, id as n, integer as r, json as i, table as a, text as o } from "@voltro/database";
+//#region src/settings.entity.ts
+var s = a(e, {
+	id: n({ prefix: "ssettings" }),
+	tenantId: o().maxLength(256).externalId().sensitive("pii"),
+	ownerId: o().maxLength(256).externalId().sensitive("pii"),
+	requestsFrom: o().maxLength(18).oneOf([
+		"anyone",
+		"friends-of-friends",
+		"nobody"
+	]).safe(),
+	showOnline: t().safe(),
+	showActivity: t().safe(),
+	allowPartyInvites: o().maxLength(16).oneOf(["friends", "anyone"]).safe(),
+	admission: r().serverOnly(),
+	metadata: i().sensitive("pii")
+}).index(["tenantId", "ownerId"]);
+//#endregion
+export { s as socialSettingsTable };

package/dist/social-app/events/social.accepted.event.ts

@@ -0,0 +1 @@
+export { accepted as default } from '@voltro/plugin-social/events'

package/dist/social-app/events/social.requested.event.ts

@@ -0,0 +1 @@
+export { requested as default } from '@voltro/plugin-social/events'

package/dist/social-app/subscribers/social.relations.subscribe.ts

@@ -0,0 +1,4 @@
+import { defineSubscriber } from '@voltro/runtime'
+import { socialEventTenant, publishSocialChange } from '@voltro/plugin-social/events/server'
+export default defineSubscriber({ table: '_voltro_social_relations', on: ['insert', 'update', 'delete'], once: true,
+  eventTenant: socialEventTenant, handler: publishSocialChange })

package/dist/strategies.d.ts

@@ -0,0 +1,85 @@
+import { RedisStoreOptions } from '@voltro/plugin-ratelimit';
+import { Schema } from 'effect';
+
+export declare const defaultSocialStrategies: SocialStrategies;
+
+export declare const distinctRecentPeers: (input: RecentPolicyInput) => boolean;
+
+export declare const mutualMatchSuggestions: (candidates: ReadonlyArray<SocialSuggestion>, limit: number) => ReadonlyArray<SocialSuggestion>;
+
+export declare interface RecentPolicyInput {
+    readonly ownerId: string;
+    readonly otherId: string;
+    readonly context: string;
+    readonly at: number;
+}
+
+export declare const recipientRequestPolicy: ({ settings, mutualFriends }: RequestPolicyInput) => boolean;
+
+export declare interface RequestPolicyInput {
+    readonly settings: SocialSettings;
+    readonly mutualFriends: number;
+}
+
+export declare type ResolvedSocialOptions = ReturnType<typeof resolveSocialOptions>;
+
+export declare const resolveSocialOptions: (options?: SocialOptions) => Readonly<{
+    maxFriends: number;
+    maxPendingRequests: number;
+    recentLimit: number;
+    recentRetentionMs: number;
+    maxMatchParticipants: number;
+    maxExportRows: number;
+    requestLimit: number;
+    requestWindowMs: number;
+    suggestionLimit: number;
+    strategies: Readonly<{
+        suggestions: typeof mutualMatchSuggestions;
+        requestPolicy: (input: RequestPolicyInput) => boolean;
+        recentPolicy: (input: RecentPolicyInput) => boolean;
+    }>;
+    rateLimit: RedisStoreOptions | undefined;
+    now: () => number;
+}>;
+
+export declare interface SocialOptions {
+    readonly maxFriends?: number;
+    readonly maxPendingRequests?: number;
+    readonly recentLimit?: number;
+    readonly recentRetentionMs?: number;
+    readonly maxMatchParticipants?: number;
+    readonly maxExportRows?: number;
+    readonly requestLimit?: number;
+    readonly requestWindowMs?: number;
+    readonly suggestionLimit?: number;
+    readonly strategies?: Partial<SocialStrategies>;
+    readonly rateLimit?: RedisStoreOptions;
+    readonly now?: () => number;
+}
+
+declare type SocialSettings = typeof SocialSettingsSchema.Type;
+
+declare const SocialSettingsSchema: Schema.Struct<{
+    readonly ownerId: Schema.String;
+    readonly requestsFrom: Schema.Literals<readonly ["anyone", "friends-of-friends", "nobody"]>;
+    readonly showOnline: Schema.Boolean;
+    readonly showActivity: Schema.Boolean;
+    readonly allowPartyInvites: Schema.Literals<readonly ["friends", "anyone"]>;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>;
+
+export declare interface SocialStrategies {
+    readonly suggestions: typeof mutualMatchSuggestions;
+    readonly requestPolicy: (input: RequestPolicyInput) => boolean;
+    readonly recentPolicy: (input: RecentPolicyInput) => boolean;
+}
+
+declare type SocialSuggestion = typeof SuggestionSchema.Type;
+
+declare const SuggestionSchema: Schema.Struct<{
+    readonly subjectId: Schema.String;
+    readonly mutualFriends: Schema.Number;
+    readonly recentMatches: Schema.Number;
+}>;
+
+export { }

package/dist/strategies.js

@@ -0,0 +1,40 @@
+import { socialError as e } from "./errors.js";
+//#region src/strategies.ts
+var t = ({ settings: e, mutualFriends: t }) => e.requestsFrom === "anyone" || e.requestsFrom === "friends-of-friends" && t > 0, n = (e, t) => [...e].sort((e, t) => t.recentMatches - e.recentMatches || t.mutualFriends - e.mutualFriends || (e.subjectId < t.subjectId ? -1 : +(e.subjectId > t.subjectId))).slice(0, t), r = (e) => e.ownerId !== e.otherId, i = Object.freeze({
+	suggestions: n,
+	requestPolicy: t,
+	recentPolicy: r
+}), a = (t = {}) => {
+	let n = {
+		maxFriends: t.maxFriends ?? 500,
+		maxPendingRequests: t.maxPendingRequests ?? 100,
+		recentLimit: t.recentLimit ?? 50,
+		recentRetentionMs: t.recentRetentionMs ?? 2592e6,
+		maxMatchParticipants: t.maxMatchParticipants ?? 64,
+		maxExportRows: t.maxExportRows ?? 1e4,
+		requestLimit: t.requestLimit ?? 10,
+		requestWindowMs: t.requestWindowMs ?? 6e4,
+		suggestionLimit: t.suggestionLimit ?? 20,
+		strategies: Object.freeze({
+			...i,
+			...t.strategies
+		}),
+		rateLimit: t.rateLimit,
+		now: t.now ?? Date.now
+	};
+	for (let [t, r] of [
+		[n.maxFriends, 1e4],
+		[n.maxPendingRequests, 1e4],
+		[n.recentLimit, 1e3],
+		[n.recentRetentionMs, 31536e7],
+		[n.maxMatchParticipants, 256],
+		[n.maxExportRows, 1e5],
+		[n.requestLimit, 1e4],
+		[n.requestWindowMs, 864e5],
+		[n.suggestionLimit, 100]
+	]) if (!Number.isSafeInteger(t) || t < 1 || t > r) throw e("invalid_input");
+	if (typeof n.now != "function" || Object.values(n.strategies).some((e) => typeof e != "function")) throw e("invalid_input");
+	return Object.freeze(n);
+};
+//#endregion
+export { i as defaultSocialStrategies, r as distinctRecentPeers, n as mutualMatchSuggestions, t as recipientRequestPolicy, a as resolveSocialOptions };

package/dist/testing.d.ts

@@ -0,0 +1,122 @@
+import { Context } from 'effect';
+import { Effect } from 'effect';
+import { Layer } from 'effect';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
+
+export declare const fakeSocialBlockLayer: (overrides?: Partial<SocialBlockService>) => Layer.Layer<SocialBlockPort, never, never>;
+
+export declare const fakeSocialBlockService: (overrides?: Partial<SocialBlockService>) => SocialBlockService;
+
+declare interface RecentPolicyInput {
+    readonly ownerId: string;
+    readonly otherId: string;
+    readonly context: string;
+    readonly at: number;
+}
+
+declare interface RecordRecentInput {
+    readonly tenantId: string;
+    readonly participants: ReadonlyArray<string>;
+    readonly context: string;
+    readonly at?: number;
+}
+
+declare interface RequestPolicyInput {
+    readonly settings: SocialSettings;
+    readonly mutualFriends: number;
+}
+
+export declare const socialBlockFakeLayer: Layer.Layer<SocialBlockPort, never, never>;
+
+declare class SocialBlockPort extends SocialBlockPort_base {
+}
+
+declare const SocialBlockPort_base: Context.ServiceClass<SocialBlockPort, "@voltro/SocialBlockPort", SocialBlockService>;
+
+export declare const socialBlockPortFixture: {
+    kind: "port";
+    tag: typeof SocialBlockPort;
+    fakeLayer: Layer.Layer<SocialBlockPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<boolean | "unavailable" | "identity_required" | "invalid_input" | "blocked" | "request_refused" | "not_found" | "friend_limit" | "pending_limit" | "rate_limited" | "export_limit", never, never>;
+        expected: string;
+    };
+};
+
+/** Chat, matchmaking and party admission depend on this port, never Social SQL. */
+declare interface SocialBlockService {
+    readonly isBlocked: (subject: Subject, otherId: string) => Effect.Effect<boolean, SocialError>;
+    readonly blockPairs: (subject: Subject, subjectIds: ReadonlyArray<string>) => Effect.Effect<ReadonlyArray<readonly [string, string]>, SocialError>;
+    readonly canMessage: (subject: Subject, otherId: string) => Effect.Effect<boolean, SocialError>;
+    readonly canInvite: (subject: Subject, otherId: string) => Effect.Effect<boolean, SocialError>;
+    readonly recordRecent: (subject: Subject, input: RecordRecentInput) => Effect.Effect<void, SocialError>;
+}
+
+declare class SocialError extends SocialError_base {
+}
+
+declare const SocialError_base: Schema.Class<SocialError, Schema.TaggedStruct<"SocialError", {
+    readonly code: Schema.Literals<readonly ["identity_required", "invalid_input", "blocked", "request_refused", "not_found", "friend_limit", "pending_limit", "rate_limited", "unavailable", "export_limit"]>;
+}>, YieldableError>;
+
+export declare const socialRecentPolicyFixture: {
+    kind: "slot";
+    defaultImplementation: (input: RecentPolicyInput) => boolean;
+    defaultProbe: {
+        run: () => Effect.Effect<boolean, never, never>;
+        expected: boolean;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<boolean, never, never>;
+        expected: boolean;
+    };
+};
+
+export declare const socialRequestPolicyFixture: {
+    kind: "slot";
+    defaultImplementation: ({ settings, mutualFriends }: RequestPolicyInput) => boolean;
+    defaultProbe: {
+        run: () => Effect.Effect<boolean, never, never>;
+        expected: boolean;
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<boolean, never, never>;
+        expected: boolean;
+    };
+};
+
+declare type SocialSettings = typeof SocialSettingsSchema.Type;
+
+declare const SocialSettingsSchema: Schema.Struct<{
+    readonly ownerId: Schema.String;
+    readonly requestsFrom: Schema.Literals<readonly ["anyone", "friends-of-friends", "nobody"]>;
+    readonly showOnline: Schema.Boolean;
+    readonly showActivity: Schema.Boolean;
+    readonly allowPartyInvites: Schema.Literals<readonly ["friends", "anyone"]>;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>;
+
+declare type SocialSuggestion = typeof SuggestionSchema.Type;
+
+export declare const socialSuggestionsFixture: {
+    kind: "slot";
+    defaultImplementation: (candidates: ReadonlyArray< SocialSuggestion>, limit: number) => ReadonlyArray< SocialSuggestion>;
+    defaultProbe: {
+        run: () => Effect.Effect<string[], never, never>;
+        expected: string[];
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<string[], never, never>;
+        expected: string[];
+    };
+};
+
+declare const SuggestionSchema: Schema.Struct<{
+    readonly subjectId: Schema.String;
+    readonly mutualFriends: Schema.Number;
+    readonly recentMatches: Schema.Number;
+}>;
+
+export { }