@voltro/plugin-chat 0.0.0-stage → 0.87.0

package/dist/index.js

@@ -0,0 +1,181 @@
+import { ChatError as e, chatError as t } from "./errors.js";
+import { chatAdmissionsTable as n } from "./admissions.entity.js";
+import { chatEvidenceTable as r } from "./evidence.entity.js";
+import { CHAT_MAX_MESSAGE_VERSION as i, CHAT_MEDIA_SWEEP_BATCH_SIZE as a, CHAT_RETENTION_BATCH_SIZE as o, CHAT_RETENTION_RUN_BATCHES as s } from "./contract.js";
+import { chatMediaTable as c } from "./media.entity.js";
+import { chatRetentionTable as l } from "./retention.entity.js";
+import { mentioned as u, messageChanged as d, typing as f } from "./events.js";
+import { chatChannelsTable as p } from "./channels.entity.js";
+import { chatMembersTable as m } from "./members.entity.js";
+import { chatMessagesTable as h } from "./messages.entity.js";
+import { dataStoreChat as g } from "./service.js";
+import { BASE_NAME as _, chatRpcClientImports as v } from "./rpc.js";
+import { chatRpcRoutes as y } from "./rpcRoutes.js";
+import { defaultChatStrategies as b, resolveChatOptions as x } from "./strategies.js";
+import { chatStatus as S } from "./inspect.js";
+import { ChatAdministration as C } from "./server.js";
+import { defineLicensedGamePlugin as w } from "@voltro/plugin-licensing/gate";
+import { Effect as T, Layer as E } from "effect";
+import { fileURLToPath as D } from "node:url";
+import { replicaEvidence as O } from "@voltro/protocol/identity";
+import { redisStore as k } from "@voltro/plugin-ratelimit";
+//#region src/index.ts
+var A = {
+	slots: {
+		moderate: {
+			defaultExport: "keywordChatModeration",
+			fixtureExport: "chatModerationFixture"
+		},
+		rateLimit: {
+			defaultExport: "fixedChatRateBudgets",
+			fixtureExport: "chatRateLimitFixture"
+		},
+		mentionResolver: {
+			defaultExport: "playerChatMentions",
+			fixtureExport: "chatMentionResolverFixture"
+		},
+		retention: {
+			defaultExport: "channelChatRetention",
+			fixtureExport: "chatRetentionFixture"
+		},
+		moderateMedia: {
+			defaultExport: "typedChatMedia",
+			fixtureExport: "chatMediaModerationFixture"
+		}
+	},
+	ports: {},
+	events: [
+		d.name,
+		u.name,
+		f.name
+	]
+}, j = (i = {}) => {
+	let a = x(i), o = k(a.rateLimit), s, u, d = !1, b = (e) => T.suspend(() => u === void 0 ? T.fail(t("unavailable")) : e(u)), A = (e, n, r) => {
+		try {
+			let t = structuredClone(e), i = structuredClone(n);
+			return b((e) => r(e, t, i));
+		} catch {
+			return T.fail(t("invalid_input"));
+		}
+	};
+	return w({
+		name: _,
+		description: "Membership-filtered durable chat with replaceable rule slots.",
+		eventClientPolicies: [{
+			id: f.clientPolicy,
+			admit: (e) => b((t) => t.typingPolicy.admit(e)),
+			deliver: (e) => b((t) => t.typingPolicy.deliver(e)),
+			monitor: (e) => b((t) => t.typingPolicy.monitor(e))
+		}],
+		services: E.succeed(C, {
+			readReportEvidence: (e, t) => A(e, t, (e, t, n) => e.readReportEvidence(t, n)),
+			collectReportContext: (e, t) => A(e, t, (e, t, n) => e.collectReportContext(t, n)),
+			prune: (e) => A(e, null, (e, t) => e.prune(t)),
+			sweepMedia: (e) => A(e, null, (e, t) => e.sweepMedia(t)),
+			canNotifyMention: (e, t) => A(e, t, (e, t, n) => e.canNotifyMention(t, n)),
+			createChannel: (e, t) => A(e, t, (e, t, n) => e.createChannel(t, n)),
+			addMember: (e, t) => A(e, t, (e, t, n) => e.addMember(t, n)),
+			removeMember: (e, t) => A(e, t, (e, t, n) => e.removeMember(t, n)),
+			archiveMatch: (e, t) => A(e, t, (e, t, n) => e.archiveMatch(t, n))
+		}),
+		permissions: ["store:write", "inspect:read"],
+		routes: y({
+			mentionCandidates: (e, t) => A(e, t, (e, t, n) => e.service.mentionCandidates(t, n)),
+			authors: (e, t) => A(e, t, (e, t, n) => e.service.authors(t, n)),
+			prepareTyping: (e, t) => b((n) => n.service.prepareTyping(e, t)),
+			dm: (e, t) => b((n) => n.service.dm(e, t)),
+			send: (e, t) => b((n) => n.service.send(e, t)),
+			edit: (e, t) => b((n) => n.service.edit(e, t)),
+			remove: (e, t) => b((n) => n.service.remove(e, t)),
+			messages: (e, t) => b((n) => n.service.messages(e, t)),
+			channel: (e, t) => b((n) => n.service.channel(e, t)),
+			membership: (e, t) => b((n) => n.service.membership(e, t)),
+			unread: (e) => b((t) => t.service.unread(e)),
+			original: (e, t) => b((n) => n.service.original(e, t)),
+			mediaUrl: (e, t) => b((n) => n.service.mediaUrl(e, t)),
+			channels: (e) => b((t) => t.service.channels(e)),
+			markRead: (e, t, n) => b((r) => r.service.markRead(e, t, n)),
+			moderateMember: (e, t) => b((n) => n.service.moderateMember(e, t)),
+			configure: (e, t) => b((n) => n.service.configure(e, t)),
+			join: (e, t) => b((n) => n.service.join(e, t)),
+			leave: (e, t) => b((n) => n.service.leave(e, t)),
+			transferOwnership: (e, t, n) => b((r) => r.service.transferOwnership(e, t, n))
+		}),
+		rpcClientDescriptors: v,
+		sources: D(new URL("./chat-app", "" + import.meta.url)),
+		errorSchemas: [{
+			schema: e,
+			import: {
+				module: "@voltro/plugin-chat/errors",
+				name: "ChatError"
+			}
+		}],
+		extendSchema: { tables: [
+			p,
+			m,
+			h,
+			l,
+			r,
+			n,
+			c
+		] },
+		subjectPrivacy: {
+			tables: [
+				p.tableName,
+				m.tableName,
+				h.tableName,
+				l.tableName,
+				r.tableName,
+				n.tableName,
+				c.tableName
+			],
+			kinds: ["user", "guest"]
+		},
+		inspectEndpoints: [{
+			method: "GET",
+			path: "/status",
+			scope: "process",
+			description: "Declared chat budgets and process binding; no channel/message/body enumeration.",
+			handler: () => T.try({
+				try: () => ({
+					kind: "json",
+					data: S(a, u !== void 0, d)
+				}),
+				catch: () => t("unavailable")
+			})
+		}],
+		bindDataStore: (e) => {
+			if (s !== void 0 && s !== e) throw Error("Chat plugin instance cannot cross app stores");
+			s = e, u ??= g(e, a, o);
+		},
+		onActivate: (e) => T.tryPromise({
+			try: async () => {
+				if (a.rateLimit?.hotStore !== void 0 && O(e.env) !== null) throw t("unavailable");
+				await o.activate(e.env, e.connectionRegistry), d = !0;
+			},
+			catch: () => t("unavailable")
+		}),
+		onExport: (e, t) => b((n) => n.exportSubject({
+			subjectId: e,
+			tenantId: t.tenantId,
+			kind: t.kind
+		})),
+		onErase: (e, t) => b((n) => n.eraseSubject({
+			subjectId: e,
+			tenantId: t.tenantId,
+			kind: t.kind
+		})),
+		onDeactivate: () => T.tryPromise({
+			try: async () => {
+				try {
+					u?.disposeTyping();
+				} finally {
+					u = void 0, s = void 0, d = !1, await o.deactivate();
+				}
+			},
+			catch: () => t("unavailable")
+		})
+	});
+};
+//#endregion
+export { i as CHAT_MAX_MESSAGE_VERSION, a as CHAT_MEDIA_SWEEP_BATCH_SIZE, o as CHAT_RETENTION_BATCH_SIZE, s as CHAT_RETENTION_RUN_BATCHES, e as ChatError, n as chatAdmissionsTable, p as chatChannelsTable, r as chatEvidenceTable, c as chatMediaTable, m as chatMembersTable, h as chatMessagesTable, j as chatPlugin, l as chatRetentionTable, A as chatSystemContract, g as dataStoreChat, b as defaultChatStrategies, x as resolveChatOptions };

