@studious-lms/server 1.9.0 → 1.12.0

package/tests/integration/routers/discussion.test.ts

@@ -0,0 +1,253 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { expectForbidden, expectUnauth } from '../helpers';
+import { user1Caller, user2Caller, user3Caller } from '../setup';
+
+vi.mock('../../../src/lib/pusher.js', async () => ({
+  pusher: { trigger: vi.fn().mockResolvedValue(undefined) },
+  chatChannel: (conversationId: string) => `private-conversation-${conversationId}`,
+  worksheetChannel: (worksheetResponseId: string) => `private-worksheet-${worksheetResponseId}`,
+  teacherChannel: (classId: string) => `private-teacher-${classId}`,
+  discussionChannel: (classId: string) => `private-class-${classId}-discussions`,
+  worksheetJobChannel: (worksheetId: string) => `private-worksheet-job-${worksheetId}`,
+}));
+
+describe('Discussion Router', () => {
+  let testClass: any;
+  let studentId: string;
+  let secondStudentId: string;
+
+  beforeEach(async () => {
+    testClass = await user1Caller.class.create({
+      name: `Discussion Test Class ${Date.now()}`,
+      subject: 'History',
+      section: '12th Grade',
+    });
+
+    const studentProfile = await user2Caller.user.getProfile();
+    const secondStudentProfile = await user3Caller.user.getProfile();
+    studentId = studentProfile.id;
+    secondStudentId = secondStudentProfile.id;
+
+    await user1Caller.class.addStudent({
+      classId: testClass.id,
+      studentId,
+    });
+    await user1Caller.class.addStudent({
+      classId: testClass.id,
+      studentId: secondStudentId,
+    });
+  });
+
+  test('creates, lists, searches, paginates, tags, and reacts to discussions', async () => {
+    const tag = await user1Caller.discussion.tags.create({
+      classId: testClass.id,
+      name: `Review ${Date.now()}`,
+      color: '#3B82F6',
+    });
+
+    const first = await user1Caller.discussion.create({
+      classId: testClass.id,
+      title: 'Primary source analysis',
+      body: 'Discuss the archive packet.',
+      type: 'DISCUSSION',
+      tagIds: [tag.id],
+    });
+    const question = await user1Caller.discussion.create({
+      classId: testClass.id,
+      title: 'Exam review question',
+      body: 'Where should we focus?',
+      type: 'QUESTION',
+    });
+    await user1Caller.discussion.create({
+      classId: testClass.id,
+      title: 'Reading logistics',
+      body: 'Bring the printed handout.',
+      type: 'ANNOUNCEMENT',
+    });
+
+    await user1Caller.discussion.pin({
+      discussionId: first.discussion.id,
+      isPinned: true,
+    });
+
+    await user2Caller.discussion.reply({
+      discussionId: first.discussion.id,
+      body: 'I found one strong quote.',
+    });
+    await user2Caller.discussion.reply({
+      discussionId: first.discussion.id,
+      body: 'A second point for ranking.',
+    });
+    await user2Caller.discussion.reply({
+      discussionId: question.discussion.id,
+      body: 'Focus on the essay question.',
+    });
+
+    const list = await user2Caller.discussion.list({
+      classId: testClass.id,
+      sort: 'top',
+      limit: 2,
+    });
+    expect(list.items).toHaveLength(2);
+    expect(list.nextCursor).toBeDefined();
+    expect(list.items[0].id).toBe(first.discussion.id);
+    expect(list.items[0].isPinned).toBe(true);
+    expect(list.items[0].replyCount).toBe(2);
+
+    const search = await user2Caller.discussion.list({
+      classId: testClass.id,
+      search: 'exam review',
+      sort: 'activity',
+      limit: 10,
+    });
+    expect(search.items.map((item: any) => item.id)).toContain(question.discussion.id);
+
+    const byTag = await user2Caller.discussion.list({
+      classId: testClass.id,
+      tagId: tag.id,
+      sort: 'activity',
+      limit: 10,
+    });
+    expect(byTag.items.map((item: any) => item.id)).toEqual([first.discussion.id]);
+
+    const reaction = await user2Caller.discussion.reactions.toggle({
+      discussionId: first.discussion.id,
+      type: 'HEART',
+    });
+    expect(reaction.reaction?.type).toBe('HEART');
+
+    const removedReaction = await user2Caller.discussion.reactions.toggle({
+      discussionId: first.discussion.id,
+      type: 'HEART',
+    });
+    expect(removedReaction.reaction).toBeNull();
+  });
+
+  test('returns nested replies, preserves children after soft delete, and toggles accepted answers', async () => {
+    const created = await user1Caller.discussion.create({
+      classId: testClass.id,
+      title: 'Question thread',
+      body: 'Which answer is best?',
+      type: 'QUESTION',
+    });
+
+    const parent = await user2Caller.discussion.reply({
+      discussionId: created.discussion.id,
+      body: 'This is my answer.',
+    });
+    const child = await user3Caller.discussion.reply({
+      discussionId: created.discussion.id,
+      parentReplyId: parent.reply.id,
+      body: 'Adding evidence under that answer.',
+    });
+
+    const accepted = await user1Caller.discussion.markAcceptedAnswer({
+      replyId: parent.reply.id,
+      accepted: true,
+    });
+    expect(accepted.reply.isAcceptedAnswer).toBe(true);
+
+    const deleted = await user2Caller.discussion.deleteReply({
+      replyId: parent.reply.id,
+    });
+    expect(deleted.reply.body).toBe('[deleted]');
+    expect(deleted.reply.deletedAt).toBeTruthy();
+
+    const thread = await user1Caller.discussion.get({
+      discussionId: created.discussion.id,
+    });
+    expect(thread.replies).toHaveLength(1);
+    expect(thread.replies[0].id).toBe(parent.reply.id);
+    expect(thread.replies[0].body).toBe('[deleted]');
+    expect(thread.replies[0].children[0].id).toBe(child.reply.id);
+  });
+
+  test('computes unread counts after a reader marks a discussion read', async () => {
+    const created = await user1Caller.discussion.create({
+      classId: testClass.id,
+      title: 'Unread count thread',
+      body: 'Watch unread counts here.',
+      type: 'DISCUSSION',
+    });
+
+    await user2Caller.discussion.get({ discussionId: created.discussion.id });
+    await user3Caller.discussion.reply({
+      discussionId: created.discussion.id,
+      body: 'This should be unread for the first student.',
+    });
+
+    const counts = await user2Caller.discussion.getUnreadCounts({
+      classIds: [testClass.id],
+    });
+    expect(counts[testClass.id].total).toBe(1);
+    expect(counts[testClass.id].perDiscussion).toEqual([
+      { discussionId: created.discussion.id, count: 1 },
+    ]);
+
+    await user2Caller.discussion.markRead({ discussionId: created.discussion.id });
+    const afterRead = await user2Caller.discussion.getUnreadCounts({
+      classIds: [testClass.id],
+    });
+    expect(afterRead[testClass.id].total).toBe(0);
+  });
+
+  test('enforces discussion authorization branches', async () => {
+    await expectUnauth((caller) => caller.discussion.list({
+      classId: testClass.id,
+      sort: 'activity',
+      limit: 10,
+    }));
+
+    await expectForbidden(() => user2Caller.discussion.create({
+      classId: testClass.id,
+      title: 'Student announcement',
+      body: 'Students cannot make this type.',
+      type: 'ANNOUNCEMENT',
+    }));
+
+    await user1Caller.class.update({
+      classId: testClass.id,
+      studentsCanCreateDiscussions: false,
+    });
+    await expectForbidden(() => user2Caller.discussion.create({
+      classId: testClass.id,
+      title: 'Blocked student discussion',
+      body: 'This should not create.',
+      type: 'DISCUSSION',
+    }));
+
+    const created = await user1Caller.discussion.create({
+      classId: testClass.id,
+      title: 'Teacher managed thread',
+      body: 'Teacher owns this.',
+      type: 'DISCUSSION',
+    });
+
+    await expectForbidden(() => user2Caller.discussion.pin({
+      discussionId: created.discussion.id,
+      isPinned: true,
+    }));
+
+    await user1Caller.discussion.lock({
+      discussionId: created.discussion.id,
+      isLocked: true,
+    });
+    await expectForbidden(() => user2Caller.discussion.reply({
+      discussionId: created.discussion.id,
+      body: 'Student cannot reply to locked thread.',
+    }));
+
+    await user1Caller.class.update({
+      classId: testClass.id,
+      discussionsEnabled: false,
+    });
+    await expectForbidden(() => user1Caller.discussion.list({
+      classId: testClass.id,
+      sort: 'activity',
+      limit: 10,
+    }));
+    await expectForbidden(() => user1Caller.discussion.get({
+      discussionId: created.discussion.id,
+    }));
+  });
+});

