@studious-lms/server 1.11.0 → 1.13.0

package/dist/services/discussion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discussion.d.ts","sourceRoot":"/","sources":["services/discussion.ts"],"names":[],"mappings":"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"}

package/dist/services/discussion.js

@@ -0,0 +1,625 @@
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="b10e68f8-0106-57a7-be41-a32938701565")}catch(e){}}();
+import { TRPCError } from "@trpc/server";
+import { prisma } from "../lib/prisma.js";
+import { discussionChannel, pusher } from "../lib/pusher.js";
+import { logger } from "../utils/logger.js";
+import { classMemberOrSchoolAdminWhere, classTeacherOrSchoolAdminWhere } from "../models/access.js";
+import { sendNotification } from "./notification.js";
+const authorSelect = {
+    id: true,
+    username: true,
+    profile: {
+        select: {
+            displayName: true,
+            profilePicture: true,
+            profilePictureThumbnail: true,
+        },
+    },
+};
+const attachmentSelect = {
+    id: true,
+    name: true,
+    type: true,
+    size: true,
+    path: true,
+    uploadedAt: true,
+    uploadStatus: true,
+    thumbnailId: true,
+    thumbnail: { select: { id: true, path: true } },
+};
+const reactionCounts = {
+    THUMBSUP: 0,
+    CELEBRATE: 0,
+    CARE: 0,
+    HEART: 0,
+    IDEA: 0,
+    HAPPY: 0,
+};
+const discussionInclude = {
+    author: { select: authorSelect },
+    attachments: { select: attachmentSelect },
+    tags: { select: { id: true, name: true, color: true } },
+    reactions: { select: { type: true, userId: true } },
+    _count: { select: { replies: { where: { deletedAt: null } } } },
+};
+const replyInclude = {
+    author: { select: authorSelect },
+    attachments: { select: attachmentSelect },
+    reactions: { select: { type: true, userId: true } },
+};
+const unclaimedAttachmentWhere = {
+    assignmentId: null,
+    submissionId: null,
+    annotationId: null,
+    classDraftId: null,
+    folderId: null,
+    messageId: null,
+    announcementId: null,
+    discussionId: null,
+    discussionReplyId: null,
+};
+function summarizeReactions(reactions, userId) {
+    const counts = { ...reactionCounts };
+    for (const reaction of reactions) {
+        counts[reaction.type] += 1;
+    }
+    return {
+        counts,
+        userReaction: reactions.find((reaction) => reaction.userId === userId)?.type ?? null,
+        total: reactions.length,
+    };
+}
+function serializeDiscussion(discussion, userId, unreadCount = 0) {
+    return {
+        id: discussion.id,
+        classId: discussion.classId,
+        authorId: discussion.authorId,
+        title: discussion.title,
+        body: discussion.body,
+        type: discussion.type,
+        isPinned: discussion.isPinned,
+        isLocked: discussion.isLocked,
+        allowReplies: discussion.allowReplies,
+        createdAt: discussion.createdAt,
+        updatedAt: discussion.updatedAt,
+        lastActivityAt: discussion.lastActivityAt,
+        author: discussion.author,
+        attachments: discussion.attachments,
+        tags: discussion.tags,
+        replyCount: discussion._count.replies,
+        hasAcceptedAnswer: false,
+        reactions: summarizeReactions(discussion.reactions, userId),
+        unreadCount,
+    };
+}
+function serializeReply(reply, userId) {
+    return {
+        id: reply.id,
+        discussionId: reply.discussionId,
+        authorId: reply.authorId,
+        parentId: reply.parentId,
+        body: reply.deletedAt ? "[deleted]" : reply.body,
+        deletedAt: reply.deletedAt,
+        isAcceptedAnswer: reply.isAcceptedAnswer,
+        createdAt: reply.createdAt,
+        modifiedAt: reply.modifiedAt,
+        author: reply.author,
+        attachments: reply.deletedAt ? [] : reply.attachments,
+        reactions: summarizeReactions(reply.reactions, userId),
+    };
+}
+export function buildReplyTree(replies, userId) {
+    const byId = new Map();
+    const roots = [];
+    for (const reply of replies) {
+        byId.set(reply.id, { ...serializeReply(reply, userId), children: [] });
+    }
+    for (const reply of replies) {
+        const node = byId.get(reply.id);
+        if (reply.parentId && byId.has(reply.parentId)) {
+            byId.get(reply.parentId).children.push(node);
+        }
+        else {
+            roots.push(node);
+        }
+    }
+    return roots;
+}
+function isWithinAuthorEditWindow(createdAt) {
+    return Date.now() - createdAt.getTime() <= 24 * 60 * 60 * 1000;
+}
+export async function getDiscussionClassAccess(classId, userId) {
+    const classData = await prisma.class.findFirst({
+        where: { id: classId, ...classMemberOrSchoolAdminWhere(userId) },
+        select: {
+            id: true,
+            name: true,
+            discussionsEnabled: true,
+            studentsCanCreateDiscussions: true,
+            studentsCanReply: true,
+            students: { where: { id: userId }, select: { id: true } },
+            teachers: { where: { id: userId }, select: { id: true } },
+            school: {
+                select: {
+                    memberships: {
+                        where: { userId, role: "ADMIN", status: "ACTIVE" },
+                        select: { userId: true },
+                    },
+                },
+            },
+        },
+    });
+    if (!classData) {
+        throw new TRPCError({ code: "FORBIDDEN", message: "Not a member in this class" });
+    }
+    if (!classData.discussionsEnabled) {
+        throw new TRPCError({ code: "FORBIDDEN", message: "Discussions are disabled for this class" });
+    }
+    const isTeacher = classData.teachers.length > 0 || Boolean(classData.school?.memberships.length);
+    const isStudent = classData.students.length > 0;
+    return { ...classData, isTeacher, isStudent };
+}
+async function getDiscussionForUser(discussionId, userId) {
+    const discussion = await prisma.discussion.findUnique({
+        where: { id: discussionId },
+        include: {
+            class: {
+                select: {
+                    id: true,
+                    discussionsEnabled: true,
+                    studentsCanReply: true,
+                    teachers: { where: { id: userId }, select: { id: true } },
+                    students: { where: { id: userId }, select: { id: true } },
+                    school: {
+                        select: {
+                            memberships: {
+                                where: { userId, role: "ADMIN", status: "ACTIVE" },
+                                select: { userId: true },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    });
+    if (!discussion) {
+        throw new TRPCError({ code: "NOT_FOUND", message: "Discussion not found" });
+    }
+    const isTeacher = discussion.class.teachers.length > 0 || Boolean(discussion.class.school?.memberships.length);
+    const isStudent = discussion.class.students.length > 0;
+    if (!isTeacher && !isStudent) {
+        throw new TRPCError({ code: "FORBIDDEN", message: "Not a member in this class" });
+    }
+    if (!discussion.class.discussionsEnabled) {
+        throw new TRPCError({ code: "FORBIDDEN", message: "Discussions are disabled for this class" });
+    }
+    return { discussion, isTeacher, isStudent };
+}
+async function claimDiscussionAttachments(tx, userId, discussionId, attachmentIds = []) {
+    const uniqueIds = [...new Set(attachmentIds)];
+    if (!uniqueIds.length)
+        return;
+    const { count } = await tx.file.updateMany({
+        where: { id: { in: uniqueIds }, userId, uploadStatus: "COMPLETED", ...unclaimedAttachmentWhere },
+        data: { discussionId },
+    });
+    if (count !== uniqueIds.length) {
+        throw new TRPCError({ code: "BAD_REQUEST", message: "Some attachments are missing, unfinished, or unavailable" });
+    }
+}
+async function claimReplyAttachments(tx, userId, replyId, attachmentIds = []) {
+    const uniqueIds = [...new Set(attachmentIds)];
+    if (!uniqueIds.length)
+        return;
+    const { count } = await tx.file.updateMany({
+        where: { id: { in: uniqueIds }, userId, uploadStatus: "COMPLETED", ...unclaimedAttachmentWhere },
+        data: { discussionReplyId: replyId },
+    });
+    if (count !== uniqueIds.length) {
+        throw new TRPCError({ code: "BAD_REQUEST", message: "Some attachments are missing, unfinished, or unavailable" });
+    }
+}
+function triggerDiscussionEvent(classId, event, payload) {
+    pusher.trigger(discussionChannel(classId), event, payload).catch((error) => {
+        logger.error("Failed to trigger discussion pusher event", { event, classId, error });
+    });
+}
+async function notify(receiverId, senderId, title, content) {
+    if (!receiverId || receiverId === senderId)
+        return;
+    await sendNotification({ receiverId, title, content }).catch((error) => {
+        logger.error("Failed to send discussion notification", { receiverId, error });
+    });
+}
+async function notifyMentionedUsers(classId, senderId, body, link) {
+    const usernames = [...new Set(Array.from(body.matchAll(/(^|\s)@([a-zA-Z0-9_.-]{2,32})/g)).map((match) => match[2]))];
+    if (!usernames.length)
+        return;
+    const members = await prisma.user.findMany({
+        where: {
+            username: { in: usernames },
+            OR: [
+                { teacherIn: { some: { id: classId } } },
+                { studentIn: { some: { id: classId } } },
+                { schoolMemberships: { some: { status: "ACTIVE", school: { classes: { some: { id: classId } } } } } },
+            ],
+        },
+        select: { id: true },
+    });
+    await Promise.all(members.map((member) => notify(member.id, senderId, "You were mentioned in a discussion", link)));
+}
+async function unreadCountsForDiscussions(userId, discussionIds) {
+    if (!discussionIds.length)
+        return new Map();
+    const reads = await prisma.discussionRead.findMany({
+        where: { userId, discussionId: { in: discussionIds } },
+        select: { discussionId: true, lastReadAt: true },
+    });
+    const readMap = new Map(reads.map((read) => [read.discussionId, read.lastReadAt]));
+    const neverRead = discussionIds.filter((discussionId) => !readMap.has(discussionId));
+    const readPredicates = Array.from(readMap.entries()).map(([discussionId, lastReadAt]) => ({
+        discussionId,
+        createdAt: { gt: lastReadAt },
+    }));
+    const counts = new Map();
+    const [neverReadCounts, readCounts] = await Promise.all([
+        neverRead.length
+            ? prisma.discussionReply.groupBy({
+                by: ["discussionId"],
+                where: { discussionId: { in: neverRead }, deletedAt: null, authorId: { not: userId } },
+                _count: true,
+            })
+            : Promise.resolve([]),
+        readPredicates.length
+            ? prisma.discussionReply.groupBy({
+                by: ["discussionId"],
+                where: { deletedAt: null, authorId: { not: userId }, OR: readPredicates },
+                _count: true,
+            })
+            : Promise.resolve([]),
+    ]);
+    for (const item of [...neverReadCounts, ...readCounts]) {
+        counts.set(item.discussionId, item._count);
+    }
+    return counts;
+}
+export async function listDiscussions(userId, input) {
+    await getDiscussionClassAccess(input.classId, userId);
+    const where = {
+        classId: input.classId,
+        ...(input.tagId ? { tags: { some: { id: input.tagId } } } : {}),
+        ...(input.type ? { type: input.type } : {}),
+        ...(input.search?.trim()
+            ? {
+                OR: [
+                    { title: { contains: input.search.trim(), mode: "insensitive" } },
+                    { body: { contains: input.search.trim(), mode: "insensitive" } },
+                ],
+            }
+            : {}),
+    };
+    const orderBy = input.sort === "recent"
+        ? [{ isPinned: "desc" }, { createdAt: "desc" }]
+        : input.sort === "top"
+            ? [{ isPinned: "desc" }, { replies: { _count: "desc" } }, { lastActivityAt: "desc" }]
+            : [{ isPinned: "desc" }, { lastActivityAt: "desc" }];
+    const items = await prisma.discussion.findMany({
+        where,
+        include: discussionInclude,
+        orderBy,
+        cursor: input.cursor ? { id: input.cursor } : undefined,
+        skip: input.cursor ? 1 : 0,
+        take: input.limit + 1,
+    });
+    const next = items.length > input.limit ? items.pop() : undefined;
+    const unreadMap = await unreadCountsForDiscussions(userId, items.map((item) => item.id));
+    const accepted = await prisma.discussionReply.groupBy({
+        by: ["discussionId"],
+        where: { discussionId: { in: items.map((item) => item.id) }, isAcceptedAnswer: true, deletedAt: null },
+    });
+    const acceptedIds = new Set(accepted.map((item) => item.discussionId));
+    return {
+        items: items.map((item) => ({
+            ...serializeDiscussion(item, userId, unreadMap.get(item.id) ?? 0),
+            hasAcceptedAnswer: acceptedIds.has(item.id),
+        })),
+        nextCursor: next?.id,
+    };
+}
+export async function getDiscussion(userId, discussionId) {
+    const { discussion: accessDiscussion, isTeacher } = await getDiscussionForUser(discussionId, userId);
+    const [discussion, replies, myReaction] = await Promise.all([
+        prisma.discussion.findUniqueOrThrow({ where: { id: discussionId }, include: discussionInclude }),
+        prisma.discussionReply.findMany({ where: { discussionId }, include: replyInclude, orderBy: { createdAt: "asc" } }),
+        prisma.reaction.findUnique({ where: { userId_discussionId: { userId, discussionId } }, select: { type: true } }),
+        prisma.discussionRead.upsert({
+            where: { userId_discussionId: { userId, discussionId } },
+            update: { lastReadAt: new Date() },
+            create: { userId, discussionId },
+        }),
+    ]);
+    const canAuthorEdit = accessDiscussion.authorId === userId && isWithinAuthorEditWindow(accessDiscussion.createdAt);
+    const canReply = isTeacher || (accessDiscussion.class.studentsCanReply && !accessDiscussion.isLocked && accessDiscussion.allowReplies);
+    return {
+        discussion: serializeDiscussion(discussion, userId),
+        replies: buildReplyTree(replies, userId),
+        myReaction: myReaction?.type ?? null,
+        canEdit: isTeacher || canAuthorEdit,
+        canPin: isTeacher,
+        canLock: isTeacher,
+        canDelete: isTeacher || accessDiscussion.authorId === userId,
+        canReply,
+    };
+}
+export async function createDiscussion(userId, input) {
+    const classData = await getDiscussionClassAccess(input.classId, userId);
+    if (!classData.isTeacher && !classData.studentsCanCreateDiscussions) {
+        throw new TRPCError({ code: "FORBIDDEN", message: "Students cannot create discussions in this class" });
+    }
+    if (input.type === "ANNOUNCEMENT" && !classData.isTeacher) {
+        throw new TRPCError({ code: "FORBIDDEN", message: "Only teachers can create announcement discussions" });
+    }
+    const discussion = await prisma.$transaction(async (tx) => {
+        const created = await tx.discussion.create({
+            data: {
+                classId: input.classId,
+                authorId: userId,
+                title: input.title.trim(),
+                body: input.body.trim(),
+                type: input.type,
+                allowReplies: input.type !== "ANNOUNCEMENT",
+                tags: input.tagIds?.length ? { connect: input.tagIds.map((id) => ({ id })) } : undefined,
+            },
+        });
+        await claimDiscussionAttachments(tx, userId, created.id, input.attachmentIds);
+        return tx.discussion.findUniqueOrThrow({ where: { id: created.id }, include: discussionInclude });
+    });
+    triggerDiscussionEvent(input.classId, "discussion-created", { discussion: serializeDiscussion(discussion, userId) });
+    await notifyMentionedUsers(input.classId, userId, input.body, `/class/${input.classId}/discussions/${discussion.id}`);
+    return { discussion: serializeDiscussion(discussion, userId) };
+}
+export async function updateDiscussion(userId, input) {
+    const { discussion, isTeacher } = await getDiscussionForUser(input.discussionId, userId);
+    if (!isTeacher && !(discussion.authorId === userId && isWithinAuthorEditWindow(discussion.createdAt))) {
+        throw new TRPCError({ code: "FORBIDDEN", message: "You cannot edit this discussion" });
+    }
+    if (input.type === "ANNOUNCEMENT" && !isTeacher) {
+        throw new TRPCError({ code: "FORBIDDEN", message: "Only teachers can create announcement discussions" });
+    }
+    const updated = await prisma.discussion.update({
+        where: { id: input.discussionId },
+        data: {
+            ...(input.title !== undefined ? { title: input.title.trim() } : {}),
+            ...(input.body !== undefined ? { body: input.body.trim() } : {}),
+            ...(input.type !== undefined ? { type: input.type } : {}),
+            ...(input.allowReplies !== undefined ? { allowReplies: input.allowReplies } : {}),
+            ...(input.tagIds ? { tags: { set: input.tagIds.map((id) => ({ id })) } } : {}),
+        },
+        include: discussionInclude,
+    });
+    triggerDiscussionEvent(updated.classId, "discussion-updated", { discussion: serializeDiscussion(updated, userId) });
+    return { discussion: serializeDiscussion(updated, userId) };
+}
+export async function deleteDiscussion(userId, discussionId) {
+    const { discussion, isTeacher } = await getDiscussionForUser(discussionId, userId);
+    if (!isTeacher && discussion.authorId !== userId) {
+        throw new TRPCError({ code: "FORBIDDEN", message: "You cannot delete this discussion" });
+    }
+    await prisma.discussion.delete({ where: { id: discussionId } });
+    triggerDiscussionEvent(discussion.classId, "discussion-deleted", { discussionId });
+    return { success: true };
+}
+export async function replyToDiscussion(userId, input) {
+    const { discussion, isTeacher } = await getDiscussionForUser(input.discussionId, userId);
+    const canReply = isTeacher || (discussion.class.studentsCanReply && !discussion.isLocked && discussion.allowReplies);
+    if (!canReply) {
+        throw new TRPCError({ code: "FORBIDDEN", message: "You cannot reply to this discussion" });
+    }
+    let parent = null;
+    if (input.parentReplyId) {
+        parent = await prisma.discussionReply.findFirst({
+            where: { id: input.parentReplyId, discussionId: input.discussionId },
+            select: { id: true, authorId: true },
+        });
+        if (!parent)
+            throw new TRPCError({ code: "NOT_FOUND", message: "Parent reply not found" });
+    }
+    const reply = await prisma.$transaction(async (tx) => {
+        const created = await tx.discussionReply.create({
+            data: {
+                discussionId: input.discussionId,
+                authorId: userId,
+                parentId: input.parentReplyId,
+                body: input.body.trim(),
+            },
+        });
+        await claimReplyAttachments(tx, userId, created.id, input.attachmentIds);
+        await tx.discussion.update({
+            where: { id: input.discussionId },
+            data: { lastActivityAt: new Date() },
+        });
+        return tx.discussionReply.findUniqueOrThrow({ where: { id: created.id }, include: replyInclude });
+    });
+    const link = `/class/${discussion.classId}/discussions/${discussion.id}#${reply.id}`;
+    await Promise.all([
+        notify(discussion.authorId, userId, "New reply to your discussion", link),
+        notify(parent?.authorId, userId, "New reply in a discussion thread", link),
+        notifyMentionedUsers(discussion.classId, userId, input.body, link),
+    ]);
+    triggerDiscussionEvent(discussion.classId, "reply-created", { discussionId: discussion.id, reply: serializeReply(reply, userId) });
+    return { reply: serializeReply(reply, userId) };
+}
+export async function updateDiscussionReply(userId, input) {
+    const existing = await prisma.discussionReply.findUnique({ where: { id: input.replyId }, include: { discussion: true } });
+    if (!existing)
+        throw new TRPCError({ code: "NOT_FOUND", message: "Reply not found" });
+    const { isTeacher } = await getDiscussionForUser(existing.discussionId, userId);
+    if (!isTeacher && !(existing.authorId === userId && isWithinAuthorEditWindow(existing.createdAt))) {
+        throw new TRPCError({ code: "FORBIDDEN", message: "You cannot edit this reply" });
+    }
+    const reply = await prisma.$transaction(async (tx) => {
+        await tx.file.updateMany({ where: { discussionReplyId: input.replyId }, data: { discussionReplyId: null } });
+        await claimReplyAttachments(tx, userId, input.replyId, input.attachmentIds);
+        return tx.discussionReply.update({
+            where: { id: input.replyId },
+            data: { body: input.body.trim(), deletedAt: null },
+            include: replyInclude,
+        });
+    });
+    triggerDiscussionEvent(existing.discussion.classId, "reply-updated", { discussionId: existing.discussionId, reply: serializeReply(reply, userId) });
+    return { reply: serializeReply(reply, userId) };
+}
+export async function deleteDiscussionReply(userId, replyId) {
+    const existing = await prisma.discussionReply.findUnique({ where: { id: replyId }, include: { discussion: true } });
+    if (!existing)
+        throw new TRPCError({ code: "NOT_FOUND", message: "Reply not found" });
+    const { isTeacher } = await getDiscussionForUser(existing.discussionId, userId);
+    if (!isTeacher && existing.authorId !== userId) {
+        throw new TRPCError({ code: "FORBIDDEN", message: "You cannot delete this reply" });
+    }
+    const reply = await prisma.discussionReply.update({
+        where: { id: replyId },
+        data: { body: "[deleted]", deletedAt: new Date(), isAcceptedAnswer: false },
+        include: replyInclude,
+    });
+    triggerDiscussionEvent(existing.discussion.classId, "reply-deleted", { discussionId: existing.discussionId, reply: serializeReply(reply, userId) });
+    return { reply: serializeReply(reply, userId) };
+}
+export async function pinDiscussion(userId, discussionId, isPinned) {
+    const { discussion, isTeacher } = await getDiscussionForUser(discussionId, userId);
+    if (!isTeacher)
+        throw new TRPCError({ code: "FORBIDDEN", message: "Only teachers can pin discussions" });
+    const updated = await prisma.discussion.update({ where: { id: discussionId }, data: { isPinned }, include: discussionInclude });
+    await notify(discussion.authorId, userId, isPinned ? "Your discussion was pinned" : "Your discussion was unpinned", `/class/${discussion.classId}/discussions/${discussionId}`);
+    triggerDiscussionEvent(discussion.classId, "discussion-updated", { discussion: serializeDiscussion(updated, userId) });
+    return { discussion: serializeDiscussion(updated, userId) };
+}
+export async function lockDiscussion(userId, discussionId, isLocked) {
+    const { discussion, isTeacher } = await getDiscussionForUser(discussionId, userId);
+    if (!isTeacher)
+        throw new TRPCError({ code: "FORBIDDEN", message: "Only teachers can lock discussions" });
+    const updated = await prisma.discussion.update({ where: { id: discussionId }, data: { isLocked }, include: discussionInclude });
+    triggerDiscussionEvent(discussion.classId, "discussion-updated", { discussion: serializeDiscussion(updated, userId) });
+    return { discussion: serializeDiscussion(updated, userId) };
+}
+export async function markAcceptedAnswer(userId, replyId, accepted) {
+    const reply = await prisma.discussionReply.findUnique({ where: { id: replyId }, include: { discussion: true } });
+    if (!reply)
+        throw new TRPCError({ code: "NOT_FOUND", message: "Reply not found" });
+    const { isTeacher } = await getDiscussionForUser(reply.discussionId, userId);
+    if (reply.discussion.type !== "QUESTION") {
+        throw new TRPCError({ code: "BAD_REQUEST", message: "Only question discussions can have accepted answers" });
+    }
+    if (!isTeacher && reply.discussion.authorId !== userId) {
+        throw new TRPCError({ code: "FORBIDDEN", message: "Only the discussion author or a teacher can mark an accepted answer" });
+    }
+    const updated = await prisma.$transaction(async (tx) => {
+        if (accepted) {
+            await tx.discussionReply.updateMany({ where: { discussionId: reply.discussionId, isAcceptedAnswer: true }, data: { isAcceptedAnswer: false } });
+        }
+        return tx.discussionReply.update({ where: { id: replyId }, data: { isAcceptedAnswer: accepted }, include: replyInclude });
+    });
+    await notify(reply.authorId, userId, accepted ? "Your answer was accepted" : "Your answer was unmarked", `/class/${reply.discussion.classId}/discussions/${reply.discussionId}#${replyId}`);
+    triggerDiscussionEvent(reply.discussion.classId, "reply-updated", { discussionId: reply.discussionId, reply: serializeReply(updated, userId) });
+    return { reply: serializeReply(updated, userId) };
+}
+export async function markDiscussionRead(userId, discussionId) {
+    await getDiscussionForUser(discussionId, userId);
+    return prisma.discussionRead.upsert({
+        where: { userId_discussionId: { userId, discussionId } },
+        update: { lastReadAt: new Date() },
+        create: { userId, discussionId },
+    });
+}
+export async function getUnreadCounts(userId, classIds) {
+    const allowedClasses = await prisma.class.findMany({
+        where: { id: { in: classIds }, discussionsEnabled: true, ...classMemberOrSchoolAdminWhere(userId) },
+        select: { id: true },
+    });
+    const result = {};
+    for (const cls of allowedClasses) {
+        const discussions = await prisma.discussion.findMany({
+            where: { classId: cls.id },
+            select: { id: true },
+        });
+        const countMap = await unreadCountsForDiscussions(userId, discussions.map((discussion) => discussion.id));
+        const perDiscussion = Array.from(countMap.entries())
+            .map(([discussionId, count]) => ({ discussionId, count }))
+            .filter((item) => item.count > 0);
+        result[cls.id] = {
+            total: perDiscussion.reduce((sum, item) => sum + item.count, 0),
+            perDiscussion,
+        };
+    }
+    return result;
+}
+export async function toggleDiscussionReaction(userId, input) {
+    if (!input.discussionId && !input.discussionReplyId) {
+        throw new TRPCError({ code: "BAD_REQUEST", message: "A discussion or reply is required" });
+    }
+    if (input.discussionId && input.discussionReplyId) {
+        throw new TRPCError({ code: "BAD_REQUEST", message: "React to either a discussion or a reply" });
+    }
+    const target = input.discussionId
+        ? await getDiscussionForUser(input.discussionId, userId).then(({ discussion }) => ({ classId: discussion.classId, discussionId: discussion.id }))
+        : await prisma.discussionReply.findUnique({ where: { id: input.discussionReplyId }, include: { discussion: true } }).then(async (reply) => {
+            if (!reply)
+                throw new TRPCError({ code: "NOT_FOUND", message: "Reply not found" });
+            await getDiscussionForUser(reply.discussionId, userId);
+            return { classId: reply.discussion.classId, discussionId: reply.discussionId };
+        });
+    const where = input.discussionId
+        ? { userId_discussionId: { userId, discussionId: input.discussionId } }
+        : { userId_discussionReplyId: { userId, discussionReplyId: input.discussionReplyId } };
+    const existing = await prisma.reaction.findUnique({ where });
+    if (existing?.type === input.type) {
+        await prisma.reaction.delete({ where: { id: existing.id } });
+        triggerDiscussionEvent(target.classId, "reaction-removed", { discussionId: target.discussionId, discussionReplyId: input.discussionReplyId, userId });
+        return { reaction: null };
+    }
+    const reaction = input.discussionId
+        ? await prisma.reaction.upsert({
+            where: { userId_discussionId: { userId, discussionId: input.discussionId } },
+            update: { type: input.type },
+            create: { userId, discussionId: input.discussionId, type: input.type },
+        })
+        : await prisma.reaction.upsert({
+            where: { userId_discussionReplyId: { userId, discussionReplyId: input.discussionReplyId } },
+            update: { type: input.type },
+            create: { userId, discussionReplyId: input.discussionReplyId, type: input.type },
+        });
+    triggerDiscussionEvent(target.classId, "reaction-added", { discussionId: target.discussionId, discussionReplyId: input.discussionReplyId, reaction });
+    return { reaction };
+}
+export async function listDiscussionTags(userId, classId) {
+    await getDiscussionClassAccess(classId, userId);
+    return prisma.discussionTag.findMany({ where: { classId }, orderBy: { name: "asc" } });
+}
+export async function createDiscussionTag(userId, input) {
+    const isTeacher = await prisma.class.findFirst({ where: { id: input.classId, ...classTeacherOrSchoolAdminWhere(userId) }, select: { id: true, discussionsEnabled: true } });
+    if (!isTeacher?.discussionsEnabled)
+        throw new TRPCError({ code: "FORBIDDEN", message: "Only teachers can manage discussion tags" });
+    return prisma.discussionTag.create({ data: { classId: input.classId, name: input.name.trim(), color: input.color } });
+}
+export async function updateDiscussionTag(userId, input) {
+    const tag = await prisma.discussionTag.findUnique({ where: { id: input.tagId }, select: { classId: true } });
+    if (!tag)
+        throw new TRPCError({ code: "NOT_FOUND", message: "Tag not found" });
+    const isTeacher = await prisma.class.findFirst({ where: { id: tag.classId, ...classTeacherOrSchoolAdminWhere(userId) }, select: { id: true, discussionsEnabled: true } });
+    if (!isTeacher?.discussionsEnabled)
+        throw new TRPCError({ code: "FORBIDDEN", message: "Only teachers can manage discussion tags" });
+    return prisma.discussionTag.update({ where: { id: input.tagId }, data: { name: input.name?.trim(), color: input.color } });
+}
+export async function deleteDiscussionTag(userId, tagId) {
+    const tag = await prisma.discussionTag.findUnique({ where: { id: tagId }, select: { classId: true } });
+    if (!tag)
+        throw new TRPCError({ code: "NOT_FOUND", message: "Tag not found" });
+    const isTeacher = await prisma.class.findFirst({ where: { id: tag.classId, ...classTeacherOrSchoolAdminWhere(userId) }, select: { id: true, discussionsEnabled: true } });
+    if (!isTeacher?.discussionsEnabled)
+        throw new TRPCError({ code: "FORBIDDEN", message: "Only teachers can manage discussion tags" });
+    await prisma.discussionTag.delete({ where: { id: tagId } });
+    return { success: true };
+}
+//# sourceMappingURL=discussion.js.map
+//# debugId=b10e68f8-0106-57a7-be41-a32938701565