@headless-lms/core 0.2.0 → 0.3.0

package/dist/discussion/chats.js

@@ -0,0 +1,798 @@
+import { genId } from "../shared/id.js";
+import { ConflictError, ForbiddenError, InvalidInputError, NotFoundError } from "../shared/errors.js";
+import { noopLogger } from "../shared/logger.js";
+import { isStaffRole } from "../organizations/roles.js";
+import { discussionEvents } from "./events.js";
+import { authorView } from "./authors.js";
+import "./ports.js";
+//#region src/discussion/chats.ts
+var ChatServiceImpl = class {
+	repo;
+	access;
+	content;
+	authors;
+	profiles;
+	images;
+	fileUrls;
+	uow;
+	logger;
+	constructor(params) {
+		this.repo = params.repo;
+		this.access = params.access;
+		this.content = params.content;
+		this.authors = params.authors;
+		this.profiles = params.profiles;
+		this.images = params.images;
+		this.fileUrls = params.fileUrls;
+		this.uow = params.uow;
+		this.logger = params.logger ?? noopLogger;
+	}
+	async startDirect(orgId, actor, input) {
+		if (actor.id === input.orgUserId) throw new InvalidInputError("You cannot message yourself");
+		if (input.body === null && input.assetIds.length > 0) throw new InvalidInputError("An attachment needs a message");
+		const settings = await this.requireSettings(orgId, input.communityId);
+		await this.requireActor(orgId, actor, input.communityId);
+		const role = await this.requirePerson(orgId, input.communityId, input.orgUserId);
+		this.assertMayMessage(settings, actor, role);
+		const first = input.body === null ? null : {
+			body: input.body,
+			replyToId: null,
+			assetIds: input.assetIds
+		};
+		const saved = await this.uow.run(async ({ chats, outbox }) => {
+			await chats.lockDirectPair(orgId, input.communityId, actor.id, input.orgUserId);
+			const existing = await chats.findDirect(orgId, input.communityId, actor.id, input.orgUserId);
+			if (existing) {
+				const users = await chats.participants(orgId, existing.id);
+				const rejoin = users.some((user) => user.orgUserId === actor.id && user.leftAt !== null);
+				const present = users.map((user) => user.orgUserId === actor.id ? {
+					...user,
+					leftAt: null
+				} : user);
+				if (first) await this.assertMaySend(chats, orgId, actor, existing, present, settings, first);
+				if (rejoin) await chats.join(orgId, this.memberRow(orgId, existing.communityId, existing.id, actor.id, /* @__PURE__ */ new Date()));
+				const written = first ? await this.writeMessage(chats, orgId, actor, existing, first) : null;
+				const chat = written?.chat ?? existing;
+				const events = [];
+				if (rejoin || written?.opened) events.push(this.updatedEvent(orgId, actor, chat, present));
+				if (written) events.push(this.sentEvent(orgId, actor, written.chat, written.message));
+				if (events.length > 0) await outbox.append(events);
+				return {
+					chat,
+					created: false
+				};
+			}
+			await this.requireOwnedImages(orgId, actor.id, input.assetIds);
+			if (await chats.isBlocked(orgId, input.communityId, actor.id, input.orgUserId)) throw new ForbiddenError("You cannot message this person");
+			const request = settings.firstMessageIsRequest && !isStaffRole(actor.role) && !isStaffRole(role);
+			if (request && !first) throw new InvalidInputError("A message request needs a message");
+			const now = /* @__PURE__ */ new Date();
+			const chat = await chats.insertChat(orgId, {
+				orgId,
+				id: genId("chat"),
+				communityId: input.communityId,
+				kind: "direct",
+				status: request ? "pending" : "open",
+				createdBy: actor.id,
+				lockedAt: null,
+				lockedBy: null,
+				createdAt: now,
+				updatedAt: now
+			});
+			const users = [actor.id, input.orgUserId].map((orgUserId) => this.memberRow(orgId, chat.communityId, chat.id, orgUserId, now));
+			for (const user of users) await chats.join(orgId, user);
+			const events = [this.createdEvent(orgId, actor, chat, users)];
+			if (first) {
+				const written = await this.writeMessage(chats, orgId, actor, chat, first);
+				events.push(this.sentEvent(orgId, actor, written.chat, written.message));
+			}
+			await outbox.append(events);
+			return {
+				chat,
+				created: true
+			};
+		});
+		if (saved.created) this.logger.info("direct chat started", {
+			orgId,
+			communityId: input.communityId,
+			chatId: saved.chat.id,
+			status: saved.chat.status,
+			actorId: actor.id
+		});
+		else this.logger.debug("direct chat already exists", {
+			orgId,
+			communityId: input.communityId,
+			chatId: saved.chat.id
+		});
+		return saved.chat;
+	}
+	async startGroup(orgId, actor, input) {
+		const settings = await this.requireSettings(orgId, input.communityId);
+		this.assertGroup(settings);
+		await this.requireActor(orgId, actor, input.communityId);
+		const others = [...new Set(input.orgUserIds.filter((id) => id !== actor.id))].sort();
+		if (others.length < 2) throw new InvalidInputError("A group chat needs three people");
+		if (others.length + 1 > settings.groupSize) throw new ConflictError("This group is full");
+		for (const orgUserId of others) {
+			const role = await this.requirePerson(orgId, input.communityId, orgUserId);
+			this.assertMayMessage(settings, actor, role);
+		}
+		const saved = await this.uow.run(async ({ chats, outbox }) => {
+			if (await chats.anyBlockedAmong(orgId, input.communityId, [actor.id, ...others])) throw new ForbiddenError("You cannot message this person");
+			const now = /* @__PURE__ */ new Date();
+			const chat = await chats.insertChat(orgId, {
+				orgId,
+				id: genId("chat"),
+				communityId: input.communityId,
+				kind: "group",
+				status: "open",
+				createdBy: actor.id,
+				lockedAt: null,
+				lockedBy: null,
+				createdAt: now,
+				updatedAt: now
+			});
+			const users = [actor.id, ...others].map((orgUserId) => this.memberRow(orgId, chat.communityId, chat.id, orgUserId, now));
+			for (const user of users) await chats.join(orgId, user);
+			const events = [this.createdEvent(orgId, actor, chat, users), ...others.map((orgUserId) => this.addedEvent(orgId, actor, chat, orgUserId))];
+			await outbox.append(events);
+			return chat;
+		});
+		this.logger.info("group chat started", {
+			orgId,
+			communityId: input.communityId,
+			chatId: saved.id,
+			actorId: actor.id
+		});
+		return saved;
+	}
+	async addParticipant(orgId, actor, chatId, orgUserId) {
+		const chat = await this.mustChat(this.repo, orgId, chatId);
+		await this.requireActor(orgId, actor, chat.communityId);
+		await this.requireActive(this.repo, orgId, chat.id, actor.id);
+		if (chat.kind !== "group") throw new ConflictError("This chat is not a group");
+		const settings = await this.requireSettings(orgId, chat.communityId);
+		this.assertGroup(settings);
+		const role = await this.requirePerson(orgId, chat.communityId, orgUserId);
+		this.assertMayMessage(settings, actor, role);
+		const saved = await this.uow.run(async ({ chats, outbox }) => {
+			const current = await this.mustChat(chats, orgId, chatId);
+			const users = await chats.participants(orgId, chatId);
+			this.assertActive(users, actor.id);
+			const existing = users.find((user) => user.orgUserId === orgUserId);
+			if (existing && existing.leftAt === null) throw new ConflictError("That person is already in this chat");
+			const active = users.filter((user) => user.leftAt === null);
+			if (active.length + 1 > settings.groupSize) throw new ConflictError("This group is full");
+			if ((await chats.blockedWith(orgId, current.communityId, orgUserId, active.map((user) => user.orgUserId))).length > 0) throw new ForbiddenError("You cannot message this person");
+			const now = /* @__PURE__ */ new Date();
+			await chats.join(orgId, this.memberRow(orgId, current.communityId, current.id, orgUserId, now));
+			await outbox.append([this.addedEvent(orgId, actor, current, orgUserId)]);
+			return current;
+		});
+		this.logger.info("chat participant added", {
+			orgId,
+			chatId,
+			orgUserId,
+			actorId: actor.id
+		});
+		return saved;
+	}
+	async leave(orgId, actor, chatId) {
+		const chat = await this.mustChat(this.repo, orgId, chatId);
+		await this.requireActor(orgId, actor, chat.communityId);
+		await this.requireActive(this.repo, orgId, chat.id, actor.id);
+		const saved = await this.uow.run(async ({ chats, outbox }) => {
+			const current = await this.mustChat(chats, orgId, chatId);
+			const users = await chats.participants(orgId, chatId);
+			this.assertActive(users, actor.id);
+			const now = /* @__PURE__ */ new Date();
+			await chats.markLeft(orgId, chatId, actor.id, now);
+			const remaining = users.map((user) => user.orgUserId === actor.id ? {
+				...user,
+				leftAt: now
+			} : user);
+			await outbox.append([this.updatedEvent(orgId, actor, current, remaining)]);
+			return current;
+		});
+		this.logger.info("chat left", {
+			orgId,
+			chatId,
+			actorId: actor.id
+		});
+		return saved;
+	}
+	async accept(orgId, actor, chatId) {
+		const chat = await this.mustChat(this.repo, orgId, chatId);
+		await this.requireActor(orgId, actor, chat.communityId);
+		await this.requireActive(this.repo, orgId, chat.id, actor.id);
+		if (chat.createdBy === actor.id) throw new ForbiddenError("You cannot accept this request");
+		if (chat.kind !== "direct" || chat.status !== "pending") throw new ConflictError("This chat is not a request");
+		const saved = await this.uow.run(async ({ chats, outbox }) => {
+			const current = await this.mustChat(chats, orgId, chatId);
+			if (current.kind !== "direct" || current.status !== "pending") throw new ConflictError("This chat is not a request");
+			const next = await this.mustUpdate(chats, orgId, chatId, { status: "open" });
+			const users = await chats.participants(orgId, chatId);
+			await outbox.append([this.updatedEvent(orgId, actor, next, users)]);
+			return next;
+		});
+		this.logger.info("chat accepted", {
+			orgId,
+			chatId,
+			actorId: actor.id
+		});
+		return saved;
+	}
+	async send(orgId, actor, chatId, input) {
+		const preview = await this.mustChat(this.repo, orgId, chatId);
+		await this.requireActor(orgId, actor, preview.communityId);
+		const settings = await this.requireSettings(orgId, preview.communityId);
+		if (!settings.enabled) throw new ForbiddenError("Direct messages are off");
+		const saved = await this.uow.run(async ({ chats, outbox }) => {
+			const chat = await this.mustChat(chats, orgId, chatId);
+			const users = await chats.participants(orgId, chatId);
+			await this.assertMaySend(chats, orgId, actor, chat, users, settings, input);
+			const written = await this.writeMessage(chats, orgId, actor, chat, input);
+			const events = [];
+			if (written.opened) events.push(this.updatedEvent(orgId, actor, written.chat, users));
+			events.push(this.sentEvent(orgId, actor, written.chat, written.message));
+			await outbox.append(events);
+			return written.message;
+		});
+		this.logger.info("message sent", {
+			orgId,
+			chatId,
+			messageId: saved.id,
+			actorId: actor.id
+		});
+		return this.viewOf(orgId, actor, saved);
+	}
+	async editMessage(orgId, actor, messageId, body) {
+		const message = await this.mustMessage(this.repo, orgId, messageId);
+		await this.requireWritableChat(orgId, actor, message.chatId);
+		if (message.orgUserId !== actor.id) throw new ForbiddenError("You can change only your own message");
+		if (message.deletedAt) throw new ConflictError("This message was deleted");
+		if (message.body === body) return this.viewOf(orgId, actor, message);
+		const saved = await this.repo.updateMessage(orgId, messageId, {
+			body,
+			editedAt: /* @__PURE__ */ new Date()
+		});
+		if (!saved) throw new NotFoundError("Message", messageId);
+		this.logger.info("message edited", {
+			orgId,
+			messageId,
+			actorId: actor.id
+		});
+		return this.viewOf(orgId, actor, saved);
+	}
+	async deleteMessage(orgId, actor, messageId) {
+		const message = await this.mustMessage(this.repo, orgId, messageId);
+		await this.requireActor(orgId, actor, message.communityId);
+		if (!isStaffRole(actor.role)) {
+			if (message.orgUserId !== actor.id) throw new ForbiddenError("You cannot delete this message");
+			await this.requireWritableChat(orgId, actor, message.chatId);
+		}
+		if (message.deletedAt) throw new ConflictError("This message was deleted");
+		const now = /* @__PURE__ */ new Date();
+		const saved = await this.uow.run(async ({ chats, outbox }) => {
+			const next = await chats.updateMessage(orgId, messageId, { deletedAt: now });
+			if (!next) throw new NotFoundError("Message", messageId);
+			await chats.resolveFlags(orgId, messageId, {
+				resolvedAt: now,
+				resolvedBy: actor.id,
+				resolution: "deleted"
+			});
+			await outbox.append([discussionEvents.messageDeleted.make({
+				orgId,
+				data: next,
+				metadata: this.meta(actor)
+			})]);
+			return next;
+		});
+		this.logger.info("message deleted", {
+			orgId,
+			messageId,
+			actorId: actor.id
+		});
+		return this.viewOf(orgId, actor, saved);
+	}
+	async setReaction(orgId, actor, messageId, emoji) {
+		const message = await this.mustMessage(this.repo, orgId, messageId);
+		await this.requireActor(orgId, actor, message.communityId);
+		await this.requireActive(this.repo, orgId, message.chatId, actor.id);
+		await this.repo.setReaction(orgId, message.communityId, messageId, actor.id, emoji);
+		this.logger.debug("message reaction set", {
+			orgId,
+			messageId
+		});
+		return (await this.repo.reactionsOf(orgId, [messageId], actor.id))[messageId] ?? { reactions: {} };
+	}
+	async markRead(orgId, actor, chatId, messageId) {
+		const chat = await this.mustChat(this.repo, orgId, chatId);
+		await this.requireActor(orgId, actor, chat.communityId);
+		await this.requireActive(this.repo, orgId, chat.id, actor.id);
+		if ((await this.mustMessage(this.repo, orgId, messageId)).chatId !== chatId) throw new NotFoundError("Message", messageId);
+		await this.repo.setRead(orgId, chatId, actor.id, messageId);
+		this.logger.debug("chat marked read", {
+			orgId,
+			chatId,
+			messageId
+		});
+	}
+	async mute(orgId, actor, chatId, until) {
+		const chat = await this.mustChat(this.repo, orgId, chatId);
+		await this.requireActor(orgId, actor, chat.communityId);
+		await this.requireActive(this.repo, orgId, chat.id, actor.id);
+		await this.repo.setMuted(orgId, chatId, actor.id, true, until ?? null);
+		this.logger.debug("chat muted", {
+			orgId,
+			chatId
+		});
+	}
+	async unmute(orgId, actor, chatId) {
+		const chat = await this.mustChat(this.repo, orgId, chatId);
+		await this.requireActor(orgId, actor, chat.communityId);
+		await this.requireActive(this.repo, orgId, chat.id, actor.id);
+		await this.repo.setMuted(orgId, chatId, actor.id, false, null);
+		this.logger.debug("chat unmuted", {
+			orgId,
+			chatId
+		});
+	}
+	async block(orgId, actor, communityId, orgUserId) {
+		if (actor.id === orgUserId) throw new InvalidInputError("You cannot block yourself");
+		await this.requireSettings(orgId, communityId);
+		await this.requireActor(orgId, actor, communityId);
+		await this.requirePerson(orgId, communityId, orgUserId);
+		await this.uow.run(async ({ chats }) => {
+			await chats.lockDirectPair(orgId, communityId, actor.id, orgUserId);
+			await chats.block(orgId, communityId, actor.id, orgUserId);
+		});
+		this.logger.info("user blocked", {
+			orgId,
+			communityId,
+			actorId: actor.id
+		});
+	}
+	async unblock(orgId, actor, communityId, orgUserId) {
+		if (actor.id === orgUserId) throw new InvalidInputError("You cannot block yourself");
+		await this.requireSettings(orgId, communityId);
+		await this.requireActor(orgId, actor, communityId);
+		await this.uow.run(async ({ chats }) => {
+			await chats.lockDirectPair(orgId, communityId, actor.id, orgUserId);
+			await chats.unblock(orgId, communityId, actor.id, orgUserId);
+		});
+		this.logger.info("user unblocked", {
+			orgId,
+			communityId,
+			actorId: actor.id
+		});
+	}
+	async flagMessage(orgId, actor, messageId, reason) {
+		const message = await this.mustMessage(this.repo, orgId, messageId);
+		await this.requireActor(orgId, actor, message.communityId);
+		await this.requireActive(this.repo, orgId, message.chatId, actor.id);
+		const now = /* @__PURE__ */ new Date();
+		const saved = await this.uow.run(async ({ chats, outbox }) => {
+			const flag = await chats.insertFlag(orgId, {
+				orgId,
+				id: genId("messageFlag"),
+				communityId: message.communityId,
+				messageId,
+				orgUserId: actor.id,
+				reason,
+				resolvedAt: null,
+				resolution: null,
+				resolvedBy: null,
+				createdAt: now,
+				updatedAt: now
+			});
+			if (!flag) {
+				const existing = await chats.findFlag(orgId, messageId, actor.id);
+				if (!existing) throw new NotFoundError("Message", messageId);
+				return existing;
+			}
+			await outbox.append([discussionEvents.messageReported.make({
+				orgId,
+				data: flag,
+				metadata: this.meta(actor)
+			})]);
+			return flag;
+		});
+		this.logger.info("message flagged", {
+			orgId,
+			messageId,
+			actorId: actor.id
+		});
+		return saved;
+	}
+	async resolveMessageFlags(orgId, actor, messageId, resolution, communityId) {
+		if (!isStaffRole(actor.role)) throw new ForbiddenError("You cannot work this queue");
+		const message = await this.mustMessage(this.repo, orgId, messageId);
+		if (communityId !== void 0 && message.communityId !== communityId) throw new NotFoundError("Message", messageId);
+		await this.requireActor(orgId, actor, message.communityId);
+		await this.repo.resolveFlags(orgId, messageId, {
+			resolvedAt: /* @__PURE__ */ new Date(),
+			resolvedBy: actor.id,
+			resolution
+		});
+		this.logger.info("message flags resolved", {
+			orgId,
+			communityId: message.communityId,
+			messageId,
+			resolution,
+			actorId: actor.id
+		});
+	}
+	async lock(orgId, actor, chatId, communityId) {
+		return this.setLock(orgId, actor, chatId, true, communityId);
+	}
+	async unlock(orgId, actor, chatId, communityId) {
+		return this.setLock(orgId, actor, chatId, false, communityId);
+	}
+	async listChats(orgId, actor, communityId, query) {
+		await this.requireSettings(orgId, communityId);
+		await this.requireActor(orgId, actor, communityId);
+		const now = /* @__PURE__ */ new Date();
+		const page = await this.repo.listForUser(orgId, communityId, actor.id, query);
+		const items = page.rows.map((item) => ({
+			...item,
+			...item.muted && item.mutedUntil !== null && item.mutedUntil <= now ? {
+				muted: false,
+				mutedUntil: null
+			} : {},
+			lastMessage: item.lastMessage && item.lastMessage.deletedAt !== null && !isStaffRole(actor.role) ? {
+				...item.lastMessage,
+				body: ""
+			} : item.lastMessage
+		}));
+		this.logger.debug("chats listed", {
+			orgId,
+			communityId,
+			count: items.length
+		});
+		return {
+			...page,
+			rows: items
+		};
+	}
+	async messages(orgId, actor, chatId, query) {
+		const chat = await this.mustChat(this.repo, orgId, chatId);
+		await this.requireActor(orgId, actor, chat.communityId);
+		await this.requireActive(this.repo, orgId, chat.id, actor.id);
+		const page = await this.repo.listMessages(orgId, chatId, query);
+		this.logger.debug("chat messages read", {
+			orgId,
+			chatId
+		});
+		return {
+			...page,
+			rows: await this.withSenders(orgId, actor, page.rows)
+		};
+	}
+	async attachmentFile(orgId, actor, chatId, messageId, assetId) {
+		const chat = await this.repo.findChat(orgId, chatId);
+		const message = await this.repo.findMessage(orgId, messageId);
+		if (!chat || !message || message.chatId !== chatId) return null;
+		if (!((await this.repo.attachmentsOf(orgId, [messageId]))[messageId] ?? []).includes(assetId)) return null;
+		if (!await this.access.isCommunityMember(orgId, actor, chat.communityId)) return null;
+		if (!((await this.repo.participants(orgId, chatId)).some((user) => user.orgUserId === actor.id && user.leftAt === null) ? message.deletedAt === null || isStaffRole(actor.role) : isStaffRole(actor.role) && (await this.repo.listOpenFlags(orgId, chat.communityId)).some((flag) => flag.messageId === messageId))) return null;
+		return this.images.signFile(orgId, assetId);
+	}
+	async messageQueue(orgId, actor, communityId) {
+		if (!isStaffRole(actor.role)) throw new ForbiddenError("You cannot work this queue");
+		await this.requireActor(orgId, actor, communityId);
+		await this.requireSettings(orgId, communityId);
+		const flags = await this.repo.listOpenFlags(orgId, communityId, 100);
+		const messages = await this.repo.messagesByIds(orgId, [...new Set(flags.map((flag) => flag.messageId))]);
+		const summaries = await this.repo.chatSummaries(orgId, [...new Set(messages.map((message) => message.chatId))]);
+		const byChat = new Map(summaries.map((summary) => [summary.chat.id, summary]));
+		const entries = (await this.withSenders(orgId, actor, messages)).flatMap((message) => {
+			const summary = byChat.get(message.chatId);
+			if (!summary) return [];
+			return [{
+				message,
+				flags: flags.filter((flag) => flag.messageId === message.id),
+				chat: summary.chat,
+				participantIds: summary.participantIds
+			}];
+		});
+		this.logger.debug("message queue read", {
+			orgId,
+			communityId,
+			count: entries.length
+		});
+		return { entries };
+	}
+	async chatSummary(orgId, chatId) {
+		const chat = await this.repo.findChat(orgId, chatId);
+		if (!chat) return null;
+		return {
+			chat,
+			participants: await this.repo.participants(orgId, chatId)
+		};
+	}
+	async titlesFor(orgId, actor, chatIds) {
+		if (chatIds.length === 0) return {};
+		const summaries = (await this.repo.chatSummaries(orgId, [...new Set(chatIds)])).filter((summary) => summary.participantIds.includes(actor.id));
+		const others = [...new Set(summaries.flatMap((summary) => summary.participantIds.filter((id) => id !== actor.id)))];
+		const records = others.length > 0 ? await this.profiles.authorsOf(orgId, others) : {};
+		const nameOf = (id) => {
+			const record = records[id];
+			return record && authorView(orgId, record, null).displayName || "A member";
+		};
+		return Object.fromEntries(summaries.flatMap((summary) => {
+			const names = summary.participantIds.filter((id) => id !== actor.id).map(nameOf);
+			if (names.length > 0) return [[summary.chat.id, names.join(", ")]];
+			return summary.chat.kind === "group" ? [[summary.chat.id, "Group chat"]] : [];
+		}));
+	}
+	async latestMessageBody(orgId, chatId) {
+		return (await this.repo.listMessages(orgId, chatId, {
+			page: 1,
+			pageSize: 1
+		})).rows[0]?.body ?? null;
+	}
+	isBlocked(orgId, communityId, a, b) {
+		return this.repo.isBlocked(orgId, communityId, a, b);
+	}
+	async setLock(orgId, actor, chatId, locked, communityId) {
+		if (!isStaffRole(actor.role)) throw new ForbiddenError("You cannot lock this chat");
+		const chat = await this.mustChat(this.repo, orgId, chatId);
+		if (communityId !== void 0 && chat.communityId !== communityId) throw new NotFoundError("Chat", chatId);
+		await this.requireActor(orgId, actor, chat.communityId);
+		if (Boolean(chat.lockedAt) === locked) return chat;
+		const now = /* @__PURE__ */ new Date();
+		const saved = await this.uow.run(async ({ chats, outbox }) => {
+			const next = await this.mustUpdate(chats, orgId, chatId, {
+				lockedAt: locked ? now : null,
+				lockedBy: locked ? actor.id : null
+			});
+			if (locked) await chats.resolveOpenFlagsForChat(orgId, chatId, {
+				resolvedAt: now,
+				resolvedBy: actor.id,
+				resolution: "locked"
+			});
+			const users = await chats.participants(orgId, chatId);
+			await outbox.append([this.updatedEvent(orgId, actor, next, users)]);
+			return next;
+		});
+		this.logger.info(locked ? "chat locked" : "chat unlocked", {
+			orgId,
+			chatId,
+			actorId: actor.id
+		});
+		return saved;
+	}
+	async requireSettings(orgId, communityId) {
+		const settings = await this.content.getDmSettings(orgId, communityId);
+		if (!settings) throw new NotFoundError("Community", communityId);
+		return settings;
+	}
+	async requireActor(orgId, actor, communityId) {
+		if (!await this.access.isCommunityMember(orgId, actor, communityId)) throw new ForbiddenError("You are not a member of this community");
+	}
+	async requirePerson(orgId, communityId, orgUserId) {
+		const role = await this.personRole(orgId, communityId, orgUserId);
+		if (!role) throw new ForbiddenError("That person is not a member of this community");
+		return role;
+	}
+	async personRole(orgId, communityId, orgUserId) {
+		const role = await this.authors.roleOf(orgId, orgUserId);
+		if (!role) return null;
+		return await this.access.isCommunityMember(orgId, {
+			id: orgUserId,
+			role
+		}, communityId) ? role : null;
+	}
+	async personRoles(orgId, communityId, orgUserIds) {
+		const roles = await this.authors.rolesOf(orgId, orgUserIds);
+		const members = new Set(await this.access.communityMembersAmong(orgId, communityId, Object.keys(roles)));
+		return Object.fromEntries(Object.entries(roles).filter(([orgUserId]) => members.has(orgUserId)));
+	}
+	async assertMaySend(chats, orgId, actor, chat, users, settings, input) {
+		this.assertActive(users, actor.id);
+		if (chat.lockedAt) throw new ForbiddenError("This chat is locked");
+		if (chat.status === "closed") throw new ForbiddenError("You cannot send in this chat");
+		if (this.pendingCreator(chat, actor)) throw new ForbiddenError("You cannot send in this chat");
+		const others = users.filter((other) => other.orgUserId !== actor.id && (chat.kind === "direct" || other.leftAt === null)).map((other) => other.orgUserId);
+		if (others.length > 0) {
+			const roles = await this.personRoles(orgId, chat.communityId, others);
+			const recipients = chat.kind === "group" ? others.filter((other) => roles[other]) : others;
+			for (const other of recipients) {
+				const role = roles[other];
+				if (!role || !this.mayMessage(settings, actor, role)) throw new ForbiddenError("You cannot send in this chat");
+			}
+			if (recipients.length > 0) {
+				if ((await chats.blockedWith(orgId, chat.communityId, actor.id, recipients)).length > 0) throw new ForbiddenError("You cannot send in this chat");
+			}
+		}
+		if (input.replyToId) {
+			const reply = await chats.findMessage(orgId, input.replyToId);
+			if (!reply || reply.chatId !== chat.id) throw new NotFoundError("Message", input.replyToId);
+		}
+		await this.requireOwnedImages(orgId, actor.id, input.assetIds);
+	}
+	async writeMessage(chats, orgId, actor, chat, input) {
+		const opened = chat.kind === "direct" && chat.status === "pending" && chat.createdBy !== actor.id;
+		const current = opened ? await this.mustUpdate(chats, orgId, chat.id, { status: "open" }) : chat;
+		const message = await chats.insertMessage(orgId, this.newMessage(orgId, current, actor, input, /* @__PURE__ */ new Date()));
+		if (input.assetIds.length > 0) await chats.attach(orgId, current.communityId, message.id, input.assetIds);
+		return {
+			chat: current,
+			message,
+			opened
+		};
+	}
+	assertMayMessage(settings, actor, role) {
+		if (!settings.enabled) throw new ForbiddenError("Direct messages are off");
+		if (!this.mayMessage(settings, actor, role)) throw new ForbiddenError("You cannot message this person");
+	}
+	assertGroup(settings) {
+		if (!settings.enabled) throw new ForbiddenError("Direct messages are off");
+		if (!settings.groupChats) throw new ForbiddenError("Group chats are off");
+	}
+	mayMessage(settings, actor, target) {
+		if (isStaffRole(actor.role)) return settings.staffToAnyone;
+		if (isStaffRole(target)) return settings.memberToStaff;
+		return settings.memberToMember;
+	}
+	async requireActive(repo, orgId, chatId, orgUserId) {
+		const users = await repo.participants(orgId, chatId);
+		this.assertActive(users, orgUserId);
+	}
+	assertActive(users, orgUserId) {
+		if (!users.some((user) => user.orgUserId === orgUserId && user.leftAt === null)) throw new ForbiddenError("You are not in this chat");
+	}
+	async requireOwnedImages(orgId, orgUserId, assetIds) {
+		for (const assetId of assetIds) if (!await this.images.ownsImage(orgId, assetId, orgUserId)) {
+			this.logger.debug("attachment refused", {
+				orgId,
+				orgUserId,
+				assetId
+			});
+			throw new NotFoundError("Asset", assetId);
+		}
+	}
+	async requireWritableChat(orgId, actor, chatId) {
+		const chat = await this.mustChat(this.repo, orgId, chatId);
+		await this.requireActor(orgId, actor, chat.communityId);
+		await this.requireActive(this.repo, orgId, chat.id, actor.id);
+		if (chat.lockedAt || chat.status === "closed") throw new ForbiddenError("You cannot send in this chat");
+	}
+	pendingCreator(chat, actor) {
+		return chat.kind === "direct" && chat.status === "pending" && chat.createdBy === actor.id;
+	}
+	async mustChat(repo, orgId, chatId) {
+		const chat = await repo.findChat(orgId, chatId);
+		if (!chat) throw new NotFoundError("Chat", chatId);
+		return chat;
+	}
+	async mustMessage(repo, orgId, messageId) {
+		const message = await repo.findMessage(orgId, messageId);
+		if (!message) throw new NotFoundError("Message", messageId);
+		return message;
+	}
+	async mustUpdate(chats, orgId, chatId, patch) {
+		const next = await chats.updateChat(orgId, chatId, patch);
+		if (!next) throw new NotFoundError("Chat", chatId);
+		return next;
+	}
+	memberRow(orgId, communityId, chatId, orgUserId, now) {
+		return {
+			orgId,
+			communityId,
+			chatId,
+			orgUserId,
+			joinedAt: now,
+			leftAt: null,
+			lastReadMessageId: null,
+			muted: false,
+			mutedUntil: null,
+			createdAt: now,
+			updatedAt: now
+		};
+	}
+	newMessage(orgId, chat, actor, input, now) {
+		return {
+			orgId,
+			id: genId("message"),
+			communityId: chat.communityId,
+			chatId: chat.id,
+			orgUserId: actor.id,
+			body: input.body,
+			replyToId: input.replyToId,
+			editedAt: null,
+			deletedAt: null,
+			createdAt: now,
+			updatedAt: now
+		};
+	}
+	activeIds(users) {
+		return users.filter((user) => user.leftAt === null).map((user) => user.orgUserId).sort();
+	}
+	chatData(chat, users) {
+		return {
+			...chat,
+			participantIds: this.activeIds(users)
+		};
+	}
+	meta(actor) {
+		return { actorOrgUserId: actor.id };
+	}
+	createdEvent(orgId, actor, chat, users) {
+		return discussionEvents.chatCreated.make({
+			orgId,
+			data: this.chatData(chat, users),
+			metadata: this.meta(actor)
+		});
+	}
+	updatedEvent(orgId, actor, chat, users) {
+		return discussionEvents.chatUpdated.make({
+			orgId,
+			data: this.chatData(chat, users),
+			metadata: this.meta(actor)
+		});
+	}
+	addedEvent(orgId, actor, chat, orgUserId) {
+		return discussionEvents.chatParticipantAdded.make({
+			orgId,
+			data: {
+				chatId: chat.id,
+				communityId: chat.communityId,
+				orgUserId,
+				addedBy: actor.id
+			},
+			metadata: this.meta(actor)
+		});
+	}
+	sentEvent(orgId, actor, chat, message) {
+		return discussionEvents.messageSent.make({
+			orgId,
+			data: message,
+			metadata: {
+				...this.meta(actor),
+				chatStatus: chat.status
+			}
+		});
+	}
+	async viewOf(orgId, actor, message) {
+		const [view] = await this.withSenders(orgId, actor, [message]);
+		return view;
+	}
+	async withSenders(orgId, actor, messages) {
+		if (messages.length === 0) return [];
+		const messageIds = messages.map((message) => message.id);
+		const [records, attached, reactions] = await Promise.all([
+			this.profiles.authorsOf(orgId, [...new Set(messages.map((message) => message.orgUserId))]),
+			this.repo.attachmentsOf(orgId, messageIds),
+			this.repo.reactionsOf(orgId, messageIds, actor.id)
+		]);
+		const shown = (message) => message.deletedAt !== null && !isStaffRole(actor.role) ? [] : attached[message.id] ?? [];
+		return messages.map((message) => {
+			const record = records[message.orgUserId];
+			if (!record) throw new NotFoundError("Member", message.orgUserId);
+			const counts = reactions[message.id];
+			return {
+				...this.present(message, actor),
+				sender: authorView(orgId, record, this.fileUrls),
+				attachments: shown(message).map((assetId) => ({
+					assetId,
+					url: this.fileUrls.messageAttachment(message.chatId, message.id, assetId)
+				})),
+				reactions: counts?.reactions ?? {},
+				viewerReaction: counts?.viewerReaction ?? null
+			};
+		});
+	}
+	present(message, actor) {
+		if (message.deletedAt !== null && !isStaffRole(actor.role)) return {
+			...message,
+			body: ""
+		};
+		return message;
+	}
+};
+//#endregion
+export { ChatServiceImpl };
+
+//# sourceMappingURL=chats.js.map