package/tests/unit/services/discussion.test.ts

@@ -0,0 +1,356 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { TRPCError } from "@trpc/server";
+
+const { prismaMocks, pusherMocks, notificationMocks } = vi.hoisted(() => ({
+  prismaMocks: {
+    class: { findFirst: vi.fn(), findMany: vi.fn() },
+    discussion: {
+      findUnique: vi.fn(),
+      findUniqueOrThrow: vi.fn(),
+      findMany: vi.fn(),
+      create: vi.fn(),
+      update: vi.fn(),
+      delete: vi.fn(),
+    },
+    discussionReply: {
+      findUnique: vi.fn(),
+      findMany: vi.fn(),
+      create: vi.fn(),
+      update: vi.fn(),
+      updateMany: vi.fn(),
+      count: vi.fn(),
+      groupBy: vi.fn(),
+    },
+    discussionRead: {
+      findMany: vi.fn(),
+      upsert: vi.fn(),
+    },
+    reaction: {
+      findUnique: vi.fn(),
+      upsert: vi.fn(),
+      delete: vi.fn(),
+    },
+    file: { updateMany: vi.fn() },
+    user: { findMany: vi.fn() },
+    discussionTag: {
+      findMany: vi.fn(),
+      findUnique: vi.fn(),
+      create: vi.fn(),
+      update: vi.fn(),
+      delete: vi.fn(),
+    },
+    $transaction: vi.fn(),
+  },
+  pusherMocks: {
+    trigger: vi.fn(),
+  },
+  notificationMocks: {
+    sendNotification: vi.fn(),
+  },
+}));
+
+vi.mock("../../../src/lib/prisma.js", () => ({
+  prisma: prismaMocks,
+}));
+
+vi.mock("../../../src/lib/pusher.js", () => ({
+  pusher: pusherMocks,
+  discussionChannel: (classId: string) => `private-class-${classId}-discussions`,
+}));
+
+vi.mock("../../../src/services/notification.js", () => notificationMocks);
+
+import {
+  buildReplyTree,
+  createDiscussion,
+  getDiscussion,
+  getUnreadCounts,
+  markAcceptedAnswer,
+  replyToDiscussion,
+} from "../../../src/services/discussion.js";
+
+const author = {
+  id: "author-1",
+  username: "teacher",
+  profile: {
+    displayName: "Teacher",
+    profilePicture: null,
+    profilePictureThumbnail: null,
+  },
+};
+
+function enabledTeacherClass(overrides = {}) {
+  return {
+    id: "class-1",
+    name: "History",
+    discussionsEnabled: true,
+    studentsCanCreateDiscussions: true,
+    studentsCanReply: true,
+    students: [],
+    teachers: [{ id: "teacher-1" }],
+    school: { memberships: [] },
+    ...overrides,
+  };
+}
+
+function discussion(overrides = {}) {
+  return {
+    id: "discussion-1",
+    classId: "class-1",
+    authorId: "teacher-1",
+    title: "Question",
+    body: "Body",
+    type: "QUESTION",
+    isPinned: false,
+    isLocked: false,
+    allowReplies: true,
+    createdAt: new Date("2026-01-01T00:00:00Z"),
+    updatedAt: new Date("2026-01-01T00:00:00Z"),
+    lastActivityAt: new Date("2026-01-01T00:00:00Z"),
+    author,
+    attachments: [],
+    tags: [],
+    reactions: [],
+    _count: { replies: 0 },
+    ...overrides,
+  };
+}
+
+function reply(overrides = {}) {
+  return {
+    id: "reply-1",
+    discussionId: "discussion-1",
+    authorId: "student-1",
+    parentId: null,
+    body: "Reply",
+    deletedAt: null,
+    isAcceptedAnswer: false,
+    createdAt: new Date("2026-01-01T00:00:00Z"),
+    modifiedAt: null,
+    author,
+    attachments: [],
+    reactions: [],
+    ...overrides,
+  };
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  prismaMocks.$transaction.mockImplementation((callback) => callback(prismaMocks));
+  pusherMocks.trigger.mockResolvedValue(undefined);
+  notificationMocks.sendNotification.mockResolvedValue({});
+  prismaMocks.user.findMany.mockResolvedValue([]);
+});
+
+describe("buildReplyTree", () => {
+  test("assembles nested replies and preserves soft-deleted parents", () => {
+    const tree = buildReplyTree(
+      [
+        reply({ id: "parent", body: "[deleted]", deletedAt: new Date("2026-01-02T00:00:00Z") }) as any,
+        reply({ id: "child", parentId: "parent", body: "Child" }) as any,
+      ],
+      "viewer-1"
+    );
+
+    expect(tree).toHaveLength(1);
+    expect(tree[0].body).toBe("[deleted]");
+    expect(tree[0].attachments).toEqual([]);
+    expect(tree[0].children[0].id).toBe("child");
+  });
+});
+
+describe("getDiscussion", () => {
+  test("marks the thread read and returns nested replies with permissions", async () => {
+    prismaMocks.discussion.findUnique.mockResolvedValue({
+      ...discussion(),
+      class: {
+        id: "class-1",
+        discussionsEnabled: true,
+        studentsCanReply: true,
+        teachers: [{ id: "teacher-1" }],
+        students: [],
+        school: { memberships: [] },
+      },
+    });
+    prismaMocks.discussion.findUniqueOrThrow.mockResolvedValue(discussion());
+    prismaMocks.discussionReply.findMany.mockResolvedValue([
+      reply({ id: "parent" }),
+      reply({ id: "child", parentId: "parent" }),
+    ]);
+    prismaMocks.reaction.findUnique.mockResolvedValue({ type: "HEART" });
+    prismaMocks.discussionRead.upsert.mockResolvedValue({});
+
+    const result = await getDiscussion("teacher-1", "discussion-1");
+
+    expect(prismaMocks.discussionRead.upsert).toHaveBeenCalledWith({
+      where: { userId_discussionId: { userId: "teacher-1", discussionId: "discussion-1" } },
+      update: { lastReadAt: expect.any(Date) },
+      create: { userId: "teacher-1", discussionId: "discussion-1" },
+    });
+    expect(result.replies[0].children[0].id).toBe("child");
+    expect(result.canPin).toBe(true);
+    expect(result.canReply).toBe(true);
+    expect(result.myReaction).toBe("HEART");
+  });
+});
+
+describe("getUnreadCounts", () => {
+  test("computes per-class totals from unread replies", async () => {
+    prismaMocks.class.findMany.mockResolvedValue([{ id: "class-1" }]);
+    prismaMocks.discussion.findMany.mockResolvedValue([
+      { id: "discussion-1" },
+      { id: "discussion-2" },
+    ]);
+    prismaMocks.discussionRead.findMany.mockResolvedValue([
+      { discussionId: "discussion-1", lastReadAt: new Date("2026-01-01T00:00:00Z") },
+    ]);
+    prismaMocks.discussionReply.groupBy
+      .mockResolvedValueOnce([{ discussionId: "discussion-2", _count: 1 }])
+      .mockResolvedValueOnce([{ discussionId: "discussion-1", _count: 2 }]);
+
+    const result = await getUnreadCounts("student-1", ["class-1"]);
+
+    expect(prismaMocks.discussionReply.groupBy).toHaveBeenNthCalledWith(1, {
+      by: ["discussionId"],
+      where: {
+        discussionId: { in: ["discussion-2"] },
+        deletedAt: null,
+        authorId: { not: "student-1" },
+      },
+      _count: true,
+    });
+    expect(prismaMocks.discussionReply.groupBy).toHaveBeenNthCalledWith(2, {
+      by: ["discussionId"],
+      where: {
+        deletedAt: null,
+        authorId: { not: "student-1" },
+        OR: [
+          {
+            discussionId: "discussion-1",
+            createdAt: { gt: new Date("2026-01-01T00:00:00Z") },
+          },
+        ],
+      },
+      _count: true,
+    });
+    expect(result["class-1"].total).toBe(3);
+    expect(result["class-1"].perDiscussion).toEqual([
+      { discussionId: "discussion-2", count: 1 },
+      { discussionId: "discussion-1", count: 2 },
+    ]);
+  });
+});
+
+describe("createDiscussion authorization", () => {
+  test("blocks student-created announcement discussions", async () => {
+    prismaMocks.class.findFirst.mockResolvedValue(
+      enabledTeacherClass({
+        teachers: [],
+        students: [{ id: "student-1" }],
+      })
+    );
+
+    await expect(
+      createDiscussion("student-1", {
+        classId: "class-1",
+        title: "Update",
+        body: "Read this",
+        type: "ANNOUNCEMENT",
+      })
+    ).rejects.toMatchObject({ code: "FORBIDDEN" });
+  });
+
+  test("blocks student-created discussions when disabled", async () => {
+    prismaMocks.class.findFirst.mockResolvedValue(
+      enabledTeacherClass({
+        teachers: [],
+        students: [{ id: "student-1" }],
+        studentsCanCreateDiscussions: false,
+      })
+    );
+
+    await expect(
+      createDiscussion("student-1", {
+        classId: "class-1",
+        title: "Question",
+        body: "Can I ask this?",
+        type: "DISCUSSION",
+      })
+    ).rejects.toMatchObject({ code: "FORBIDDEN" });
+  });
+});
+
+describe("replyToDiscussion authorization", () => {
+  test("blocks student replies on locked discussions", async () => {
+    prismaMocks.discussion.findUnique.mockResolvedValue({
+      ...discussion({ isLocked: true }),
+      class: {
+        id: "class-1",
+        discussionsEnabled: true,
+        studentsCanReply: true,
+        teachers: [],
+        students: [{ id: "student-1" }],
+        school: { memberships: [] },
+      },
+    });
+
+    await expect(
+      replyToDiscussion("student-1", {
+        discussionId: "discussion-1",
+        body: "Reply",
+      })
+    ).rejects.toMatchObject({ code: "FORBIDDEN" });
+  });
+});
+
+describe("markAcceptedAnswer", () => {
+  test("unmarks previous answers before accepting a reply", async () => {
+    prismaMocks.discussionReply.findUnique.mockResolvedValue({
+      ...reply({ id: "reply-1", authorId: "student-1" }),
+      discussion: discussion({ type: "QUESTION", authorId: "teacher-1" }),
+    });
+    prismaMocks.discussion.findUnique.mockResolvedValue({
+      ...discussion(),
+      class: {
+        id: "class-1",
+        discussionsEnabled: true,
+        studentsCanReply: true,
+        teachers: [{ id: "teacher-1" }],
+        students: [],
+        school: { memberships: [] },
+      },
+    });
+    prismaMocks.discussionReply.update.mockResolvedValue(
+      reply({ id: "reply-1", isAcceptedAnswer: true })
+    );
+
+    const result = await markAcceptedAnswer("teacher-1", "reply-1", true);
+
+    expect(prismaMocks.discussionReply.updateMany).toHaveBeenCalledWith({
+      where: { discussionId: "discussion-1", isAcceptedAnswer: true },
+      data: { isAcceptedAnswer: false },
+    });
+    expect(result.reply.isAcceptedAnswer).toBe(true);
+    expect(notificationMocks.sendNotification).toHaveBeenCalled();
+  });
+
+  test("rejects accepted answers on non-question discussions", async () => {
+    prismaMocks.discussionReply.findUnique.mockResolvedValue({
+      ...reply({ id: "reply-1" }),
+      discussion: discussion({ type: "DISCUSSION" }),
+    });
+    prismaMocks.discussion.findUnique.mockResolvedValue({
+      ...discussion(),
+      class: {
+        id: "class-1",
+        discussionsEnabled: true,
+        studentsCanReply: true,
+        teachers: [{ id: "teacher-1" }],
+        students: [],
+        school: { memberships: [] },
+      },
+    });
+
+    await expect(markAcceptedAnswer("teacher-1", "reply-1", true)).rejects.toBeInstanceOf(TRPCError);
+  });
+});