package/dist/inspect.js

@@ -0,0 +1,38 @@
+import { chatError as e } from "./errors.js";
+import { defaultChatStrategies as t } from "./strategies.js";
+//#region src/inspect.ts
+var n = (n, r, i) => {
+	let a = n.now();
+	if (!Number.isSafeInteger(a) || a < 0 || a > 864e13) throw e("unavailable");
+	return {
+		observedAt: a,
+		bound: r,
+		rateActive: i,
+		maxBodyLength: n.maxBodyLength,
+		pageSize: n.pageSize,
+		maxMembers: n.maxMembers,
+		maxChannelsPerSubject: n.maxChannelsPerSubject,
+		retentionMs: n.retentionMs,
+		evidenceRetentionMs: n.evidenceRetentionMs,
+		perChannelRate: n.perChannelRate,
+		globalRate: n.globalRate,
+		maxMentions: n.maxMentions,
+		moderationAction: n.moderationAction,
+		denyWordCount: n.denyWords.length,
+		mediaContentTypes: n.mediaContentTypes,
+		maxMediaBytes: n.maxMediaBytes,
+		mediaUrlTtlSec: n.mediaUrlTtlSec,
+		slots: Object.fromEntries(Object.entries(t).map(([e, t]) => [e, n.strategies[e] === t ? "default" : "custom"])),
+		tables: [
+			"_voltro_chat_channels",
+			"_voltro_chat_members",
+			"_voltro_chat_messages",
+			"_voltro_chat_retention",
+			"_voltro_chat_evidence",
+			"_voltro_chat_admissions",
+			"_voltro_chat_media"
+		]
+	};
+};
+//#endregion
+export { n as chatStatus };

