@headless-lms/core 0.3.0 → 0.5.0

package/dist/discussion/service.js

@@ -1,10 +1,11 @@
-import { genId } from "../shared/id.js";
-import { ConflictError, ForbiddenError, NotFoundError } from "../shared/errors.js";
 import { noopLogger } from "../shared/logger.js";
-import { canModerate, isStaffRole } from "../organizations/roles.js";
+import { ConflictError, ForbiddenError, NotFoundError } from "../shared/errors.js";
+import { genId } from "../shared/id.js";
 import "../shared/settings.js";
 import { discussionEvents } from "./events.js";
 import { authorView } from "./authors.js";
+import { keepAllowed, mentionTokens, mentionViews } from "./mentions.js";
+import { skipsReview, teamBadge } from "./rules.js";
 //#region src/discussion/service.ts
 /** A course with no stored settings. Discussion is opt-in, so the common case
 *  persists no row at all and every existing course stays silent. */
@@ -20,9 +21,11 @@ var DiscussionServiceImpl = class {
 	access;
 	content;
 	posts;
+	spaces;
+	authors;
+	mentions;
 	uow;
 	settings;
-	communities;
 	fileUrls;
 	logger;
 	constructor(params) {
@@ -30,21 +33,21 @@ var DiscussionServiceImpl = class {
 		this.access = params.access;
 		this.content = params.content;
 		this.posts = params.posts;
+		this.spaces = params.spaces;
+		this.authors = params.authors;
+		this.mentions = params.mentions;
 		this.uow = params.uow;
 		this.settings = params.settings;
-		this.communities = params.communities;
 		this.fileUrls = params.fileUrls;
 		this.logger = params.logger ?? noopLogger;
 	}
-	async resolveConfig(orgId, activityId) {
-		const activity = await this.content.getActivity(orgId, activityId);
-		if (!activity) throw new NotFoundError("Activity", activityId);
+	async configOf(orgId, activity) {
 		const stored = await this.settings.get(orgId, "content", activity.courseId);
 		const settings = {
 			...DEFAULT_SETTINGS,
 			...stored?.comments
 		};
-		const rule = (activity?.settings ?? {}).comments ?? "inherit";
+		const rule = (activity.settings ?? {}).comments ?? "inherit";
 		return {
 			enabled: settings.enabled && rule !== "never",
 			threaded: settings.threaded,
@@ -52,10 +55,10 @@ var DiscussionServiceImpl = class {
 			reactions: settings.reactions
 		};
 	}
-	isStaff(actor) {
-		return isStaffRole(actor.role);
+	async badgesOf(orgId, orgUserIds) {
+		return this.authors.permissionsOfMany(orgId, [...new Set(orgUserIds)]);
 	}
-	toView(orgId, comment, authors, urls, reactions) {
+	toView(orgId, comment, itemId, authors, permissions, reactions, mentions) {
 		const author = authors[comment.orgUserId];
 		if (!author) throw new NotFoundError("Member", comment.orgUserId);
 		if (comment.removedBy && !authors[comment.removedBy]) throw new NotFoundError("Member", comment.removedBy);
@@ -66,12 +69,13 @@ var DiscussionServiceImpl = class {
 			postId: comment.postId,
 			communityId: comment.communityId,
 			parentId: comment.parentId,
-			author: authorView(orgId, author, urls),
+			author: authorView(orgId, author, this.fileUrls, teamBadge(permissions.get(author.id), itemId)),
 			body: comment.status === "removed" ? null : comment.body,
 			status: comment.status,
-			removedBy: remover ? authorView(orgId, remover, urls) : null,
+			removedBy: remover ? authorView(orgId, remover, this.fileUrls, teamBadge(permissions.get(remover.id), itemId)) : null,
 			reactions: reactions.reactions,
 			viewerReaction: reactions.viewerReaction,
+			mentions: comment.status === "removed" ? [] : mentions,
 			createdAt: comment.createdAt,
 			updatedAt: comment.updatedAt
 		};
@@ -84,34 +88,97 @@ var DiscussionServiceImpl = class {
 		}
 		return [...ids];
 	}
-	async renderOne(orgId, comment, actor) {
-		const authors = await this.repo.authorsOf(orgId, this.peopleIn([comment]));
+	itemOf(where) {
+		return where.kind === "course" ? where.courseId : where.communityId;
+	}
+	async renderOne(comment, where, actor) {
+		const orgId = actor.orgId;
+		const people = this.peopleIn([comment]);
+		const [authors, permissions, mentioned] = await Promise.all([
+			this.repo.authorsOf(orgId, people),
+			this.badgesOf(orgId, people),
+			mentionViews(this.mentions, this.repo, orgId, "comment", [comment.id])
+		]);
 		const stored = comment.status === "removed" ? EMPTY_REACTIONS : (await this.repo.reactionsOf(orgId, [comment.id], actor.id))[comment.id] ?? EMPTY_REACTIONS;
-		return this.toView(orgId, comment, authors, this.fileUrls, stored);
+		return this.toView(orgId, comment, this.itemOf(where), authors, permissions, stored, mentioned[comment.id] ?? []);
 	}
 	activityIdOf(comment) {
 		if (comment.activityId === null) throw new NotFoundError("Activity", comment.id);
 		return comment.activityId;
 	}
-	async hasAccess(orgId, activityId, actor) {
-		if (this.isStaff(actor)) return true;
-		const activity = await this.content.getActivity(orgId, activityId);
-		return activity ? this.access.hasAccess(orgId, actor.id, activity.courseId) : false;
+	system(orgId) {
+		return this.authors.systemActor(orgId);
+	}
+	async activityOf(orgId, activityId) {
+		return this.content.getActivity(activityId, this.system(orgId));
 	}
-	async requireActivityOpen(orgId, activityId, actor) {
-		const activity = await this.content.getActivity(orgId, activityId);
+	async opensCourse(actor, courseId) {
+		return actor.permissions.has("courses:read", courseId) || this.access.hasAccess(actor.orgId, actor.id, courseId);
+	}
+	async requireActivityOpen(activityId, actor) {
+		const activity = await this.activityOf(actor.orgId, activityId);
 		if (!activity) throw new NotFoundError("Activity", activityId);
-		if (!this.isStaff(actor) && !await this.access.hasAccess(orgId, actor.id, activity.courseId)) throw new ForbiddenError("You cannot open this activity");
+		if (!await this.opensCourse(actor, activity.courseId)) {
+			this.logger.warn("activity refused — no access", {
+				orgId: actor.orgId,
+				activityId,
+				actorId: actor.id
+			});
+			throw new ForbiddenError("You cannot open this activity");
+		}
+		return activity;
+	}
+	async courseOpeners(orgId, courseId, orgUserIds) {
+		if (orgUserIds.length === 0) return [];
+		const [people, permissions] = await Promise.all([this.repo.authorsOf(orgId, orgUserIds), this.badgesOf(orgId, orgUserIds)]);
+		const opens = await Promise.all(orgUserIds.map(async (orgUserId) => {
+			if (!people[orgUserId]) return false;
+			return (permissions.get(orgUserId)?.has("courses:read", courseId) ?? false) || this.access.hasAccess(orgId, orgUserId, courseId);
+		}));
+		return orgUserIds.filter((_, index) => opens[index]);
+	}
+	async spaceOpeners(orgId, spaceId, orgUserIds) {
+		if (orgUserIds.length === 0) return [];
+		return keepAllowed(orgUserIds, await this.spaces.spaceOpenersAmong(orgId, spaceId, orgUserIds));
+	}
+	async openersOf(orgId, comment, orgUserIds) {
+		if (orgUserIds.length === 0) return [];
+		if (comment.postId) {
+			const post = await this.posts.find(orgId, comment.postId);
+			return post ? this.spaceOpeners(orgId, post.spaceId, orgUserIds) : [];
+		}
+		const activity = await this.activityOf(orgId, this.activityIdOf(comment));
+		return activity ? this.courseOpeners(orgId, activity.courseId, orgUserIds) : [];
 	}
-	async postComment(orgId, input) {
-		if (input.postId) return this.postOnPost(orgId, input.postId, input);
+	commenterIds(orgId, target) {
+		return this.repo.commenterIds(orgId, target);
+	}
+	async postComment(input, actor) {
+		if (input.postId) return this.postOnPost(input.postId, input, actor);
 		const activityId = input.activityId;
 		if (!activityId) throw new NotFoundError("Activity", activityId ?? "");
-		return this.postOnActivity(orgId, activityId, input);
-	}
-	async postOnActivity(orgId, activityId, { actor, parentId, body }) {
-		await this.requireActivityOpen(orgId, activityId, actor);
-		const config = await this.resolveConfig(orgId, activityId);
+		return this.postOnActivity(activityId, input, actor);
+	}
+	async replyToComment(commentId, body, actor) {
+		const parent = await this.getComment(actor.orgId, commentId);
+		if (!parent || parent.activityId === null) throw new NotFoundError("Comment", commentId);
+		const activity = await this.activityOf(actor.orgId, parent.activityId);
+		if (!activity) throw new NotFoundError("Comment", commentId);
+		this.requireModerates(actor, {
+			kind: "course",
+			courseId: activity.courseId,
+			activity
+		});
+		return this.postOnActivity(parent.activityId, {
+			activityId: parent.activityId,
+			parentId: parent.parentId ?? parent.id,
+			body
+		}, actor);
+	}
+	async postOnActivity(activityId, { parentId, body }, actor) {
+		const orgId = actor.orgId;
+		const activity = await this.requireActivityOpen(activityId, actor);
+		const config = await this.configOf(orgId, activity);
 		if (!config.enabled) throw new ForbiddenError("Discussion is not open on this activity");
 		if (parentId !== null) {
 			if (!config.threaded) throw new ForbiddenError("Replies are off on this course");
@@ -120,7 +187,7 @@ var DiscussionServiceImpl = class {
 			if (parent.parentId !== null) throw new ForbiddenError("A reply cannot have replies of its own");
 			if (parent.status !== "published") throw new ForbiddenError("You can reply only to a published comment");
 		}
-		const status = config.requireReview && !this.isStaff(actor) ? "pending" : "published";
+		const status = config.requireReview && !skipsReview(actor.permissions, { courseId: activity.courseId }) ? "pending" : "published";
 		const comment = {
 			id: genId("comment"),
 			orgId,
@@ -135,11 +202,17 @@ var DiscussionServiceImpl = class {
 			createdAt: /* @__PURE__ */ new Date(),
 			updatedAt: /* @__PURE__ */ new Date()
 		};
+		const mentioned = await this.courseOpeners(orgId, activity.courseId, mentionTokens(body));
 		const saved = await this.uow.run(async (scope) => {
 			const row = await scope.discussion.insertComment(orgId, comment);
+			await scope.mentions.sync(orgId, "comment", row.id, mentioned, comment.createdAt);
 			await scope.outbox.append([discussionEvents.commentCreated.make({
 				orgId,
-				data: row
+				data: {
+					...row,
+					mentionedOrgUserIds: status === "published" ? mentioned : []
+				},
+				metadata: { actorId: actor.id }
 			})]);
 			this.logger.info("comment created", {
 				orgId,
@@ -149,10 +222,15 @@ var DiscussionServiceImpl = class {
 			});
 			return row;
 		});
-		return this.renderOne(orgId, saved, actor);
-	}
-	async postOnPost(orgId, postId, { actor, parentId, body }) {
-		const { post, space } = await this.visiblePost(orgId, actor, postId);
+		return this.renderOne(saved, {
+			kind: "course",
+			courseId: activity.courseId,
+			activity
+		}, actor);
+	}
+	async postOnPost(postId, { parentId, body }, actor) {
+		const orgId = actor.orgId;
+		const { post, space } = await this.posts.visible(postId, actor);
 		if (post.status !== "published") throw new ConflictError("This post is not published");
 		if (!this.commentsOpen(post, space)) throw new ForbiddenError("Comments are closed on this post");
 		if (parentId !== null) {
@@ -176,12 +254,17 @@ var DiscussionServiceImpl = class {
 			createdAt: now,
 			updatedAt: now
 		};
+		const mentioned = await this.spaceOpeners(orgId, post.spaceId, mentionTokens(body));
 		const saved = await this.uow.run(async (scope) => {
 			const row = await scope.discussion.insertComment(orgId, comment);
+			await scope.mentions.sync(orgId, "comment", row.id, mentioned, now);
 			await scope.outbox.append([discussionEvents.commentCreated.make({
 				orgId,
-				data: row,
-				metadata: { actorOrgUserId: actor.id }
+				data: {
+					...row,
+					mentionedOrgUserIds: mentioned
+				},
+				metadata: { actorId: actor.id }
 			})]);
 			this.logger.info("comment created", {
 				orgId,
@@ -192,17 +275,23 @@ var DiscussionServiceImpl = class {
 			});
 			return row;
 		});
-		return this.renderOne(orgId, saved, actor);
-	}
-	async postComments(orgId, postId, actor, query) {
-		const { post, space } = await this.visiblePost(orgId, actor, postId);
-		const seesHeld = (person) => this.canModerate(person);
+		return this.renderOne(saved, {
+			kind: "post",
+			communityId: post.communityId,
+			post,
+			space
+		}, actor);
+	}
+	async postComments(postId, query, actor) {
+		const orgId = actor.orgId;
+		const { post, space } = await this.posts.visible(postId, actor);
+		const seesHeld = actor.permissions.has("communities:moderate", post.communityId);
 		const page = await this.repo.listThreadsByPost(orgId, postId, {
 			...query,
 			viewerId: actor.id,
-			seesHeld: seesHeld(actor)
+			seesHeld
 		});
-		const comments = await this.thread(orgId, page.rows, actor, post.reactionsEnabled ?? space.settings.reactions, seesHeld);
+		const comments = await this.thread(orgId, page.rows, actor, post.communityId, post.reactionsEnabled ?? space.settings.reactions, seesHeld);
 		this.logger.debug("post comments read", {
 			orgId,
 			postId,
@@ -213,84 +302,142 @@ var DiscussionServiceImpl = class {
 			rows: comments
 		};
 	}
-	async thread(orgId, rows, actor, reactionsOn, seesHeld) {
+	async thread(orgId, rows, actor, itemId, reactionsOn, seesHeld) {
 		const readable = rows.filter((comment) => {
 			if (comment.status === "published" || comment.status === "removed") return true;
-			return seesHeld(actor) || comment.orgUserId === actor.id;
+			return seesHeld || comment.orgUserId === actor.id;
 		});
 		const replies = readable.filter((comment) => comment.parentId !== null && comment.status !== "removed");
 		const heldOpen = new Set(replies.map((reply) => reply.parentId));
 		const roots = readable.filter((comment) => comment.parentId === null && (comment.status !== "removed" || heldOpen.has(comment.id)));
 		const rootIds = new Set(roots.map((root) => root.id));
 		const served = [...roots, ...replies.filter((reply) => rootIds.has(reply.parentId))].sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
-		const [authors, reactions] = await Promise.all([this.repo.authorsOf(orgId, this.peopleIn(served)), reactionsOn ? this.repo.reactionsOf(orgId, served.map((comment) => comment.id), actor.id) : Promise.resolve({})]);
-		const urls = this.fileUrls;
-		return served.map((comment) => this.toView(orgId, comment, authors, urls, reactions[comment.id] ?? EMPTY_REACTIONS));
-	}
-	async visiblePost(orgId, actor, postId) {
-		return this.posts.visible(orgId, actor, postId);
-	}
-	async postOfComment(orgId, actor, commentId, postId) {
+		const people = this.peopleIn(served);
+		const [authors, permissions, reactions, mentioned] = await Promise.all([
+			this.repo.authorsOf(orgId, people),
+			this.badgesOf(orgId, people),
+			reactionsOn ? this.repo.reactionsOf(orgId, served.map((comment) => comment.id), actor.id) : Promise.resolve({}),
+			mentionViews(this.mentions, this.repo, orgId, "comment", served.map((comment) => comment.id))
+		]);
+		return served.map((comment) => this.toView(orgId, comment, itemId, authors, permissions, reactions[comment.id] ?? EMPTY_REACTIONS, mentioned[comment.id] ?? []));
+	}
+	async postOfComment(actor, commentId, postId) {
 		try {
-			return await this.visiblePost(orgId, actor, postId);
+			return await this.posts.visible(postId, actor);
 		} catch (error) {
 			if (error instanceof NotFoundError) throw new NotFoundError("Comment", commentId);
 			throw error;
 		}
 	}
-	canModerate(actor) {
-		return canModerate(actor.role);
-	}
-	inCommunity(comment, communityId) {
-		return communityId === void 0 || comment.communityId === communityId;
+	isWithin(comment, within) {
+		if (within === "any") return true;
+		if (within === "lesson") return comment.activityId !== null;
+		return comment.communityId === within.communityId;
 	}
 	commentsOpen(post, space) {
 		return post.commentsClosed === null ? space.settings.comments : !post.commentsClosed;
 	}
-	async activityComments(orgId, activityId, actor) {
-		await this.requireActivityOpen(orgId, activityId, actor);
-		const config = await this.resolveConfig(orgId, activityId);
+	/** Where the comment sits, having proved the actor may reach it: the post
+	*  is visible to them, or they open the course. */
+	async whereOf(comment, actor) {
+		if (comment.postId) {
+			const { post, space } = await this.postOfComment(actor, comment.id, comment.postId);
+			return {
+				kind: "post",
+				communityId: post.communityId,
+				post,
+				space
+			};
+		}
+		const activity = await this.activityOf(actor.orgId, this.activityIdOf(comment));
+		if (!activity) throw new NotFoundError("Comment", comment.id);
+		if (!await this.opensCourse(actor, activity.courseId)) {
+			this.logger.warn("comment refused — no access", {
+				orgId: actor.orgId,
+				commentId: comment.id,
+				actorId: actor.id
+			});
+			throw new ForbiddenError("You cannot open this activity");
+		}
+		return {
+			kind: "course",
+			courseId: activity.courseId,
+			activity
+		};
+	}
+	moderates(actor, where) {
+		return where.kind === "course" ? actor.permissions.has("courses:moderate", where.courseId) : actor.permissions.has("communities:moderate", where.communityId);
+	}
+	requireModerates(actor, where) {
+		actor.permissions.require(where.kind === "course" ? "courses:moderate" : "communities:moderate", this.itemOf(where));
+	}
+	async findIn(commentId, within, actor, action) {
+		const comment = await this.getComment(actor.orgId, commentId);
+		if (!comment || !this.isWithin(comment, within)) {
+			this.logger.warn(`comment ${action} rejected — not found`, {
+				orgId: actor.orgId,
+				commentId,
+				actorId: actor.id
+			});
+			throw new NotFoundError("Comment", commentId);
+		}
+		return comment;
+	}
+	async activityComments(activityId, actor) {
+		const activity = await this.requireActivityOpen(activityId, actor);
+		const config = await this.configOf(actor.orgId, activity);
 		if (!config.enabled) return {
 			config,
 			comments: []
 		};
-		const rows = await this.repo.listByActivity(orgId, activityId);
+		const rows = await this.repo.listByActivity(actor.orgId, activityId);
 		return {
 			config,
-			comments: await this.thread(orgId, rows, actor, config.reactions, (person) => this.isStaff(person))
+			comments: await this.thread(actor.orgId, rows, actor, activity.courseId, config.reactions, actor.permissions.has("courses:moderate", activity.courseId))
 		};
 	}
-	async edit(orgId, commentId, actor, body) {
-		const { comment, config } = await this.loadWithConfig(orgId, commentId, actor);
+	async edit(commentId, body, actor) {
+		const orgId = actor.orgId;
+		const { comment, config, where } = await this.loadWithConfig(commentId, actor);
 		if (!config.enabled) throw new ForbiddenError(comment.postId ? "Comments are closed on this post" : "Discussion is not open on this activity");
 		if (comment.orgUserId !== actor.id) throw new ForbiddenError("You can edit only your own comment");
 		if (comment.status === "removed") throw new ForbiddenError("A removed comment cannot be edited");
-		const updated = await this.repo.updateComment(orgId, commentId, { body });
-		if (!updated) throw new NotFoundError("Comment", commentId);
-		return this.renderOne(orgId, updated, actor);
-	}
-	async remove(orgId, commentId, actor, communityId) {
-		return this.renderOne(orgId, await this.removeComment(orgId, commentId, actor, communityId), actor);
-	}
-	async removeComment(orgId, commentId, actor, communityId) {
-		const comment = await this.getComment(orgId, commentId);
-		if (!comment || !this.inCommunity(comment, communityId)) {
-			this.logger.warn("comment remove rejected — not found", {
+		const candidates = await this.openersOf(orgId, comment, mentionTokens(body));
+		const updated = await this.uow.run(async (scope) => {
+			const next = await scope.discussion.updateComment(orgId, commentId, { body });
+			if (!next) throw new NotFoundError("Comment", commentId);
+			const added = await scope.mentions.sync(orgId, "comment", commentId, candidates, /* @__PURE__ */ new Date());
+			await scope.outbox.append([discussionEvents.commentUpdated.make({
+				orgId,
+				data: {
+					...next,
+					mentionedOrgUserIds: next.status === "published" ? keepAllowed(candidates, added) : []
+				},
+				metadata: { actorId: actor.id }
+			})]);
+			return next;
+		});
+		this.logger.info("comment edited", {
+			orgId,
+			commentId,
+			actorId: actor.id
+		});
+		return this.renderOne(updated, where, actor);
+	}
+	async remove(commentId, within, actor) {
+		const orgId = actor.orgId;
+		const comment = await this.findIn(commentId, within, actor, "remove");
+		const where = await this.whereOf(comment, actor);
+		if (comment.orgUserId !== actor.id && !this.moderates(actor, where)) {
+			this.logger.warn("comment remove refused — not the author or a moderator", {
 				orgId,
 				commentId,
 				actorId: actor.id
 			});
-			throw new NotFoundError("Comment", commentId);
+			throw new ForbiddenError("You cannot remove this comment");
 		}
-		if (comment.postId) {
-			await this.postOfComment(orgId, actor, commentId, comment.postId);
-			if (comment.orgUserId !== actor.id && !this.canModerate(actor)) throw new ForbiddenError("You cannot remove this comment");
-		} else {
-			if (!await this.hasAccess(orgId, this.activityIdOf(comment), actor)) throw new ForbiddenError("You cannot open this activity");
-			if (comment.orgUserId !== actor.id && !this.isStaff(actor)) throw new ForbiddenError("You cannot remove this comment");
-		}
-		if (comment.status === "removed") return comment;
-		return this.uow.run(async (scope) => {
+		if (comment.status === "removed") return this.renderOne(comment, where, actor);
+		const removed = await this.uow.run(async (scope) => {
 			const updated = await scope.discussion.updateComment(orgId, commentId, {
 				status: "removed",
 				removedBy: actor.id
@@ -304,7 +451,7 @@ var DiscussionServiceImpl = class {
 			await scope.outbox.append([discussionEvents.commentRemoved.make({
 				orgId,
 				data: updated,
-				metadata: updated.postId ? { actorOrgUserId: actor.id } : void 0
+				metadata: { actorId: actor.id }
 			})]);
 			this.logger.info("comment removed", {
 				orgId,
@@ -313,85 +460,96 @@ var DiscussionServiceImpl = class {
 			});
 			return updated;
 		});
+		return this.renderOne(removed, where, actor);
 	}
-	async restore(orgId, commentId, actor, communityId) {
-		return this.renderOne(orgId, await this.restoreComment(orgId, commentId, actor, communityId), actor);
+	async restore(commentId, within, actor) {
+		const comment = await this.findIn(commentId, within, actor, "restore");
+		const where = await this.whereOf(comment, actor);
+		this.requireModerates(actor, where);
+		return this.renderOne(await this.restoreComment(comment, actor), where, actor);
 	}
-	async restoreComment(orgId, commentId, actor, communityId) {
-		if (!this.isStaff(actor)) throw new ForbiddenError("You cannot restore this comment");
-		const comment = await this.getComment(orgId, commentId);
-		if (!comment || !this.inCommunity(comment, communityId)) {
-			this.logger.warn("comment restore rejected — not found", {
-				orgId,
-				commentId,
-				actorId: actor.id
-			});
-			throw new NotFoundError("Comment", commentId);
-		}
+	async restoreComment(comment, actor) {
 		if (comment.status !== "removed") return comment;
-		const updated = await this.repo.updateComment(orgId, commentId, {
+		const updated = await this.repo.updateComment(actor.orgId, comment.id, {
 			status: "published",
 			removedBy: null
 		});
-		if (!updated) throw new NotFoundError("Comment", commentId);
+		if (!updated) throw new NotFoundError("Comment", comment.id);
 		this.logger.info("comment restored", {
-			orgId,
-			commentId,
+			orgId: actor.orgId,
+			commentId: comment.id,
 			actorId: actor.id
 		});
 		return updated;
 	}
-	/** Load a comment together with its activity's resolved comments config,
-	*  having proved the actor may reach that activity at all. Every path that
-	*  acts on one comment needs the pair, and none should read the row twice. */
-	async loadWithConfig(orgId, commentId, actor) {
-		const comment = await this.getComment(orgId, commentId);
+	/** Load a comment together with where it sits and the comments config that
+	*  applies there, having proved the actor may reach it at all. Every path
+	*  that acts on one comment needs them, and none should read the row twice. */
+	async loadWithConfig(commentId, actor) {
+		const comment = await this.getComment(actor.orgId, commentId);
 		if (!comment) throw new NotFoundError("Comment", commentId);
-		if (comment.postId) {
-			const { post, space } = await this.postOfComment(orgId, actor, commentId, comment.postId);
-			return {
-				comment,
-				config: {
-					enabled: this.commentsOpen(post, space),
-					threaded: true,
-					requireReview: false,
-					reactions: post.reactionsEnabled ?? space.settings.reactions
-				}
-			};
-		}
-		const activityId = this.activityIdOf(comment);
-		if (!await this.hasAccess(orgId, activityId, actor)) throw new ForbiddenError("You cannot open this activity");
+		const where = await this.whereOf(comment, actor);
+		if (where.kind === "post") return {
+			comment,
+			config: {
+				enabled: this.commentsOpen(where.post, where.space),
+				threaded: true,
+				requireReview: false,
+				reactions: where.post.reactionsEnabled ?? where.space.settings.reactions
+			},
+			where
+		};
 		return {
 			comment,
-			config: await this.resolveConfig(orgId, activityId)
+			config: await this.configOf(actor.orgId, where.activity),
+			where
 		};
 	}
-	async setReaction(orgId, commentId, actor, emoji) {
-		const { comment, config } = await this.loadWithConfig(orgId, commentId, actor);
+	async setReaction(commentId, emoji, actor) {
+		const orgId = actor.orgId;
+		const { comment, config, where } = await this.loadWithConfig(commentId, actor);
 		if (!config.enabled && !comment.postId) throw new ForbiddenError("Discussion is not open on this activity");
 		if (!config.reactions && emoji !== null) throw new ForbiddenError(comment.postId ? "Reactions are off on this post" : "Reactions are off on this course");
 		if (comment.status === "removed") throw new ForbiddenError("A removed comment cannot be reacted to");
-		await this.repo.setReaction(orgId, commentId, actor.id, emoji);
+		await this.uow.run(async (scope) => {
+			if (!await scope.discussion.setReaction(orgId, commentId, actor.id, emoji) || emoji === null) return;
+			await scope.outbox.append([discussionEvents.commentReactionAdded.make({
+				orgId,
+				data: {
+					commentId,
+					postId: comment.postId,
+					activityId: comment.activityId,
+					spaceId: where.kind === "post" ? where.post.spaceId : null,
+					communityId: comment.communityId,
+					orgUserId: actor.id,
+					reaction: emoji
+				},
+				metadata: { actorId: actor.id }
+			})]);
+		});
 		return (await this.repo.reactionsOf(orgId, [commentId], actor.id))[commentId] ?? EMPTY_REACTIONS;
 	}
-	async approve(orgId, commentId, actor) {
-		if (!this.isStaff(actor)) throw new ForbiddenError("You cannot approve this comment");
-		const comment = await this.getComment(orgId, commentId);
-		if (!comment) {
-			this.logger.warn("comment approve rejected — not found", {
-				orgId,
-				commentId,
-				actorId: actor.id
-			});
-			throw new NotFoundError("Comment", commentId);
-		}
+	async approve(commentId, actor) {
+		const comment = await this.findIn(commentId, "any", actor, "approve");
+		const where = await this.whereOf(comment, actor);
+		this.requireModerates(actor, where);
+		return this.approveComment(comment, actor);
+	}
+	async approveComment(comment, actor) {
+		const orgId = actor.orgId;
+		const commentId = comment.id;
 		if (comment.status !== "pending") throw new ForbiddenError("Only a comment awaiting review can be approved");
+		const mentioned = await this.openersOf(orgId, comment, await this.mentions.ofItem(orgId, "comment", commentId));
 		return this.uow.run(async (scope) => {
 			const updated = await scope.discussion.updateComment(orgId, commentId, { status: "published" });
 			if (!updated) throw new NotFoundError("Comment", commentId);
 			await scope.outbox.append([discussionEvents.commentPublished.make({
 				orgId,
-				data: updated
+				data: {
+					...updated,
+					mentionedOrgUserIds: mentioned
+				},
+				metadata: { actorId: actor.id }
 			})]);
 			this.logger.info("comment published", {
 				orgId,
@@ -402,51 +560,33 @@ var DiscussionServiceImpl = class {
 		});
 	}
 	/** Loads the comment and dispatches to whichever transition applies — the
-	*  caller must not decide that itself. `approve` and `restore` still enforce
-	*  their own staff check; the check here covers the third path, where a
-	*  comment is already published and neither of them would run. */
-	async publish(orgId, commentId, actor, communityId) {
-		if (!this.isStaff(actor)) throw new ForbiddenError("You cannot publish this comment");
-		const comment = await this.getComment(orgId, commentId);
-		if (!comment || !this.inCommunity(comment, communityId)) {
-			this.logger.warn("comment publish rejected — not found", {
-				orgId,
-				commentId,
-				actorId: actor.id
-			});
-			throw new NotFoundError("Comment", commentId);
-		}
-		if (comment.status === "pending") return this.approve(orgId, commentId, actor);
-		if (comment.status === "removed") return this.restoreComment(orgId, commentId, actor);
+	*  caller must not decide that itself. */
+	async publish(commentId, within, actor) {
+		const comment = await this.findIn(commentId, within, actor, "publish");
+		const where = await this.whereOf(comment, actor);
+		this.requireModerates(actor, where);
+		if (comment.status === "pending") return this.approveComment(comment, actor);
+		if (comment.status === "removed") return this.restoreComment(comment, actor);
 		return comment;
 	}
-	async resolveReports(orgId, commentId, actor, communityId) {
-		const comment = await this.getComment(orgId, commentId);
-		if (!comment || !this.inCommunity(comment, communityId)) {
-			this.logger.warn("comment reports resolve rejected — not found", {
-				orgId,
-				commentId,
-				actorId: actor.id
-			});
-			throw new NotFoundError("Comment", commentId);
-		}
-		if (comment.postId) {
-			await this.postOfComment(orgId, actor, commentId, comment.postId);
-			if (!this.canModerate(actor)) throw new ForbiddenError("You cannot work this queue");
-		} else if (!this.isStaff(actor)) throw new ForbiddenError("You cannot resolve this report");
-		await this.repo.resolveReportsFor(orgId, commentId, {
+	async resolveReports(commentId, within, actor) {
+		const comment = await this.findIn(commentId, within, actor, "reports resolve");
+		const where = await this.whereOf(comment, actor);
+		this.requireModerates(actor, where);
+		await this.repo.resolveReportsFor(actor.orgId, commentId, {
 			resolvedAt: /* @__PURE__ */ new Date(),
 			resolvedBy: actor.id,
 			resolution: "dismissed"
 		});
 		this.logger.info("comment reports resolved", {
-			orgId,
+			orgId: actor.orgId,
 			commentId,
 			actorId: actor.id
 		});
 	}
-	async reportComment(orgId, commentId, actor, reason) {
-		const { comment, config } = await this.loadWithConfig(orgId, commentId, actor);
+	async reportComment(commentId, reason, actor) {
+		const orgId = actor.orgId;
+		const { comment, config } = await this.loadWithConfig(commentId, actor);
 		if (!config.enabled && !comment.postId) throw new ForbiddenError("Discussion is not open on this activity");
 		const now = /* @__PURE__ */ new Date();
 		const report = {
@@ -474,7 +614,7 @@ var DiscussionServiceImpl = class {
 					...saved,
 					communityId: comment.communityId
 				},
-				metadata: comment.postId ? { actorOrgUserId: actor.id } : void 0
+				metadata: { actorId: actor.id }
 			})]);
 			this.logger.info("comment reported", {
 				orgId,
@@ -484,15 +624,25 @@ var DiscussionServiceImpl = class {
 			return saved;
 		});
 	}
-	async listComments(orgId, query) {
-		const page = await this.repo.listComments(orgId, query);
+	async listComments(query, actor) {
+		const orgId = actor.orgId;
+		const where = actor.permissions.where("courses:moderate");
+		if (!where.org && where.content.length === 0) {
+			this.logger.warn("comment list refused — moderates no course", {
+				orgId,
+				actorId: actor.id
+			});
+			throw new ForbiddenError("You need courses:moderate");
+		}
+		const page = await this.repo.listComments(orgId, query, where.org ? void 0 : where.content);
 		const rows = page.rows.map((r) => r.comment);
 		if (rows.length === 0) return {
 			...page,
 			rows: []
 		};
 		const reports = await this.repo.listOpenReports(orgId, rows.map((c) => c.id));
-		const authors = await this.repo.authorsOf(orgId, [.../* @__PURE__ */ new Set([...this.peopleIn(rows), ...reports.map((r) => r.orgUserId)])]);
+		const people = [.../* @__PURE__ */ new Set([...this.peopleIn(rows), ...reports.map((r) => r.orgUserId)])];
+		const [authors, permissions] = await Promise.all([this.repo.authorsOf(orgId, people), this.badgesOf(orgId, people)]);
 		const urls = this.fileUrls;
 		const byComment = /* @__PURE__ */ new Map();
 		for (const report of reports) byComment.set(report.commentId, [...byComment.get(report.commentId) ?? [], report]);
@@ -509,14 +659,14 @@ var DiscussionServiceImpl = class {
 					courseId,
 					body: comment.body,
 					status: comment.status,
-					author: authorView(orgId, author, urls),
+					author: authorView(orgId, author, urls, teamBadge(permissions.get(author.id), courseId)),
 					authorEmail: author.email,
 					removedBy: comment.removedBy,
 					reports: (byComment.get(comment.id) ?? []).map((r) => {
 						const reporter = authors[r.orgUserId];
 						if (!reporter) throw new NotFoundError("Member", r.orgUserId);
 						return {
-							reporter: authorView(orgId, reporter, urls),
+							reporter: authorView(orgId, reporter, urls, teamBadge(permissions.get(reporter.id), courseId)),
 							reason: r.reason,
 							createdAt: r.createdAt
 						};
@@ -530,28 +680,6 @@ var DiscussionServiceImpl = class {
 	getComment(orgId, commentId) {
 		return this.repo.findComment(orgId, commentId);
 	}
-	async sendDigest(orgId, now) {
-		const communityIds = await this.communities.listIds(orgId);
-		if (communityIds.length === 0) {
-			this.logger.debug("no communities for digest", { orgId });
-			return;
-		}
-		const period = now.toISOString().slice(0, 10);
-		await this.uow.run(async ({ outbox }) => {
-			await outbox.append(communityIds.map((communityId) => discussionEvents.digestDue.make({
-				orgId,
-				data: {
-					communityId,
-					period
-				}
-			})));
-		});
-		this.logger.info("digest due", {
-			orgId,
-			communities: communityIds.length,
-			period
-		});
-	}
 };
 //#endregion
 export { DEFAULT_SETTINGS, DiscussionServiceImpl };