@studious-lms/server 1.4.4 → 1.4.6

package/tests/routers/assignment.test.ts

@@ -1,5 +1,5 @@
 import { test, expect, describe, beforeEach } from 'vitest';
-import { user1Caller, user2Caller } from '../setup';
+import { user1Caller, user2Caller, user3Caller } from '../setup';
 import { expectForbidden, expectUnauth } from '../helpers';
 
 describe('Assignment Router', () => {
@@ -145,6 +145,73 @@ describe('Assignment Router', () => {
     });
   });
 
+  describe('comments', () => {
+    test('allows class members to add and read assignment-level comments', async () => {
+      const { comment } = await user2Caller.assignment.addComment({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+        content: 'I have a question about this assignment.',
+      });
+
+      expect(comment.assignmentId).toBe(testAssignment.id);
+      expect(comment.submissionId).toBeNull();
+
+      const { comments } = await user1Caller.assignment.getComments({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+      });
+
+      expect(comments.some((item) => item.id === comment.id)).toBe(true);
+    });
+
+    test('allows only the submission student and teachers to read private submission comments', async () => {
+      const submission = await user2Caller.assignment.getSubmission({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+      });
+
+      const { comment } = await user1Caller.assignment.addSubmissionComment({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+        submissionId: submission.id,
+        content: 'Private note for this submission.',
+      });
+
+      expect(comment.submissionId).toBe(submission.id);
+
+      const studentView = await user2Caller.assignment.getSubmissionComments({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+        submissionId: submission.id,
+      });
+      expect(studentView.comments.some((item) => item.id === comment.id)).toBe(true);
+
+      const teacherView = await user1Caller.assignment.getSubmissionComments({
+        classId: testClass.id,
+        assignmentId: testAssignment.id,
+        submissionId: submission.id,
+      });
+      expect(teacherView.comments.some((item) => item.id === comment.id)).toBe(true);
+
+      const classmateProfile = await user3Caller.user.getProfile();
+      await user1Caller.class.addStudent({
+        classId: testClass.id,
+        studentId: classmateProfile.id,
+      });
+
+      await expect(
+        user3Caller.assignment.getSubmissionComments({
+          classId: testClass.id,
+          assignmentId: testAssignment.id,
+          submissionId: submission.id,
+        }),
+      ).rejects.toMatchObject({
+        code: 'NOT_FOUND',
+        message: 'Submission not found',
+      });
+    });
+  });
+
   // describe('getAll', () => {
   //   test('should get all assignments for class', async () => {
   //     const result = await user1Caller.assignment.get({
@@ -834,4 +901,3 @@ describe('Assignment Router', () => {
     });
   });
 });
-

package/tests/routers/comment.test.ts

@@ -1,5 +1,5 @@
 import { test, expect, describe, beforeAll } from 'vitest';