package/dist/media.entity.js

@@ -0,0 +1,15 @@
+import { MEDIA_TABLE as e } from "./contract.js";
+import { id as t, table as n, text as r, timestamp as i } from "@voltro/database";
+//#region src/media.entity.ts
+var a = n(e, {
+	id: t({ prefix: "cmed" }),
+	tenantId: r().maxLength(256).externalId().serverOnly(),
+	channelId: r().maxLength(64).serverOnly(),
+	messageId: r().maxLength(64).serverOnly(),
+	storageId: r().maxLength(256).serverOnly(),
+	ownerId: r().maxLength(256).nullable().externalId().sensitive("pii").serverOnly(),
+	state: r().maxLength(16).oneOf(["active", "deleting"]).serverOnly(),
+	createdAt: i().serverOnly()
+}).index(["tenantId", "ownerId"]).index(["state", "id"]).index(["tenantId", "storageId"]);
+//#endregion
+export { a as chatMediaTable };

package/dist/members.entity.js

@@ -0,0 +1,22 @@
+import { MEMBERS_TABLE as e } from "./contract.js";
+import { boolean as t, id as n, json as r, table as i, text as a, timestamp as o } from "@voltro/database";
+//#region src/members.entity.ts
+var s = i(e, {
+	id: n({ prefix: "cmem" }),
+	tenantId: a().maxLength(256).externalId().sensitive("pii"),
+	channelId: a().maxLength(64).safe(),
+	subjectId: a().maxLength(256).externalId().sensitive("pii"),
+	role: a().maxLength(16).oneOf([
+		"member",
+		"mod",
+		"owner"
+	]).safe(),
+	mutedUntil: o().nullable().safe(),
+	lastReadAt: o().safe(),
+	lastReadId: a().maxLength(64).nullable().safe(),
+	lastSentAt: o().nullable().serverOnly(),
+	notify: t().safe(),
+	metadata: r().sensitive("pii")
+}).index(["tenantId", "subjectId"]).index(["channelId"]);
+//#endregion
+export { s as chatMembersTable };

package/dist/mentionDraft.js

@@ -0,0 +1,21 @@
+//#region src/mentionDraft.ts
+var e = (e, t, n) => {
+	if (t !== n || !Number.isSafeInteger(t) || t < 0 || t > e.length || t < e.length && /[\p{L}\p{N}\p{M}_#]/u.test(String.fromCodePoint(e.codePointAt(t)))) return null;
+	let r = e.lastIndexOf("@", t - 1);
+	if (r < 0 || t <= r || r > 0 && !/[\s(\[{]/u.test(e[r - 1])) return null;
+	let i = e.slice(r + 1, t);
+	return i.length > 261 || /[@\r\n]/u.test(i) ? null : {
+		start: r,
+		end: t,
+		prefix: i
+	};
+}, t = (t, n, r, i) => {
+	if (!r || r.length > 256 || /[@\r\n]/u.test(r) || !/#\d{4}$/u.test(r) || e(t, n.end, n.end)?.start !== n.start || t.slice(n.start + 1, n.end) !== n.prefix) return null;
+	let a = "@" + r + " ", o = t.slice(0, n.start) + a + t.slice(n.end);
+	return [...o].length <= i ? {
+		body: o,
+		caret: n.start + a.length
+	} : null;
+};
+//#endregion
+export { t as insertMentionDraft, e as mentionDraftToken };

package/dist/mentionNotifications.js

@@ -0,0 +1,110 @@
+import { chatError as e } from "./errors.js";
+import { MESSAGES_TABLE as t } from "./contract.js";
+import { chatEventTenant as n, committedChatMentions as r } from "./eventProducer.js";
+import { ChatAdministration as i } from "./server.js";
+import { Effect as a, Schema as o } from "effect";
+import { createHash as s } from "node:crypto";
+import { defineOutboxHandler as c, defineSubscriber as l } from "@voltro/runtime";
+import { defineNotification as u, notificationOutboxHandler as d } from "@voltro/plugin-notifications";
+//#region src/mentionNotifications.ts
+var f = "voltro.chat.mention.notify", p = "chat.mention", m = o.NonEmptyString.pipe(o.check(o.isMaxLength(256)), o.check(o.makeFilter((e) => e.trim().length > 0 && !e.includes("\0") && e !== "~"))), h = o.Struct({
+	tenantId: m,
+	channelId: m,
+	messageId: m,
+	recipientId: m
+}), g = o.Struct({
+	tenantId: m,
+	channelId: m,
+	messageId: m,
+	recipientId: m,
+	locale: o.NonEmptyString.pipe(o.check(o.isMaxLength(80)))
+}), _ = u({
+	name: "chat.mentioned",
+	audience: o.Struct({ userId: m }),
+	payload: o.Struct({
+		channelId: m,
+		messageId: m
+	}),
+	render: (e, t) => ({
+		title: t.locale.startsWith("de") ? "Du wurdest erwähnt" : "You were mentioned",
+		body: t.locale.startsWith("de") ? "Öffne den Chat, um die Nachricht zu lesen." : "Open the chat to read the message.",
+		data: {
+			channelId: e.channelId,
+			messageId: e.messageId
+		}
+	})
+}), v = (u) => {
+	let m = structuredClone(u.subject), v = u.run, y = u.service, b = u.outboxForTenant, x = u.localeFor, S = (e) => v(a.flatMap(i, (t) => t.canNotifyMention(m, e))), C = async (e) => {
+		let t = o.decodeUnknownSync(h)(e.payload);
+		return e.tenantId !== t.tenantId || e.recipientId !== t.recipientId ? !1 : S(t);
+	}, w = async (e) => {
+		let t = o.decodeUnknownSync(h)(structuredClone(e));
+		if (!await S(t)) return null;
+		let n = await x?.(t.recipientId, t.tenantId) ?? "en", r = o.decodeUnknownSync(g)({
+			...t,
+			locale: n
+		}), i = s("sha256").update(JSON.stringify([
+			t.tenantId,
+			t.messageId,
+			t.recipientId
+		])).digest("hex");
+		return b(t.tenantId).enqueue(f, { ...r }, {
+			idempotencyKey: "chat.mention:" + i,
+			maxAttempts: 5
+		});
+	};
+	return {
+		deliveryGuard: C,
+		enqueue: w,
+		outboxHandler: c({
+			effect: f,
+			maxAttempts: 5,
+			handler: async (t) => {
+				let n = o.decodeUnknownSync(g)(t.payload);
+				if (t.tenantId !== n.tenantId) throw e("identity_required");
+				if (!await S(n)) return { skipped: !0 };
+				let r = y();
+				if (!r) throw e("unavailable");
+				return d({
+					notifications: [_],
+					service: () => ({ send: async (t) => {
+						let i = await r.send({
+							...t,
+							deliveryGuard: {
+								id: p,
+								payload: {
+									tenantId: n.tenantId,
+									channelId: n.channelId,
+									messageId: n.messageId,
+									recipientId: n.recipientId
+								}
+							}
+						});
+						if (i.failed.length > 0) throw e("unavailable");
+						return i;
+					} })
+				}).handler({ payload: {
+					notification: _.name,
+					recipientId: n.recipientId,
+					locale: n.locale,
+					tenantId: n.tenantId,
+					payload: {
+						channelId: n.channelId,
+						messageId: n.messageId
+					}
+				} });
+			}
+		}),
+		subscriber: l({
+			table: t,
+			on: ["insert"],
+			once: !0,
+			eventTenant: n,
+			handler: async (e) => {
+				for (let t of r(e)) await w(t);
+			}
+		})
+	};
+};
+//#endregion
+export { f as CHAT_MENTION_NOTIFICATION_EFFECT, p as CHAT_MENTION_NOTIFICATION_GUARD, v as createChatMentionNotifications };

package/dist/messages.entity.js

@@ -0,0 +1,28 @@
+import { MESSAGES_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, timestamp as s } from "@voltro/database";
+//#region src/messages.entity.ts
+var c = a(e, {
+	id: n({ prefix: "cmsg" }),
+	tenantId: o().maxLength(256).externalId().sensitive("pii"),
+	channelId: o().maxLength(64).safe(),
+	authorId: o().maxLength(256).nullable().externalId().sensitive("pii"),
+	requestKey: o().maxLength(64).serverOnly(),
+	kind: o().maxLength(16).oneOf([
+		"text",
+		"emote",
+		"system",
+		"media"
+	]).safe(),
+	body: o().sensitive("pii"),
+	originalBody: o().sensitive("pii").serverOnly(),
+	payload: i().sensitive("pii"),
+	replyToId: o().maxLength(64).nullable().safe(),
+	editedAt: s().nullable().safe(),
+	deletedAt: s().nullable().safe(),
+	flagged: t().safe(),
+	createdAt: s().safe(),
+	version: r().safe(),
+	metadata: i().sensitive("pii")
+}).index(["channelId", "createdAt"]).index(["tenantId", "authorId"]);
+//#endregion
+export { c as chatMessagesTable };

package/dist/reportEvidence.js

@@ -0,0 +1,16 @@
+import { ChatAdministration as e } from "./server.js";
+import { Effect as t } from "effect";
+import { sanctionsError as n } from "@voltro/plugin-sanctions/errors";
+//#region src/reportEvidence.ts
+var r = (r) => t.gen(function* () {
+	if (r.context.channelId === void 0) return [];
+	if (!Array.isArray(r.context.messageIds) || r.context.messageIds.length !== 1) return yield* t.fail(n("invalid_input"));
+	let i = yield* t.serviceOption(e);
+	return i._tag === "None" ? yield* t.fail(n("unavailable")) : [{ ...yield* i.value.collectReportContext(r.subject, {
+		channelId: r.context.channelId,
+		messageId: r.context.messageIds[0],
+		targetId: r.targetId
+	}).pipe(t.mapError((e) => n(e.code === "unavailable" ? "unavailable" : "forbidden")), t.catchDefect(() => t.fail(n("unavailable")))) }];
+});
+//#endregion
+export { r as chatSanctionEvidenceCollector };

package/dist/retention.entity.js

@@ -0,0 +1,11 @@
+import { id as e, integer as t, table as n, text as r, timestamp as i } from "@voltro/database";
+//#region src/retention.entity.ts
+var a = n("_voltro_chat_retention", {
+	id: e({ prefix: "cret" }),
+	tenantId: r().maxLength(256).nullable().serverOnly(),
+	afterChannelId: r().maxLength(64).nullable().serverOnly(),
+	admission: t().serverOnly(),
+	updatedAt: i().serverOnly()
+});
+//#endregion
+export { a as chatRetentionTable };