-import { user1Caller, user2Caller } from '../setup';
+import { user1Caller, user2Caller, user3Caller } from '../setup';
 
 describe('Comment Router', () => {
   let testClass: any;
@@ -42,6 +42,47 @@ describe('Comment Router', () => {
         user1Caller.comment.get({ id: 'nonexistent-id' }),
       ).rejects.toThrow();
     });
+
+    test('should fail for users outside the comment class', async () => {
+      await expect(
+        user2Caller.comment.get({ id: commentId }),
+      ).rejects.toMatchObject({ code: 'FORBIDDEN' });
+    });
+
+    test('should fail for the author after class removal', async () => {
+      const removalClass = await user1Caller.class.create({
+        name: 'Removed Comment Author Class',
+        subject: 'History',
+        section: '11th Grade',
+      });
+      const user3Profile = await user3Caller.user.getProfile();
+      await user1Caller.class.addStudent({
+        classId: removalClass.id,
+        studentId: user3Profile.id,
+      });
+
+      const { announcement: removalAnnouncement } = await user1Caller.announcement.create({
+        classId: removalClass.id,
+        remarks: 'Announcement with removable author comment',
+      });
+      const { comment } = await user3Caller.announcement.addComment({
+        announcementId: removalAnnouncement.id,
+        classId: removalClass.id,
+        content: 'I should lose access when removed.',
+      });
+
+      await user1Caller.class.removeMember({
+        classId: removalClass.id,
+        userId: user3Profile.id,
+      });
+
+      await expect(
+        user3Caller.comment.get({ id: comment.id }),
+      ).rejects.toThrow();
+      await expect(
+        user3Caller.comment.update({ id: comment.id, content: 'Updated after removal' }),
+      ).rejects.toThrow();
+    });
   });
 
   describe('replyToComment', () => {

package/tests/routers/conversation.test.ts

@@ -1,17 +1,35 @@
 import { test, expect, describe, beforeAll } from 'vitest';
+import { prisma } from '../../src/lib/prisma';
 import { user1Caller, user2Caller, user3Caller } from '../setup';
 import { expectUnauth } from '../helpers';
 
 describe('Conversation Router', () => {
   let dmConversation: any;
   let groupConversation: any;
+  let user1Id: string;
   let user3Id: string;
+  let hideConversationCounter = 0;
 
   beforeAll(async () => {
-    const profile = await user3Caller.user.getProfile();
-    user3Id = profile.id;
+    const [user1Profile, user3Profile] = await Promise.all([
+      user1Caller.user.getProfile(),
+      user3Caller.user.getProfile(),
+    ]);
+
+    user1Id = user1Profile.id;
+    user3Id = user3Profile.id;
   });
 
+  async function createHideableConversation() {
+    hideConversationCounter += 1;
+
+    return user1Caller.conversation.create({
+      type: 'GROUP',
+      name: `Hide Test Group Chat ${hideConversationCounter}`,
+      memberIds: ['testuser2'],
+    });
+  }
+
   describe('create', () => {
     test('should create a DM conversation', async () => {
       dmConversation = await user1Caller.conversation.create({
@@ -36,6 +54,13 @@ describe('Conversation Router', () => {
       expect(groupConversation.name).toBe('Test Group Chat');
     });
 
+    test('should create a hideable GROUP conversation', async () => {
+      const conversation = await createHideableConversation();
+
+      expect(conversation).toBeDefined();
+      expect(conversation.type).toBe('GROUP');
+    });
+
     test('should fail to create duplicate DM', async () => {
       await expect(
         user1Caller.conversation.create({
@@ -125,6 +150,93 @@ describe('Conversation Router', () => {
     });
   });
 
+  describe('hide', () => {
+    test('should hide a conversation only for the requesting member', async () => {
+      const conversation = await createHideableConversation();
+
+      const result = await user1Caller.conversation.hide({
+        conversationId: conversation.id,
+      });
+
+      expect(result).toEqual({ success: true });
+
+      const membership = await prisma.conversationMember.findUniqueOrThrow({
+        where: {
+          userId_conversationId: {
+            userId: user1Id,
+            conversationId: conversation.id,
+          },
+        },
+        select: { hiddenAt: true },
+      });
+
+      expect(membership.hiddenAt).not.toBeNull();
+
+      const user1Conversations = await user1Caller.conversation.list();
+      const user2Conversations = await user2Caller.conversation.list();
+
+      expect(user1Conversations.map((item) => item.id)).not.toContain(
+        conversation.id,
+      );
+      expect(user2Conversations.map((item) => item.id)).toContain(
+        conversation.id,
+      );
+    });
+
+    test('should keep hidden conversations accessible by id', async () => {
+      const conversation = await createHideableConversation();
+
+      await user1Caller.conversation.hide({
+        conversationId: conversation.id,
+      });
+
+      const hiddenConversation = await user1Caller.conversation.get({
+        conversationId: conversation.id,
+      });
+
+      expect(hiddenConversation.id).toBe(conversation.id);
+    });
+
+    test('should unhide a hidden conversation after new activity', async () => {
+      const conversation = await createHideableConversation();
+
+      await user1Caller.conversation.hide({
+        conversationId: conversation.id,
+      });
+
+      await user2Caller.message.send({
+        conversationId: conversation.id,
+        content: 'Bringing this conversation back',
+      });
+
+      const membership = await prisma.conversationMember.findUniqueOrThrow({
+        where: {
+          userId_conversationId: {
+            userId: user1Id,
+            conversationId: conversation.id,
+          },
+        },
+        select: { hiddenAt: true },
+      });
+
+      expect(membership.hiddenAt).toBeNull();
+
+      const conversations = await user1Caller.conversation.list();
+
+      expect(conversations.map((item) => item.id)).toContain(conversation.id);
+    });
+
+    test('should fail for non-members', async () => {
+      const conversation = await createHideableConversation();
+
+      await expect(
+        user3Caller.conversation.hide({
+          conversationId: conversation.id,
+        }),
+      ).rejects.toThrow('Not a member of this conversation');
+    });
+  });
+
   describe('removeMember', () => {
     test('should remove member from conversation', async () => {
       await user1Caller.conversation.removeMember({

package/tests/routers/search.test.ts

@@ -0,0 +1,109 @@
+import { describe, expect, test, beforeAll } from "vitest";
+import { expectUnauth } from "../helpers";
+import { user1Caller, user2Caller, user3Caller } from "../setup";
+
+describe("Search Router", () => {
+  let testClass: any;
+  let assignment: any;
+  let event: any;
+  let worksheet: any;
+
+  beforeAll(async () => {
+    testClass = await user1Caller.class.create({
+      name: "Global Search Biology",
+      subject: "Biology",
+      section: "STU-65",
+    });
+
+    await user1Caller.class.addStudent({
+      classId: testClass.id,
+      studentId: (await user2Caller.user.getProfile()).id,
+    });
+
+    await user1Caller.class.updateSyllabus({
+      classId: testClass.id,
+      contents: "Photosynthesis lab policies and chlorophyll grading overview.",
+    });
+
+    assignment = await user1Caller.assignment.create({
+      classId: testClass.id,
+      title: "Chlorophyll Response",
+      instructions: "Explain the photosynthesis command palette experiment.",
+      dueDate: new Date(Date.now() + 86400000).toISOString(),
+      type: "HOMEWORK",
+    });
+
+    event = await user1Caller.event.create({
+      classId: testClass.id,
+      name: "Photosynthesis Attendance Lab",
+      location: "Room 65",
+      startTime: new Date(Date.now() + 3600000).toISOString(),
+      endTime: new Date(Date.now() + 7200000).toISOString(),
+    });
+
+    worksheet = await user1Caller.worksheet.create({
+      classId: testClass.id,
+      name: "Chloroplast Worksheet",
+    });
+  });
+
+  test("returns matching class resources for a teacher", async () => {
+    const results = await user1Caller.search.global({
+      query: "photosynthesis",
+      limit: 20,
+    });
+
+    expect(results.query).toBe("photosynthesis");
+    expect(results.results).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          type: "assignment",
+          id: assignment.id,
+          href: `/class/${testClass.id}/assignment/${assignment.id}`,
+        }),
+        expect.objectContaining({
+          type: "event",
+          id: event.event.id,
+          href: `/class/${testClass.id}/attendance/${event.event.id}`,
+        }),
+        expect.objectContaining({
+          type: "syllabus",
+          href: `/class/${testClass.id}/syllabus`,
+        }),
+      ])
+    );
+  });
+
+  test("returns visible class resources for an enrolled student", async () => {
+    const results = await user2Caller.search.global({
+      query: "chloroplast",
+      limit: 20,
+    });
+
+    expect(results.results).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          type: "worksheet",
+          id: worksheet.id,
+          href: `/class/${testClass.id}/worksheets`,
+        }),
+      ])
+    );
+  });
+
+  test("does not expose resources to non-members", async () => {
+    const results = await user3Caller.search.global({
+      query: "photosynthesis",
+      limit: 20,
+    });
+
+    expect(results.results).not.toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ classId: testClass.id }),
+      ])
+    );
+  });
+
+  test("fails without authentication", () =>
+    expectUnauth((c) => c.search.global({ query: "biology" })));
+});

package/vercel.json

@@ -0,0 +1,8 @@
+{
+    "fluid": true,
+    "functions": {
+      "src/index.ts": {
+        "maxDuration": 500
+      }
+    }
+  }