@studious-lms/server 1.5.0 → 1.7.0

package/src/workers/processors/studentProgressChat.ts

@@ -0,0 +1,28 @@
+import { chatAboutStudentProgress } from '../../services/studentProgress.js';
+import { createRunJobWorker } from './createRunJobWorker.js';
+
+export const studentProgressChatWorker = createRunJobWorker({
+  type: 'STUDENT_PROGRESS_CHAT',
+  workerOptions: {
+    concurrency: 4,
+    limiter: { max: 20, duration: 60_000 },
+  },
+  run: async ({ classId, studentId, message }, ctx) => {
+    // `chatAboutStudentProgress` runs an authorization check using the viewer
+    // id, so callers MUST pass `userId` via `enqueueRunJob` options for the
+    // service to receive it here.
+    if (!ctx.userId) {
+      throw new Error(
+        'STUDENT_PROGRESS_CHAT requires `userId` on the RunJob (set via enqueueRunJob options)',
+      );
+    }
+
+    const response = await chatAboutStudentProgress(ctx.userId, {
+      classId,
+      studentId,
+      message,
+    });
+
+    return response;
+  },
+});

package/src/workers/queues.ts

@@ -26,15 +26,30 @@ const DEFAULT_JOB_OPTIONS: JobsOptions = {
  * The queue name string must match what the corresponding processor passes
  * to `new Worker(<name>, ...)`.
  */
-type JobInputs = {
-  PDF_TO_WORKSHEET: { gcsUrl: string; classId: string };
+export type JobInputs = {
+  /**
+   * `worksheetId` is the placeholder Worksheet row created synchronously by
+   * the producer (so the client has an id to navigate to). The pipeline fills
+   * that row in asynchronously and broadcasts progress on the per-worksheet
+   * job channel.
+   */
+  PDF_TO_WORKSHEET: { gcsUrl: string; classId: string; worksheetId: string };
   GRADE_WORKSHEET: { worksheetResponseId: string };
-  AI_LAB_CHAT: { conversationId: string; messageId: string };
-  AI_NEWTON_CHAT: { conversationId: string; messageId: string };
+  /**
+   * `aiMessageId` is the placeholder AI Message row created synchronously by
+   * the producer before enqueue (so the client renders a PENDING bubble in
+   * the timeline). The pipeline fills in the content and flips the row to
+   * COMPLETED / FAILED. Used for both intros and replies — single shape.
+   */
+  AI_LAB_CHAT: { conversationId: string; aiMessageId: string };
+  /**
+   * `aiMessageId` placeholder pattern, same as AI_LAB_CHAT — see above.
+   */
+  AI_NEWTON_CHAT: { conversationId: string; aiMessageId: string };
   STUDENT_PROGRESS_CHAT: { classId: string; studentId: string; message: string };
 };
 
-const QUEUE_NAMES: Record<RunJobType, string> = {
+export const QUEUE_NAMES: Record<RunJobType, string> = {
   PDF_TO_WORKSHEET: 'pdfToWorksheet',
   GRADE_WORKSHEET: 'gradeWorksheet',
   AI_LAB_CHAT: 'aiLabChat',

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

@@ -117,6 +117,66 @@ describe('Attendance Router', () => {
       expect(updatedRecord?.late.some((l: any) => l.id === student2.id)).toBe(true);
     });
 
+    test('should notify students newly marked late or absent', async () => {
+      await prisma.notification.deleteMany({
+        where: { receiverId: student2.id },
+      });
+
+      await user1Caller.attendance.update({
+        classId: testClass.id,
+        eventId: testEvent.event.id,
+        attendance: {
+          present: [{ id: student1.id, username: student1.username }],
+          late: [{ id: student2.id, username: student2.username }],
+          absent: [],
+        },
+      });
+
+      let notifications = await user2Caller.notification.list();
+      expect(
+        notifications.some(
+          (notification: any) =>
+            notification.title === `Marked late in ${testClass.name}` &&
+            notification.content.includes(testEvent.event.name) &&
+            notification.content.includes(`/class/${testClass.id}/attendance/${testEvent.event.id}`)
+        )
+      ).toBe(true);
+
+      await user1Caller.attendance.update({
+        classId: testClass.id,
+        eventId: testEvent.event.id,
+        attendance: {
+          present: [{ id: student1.id, username: student1.username }],
+          late: [{ id: student2.id, username: student2.username }],
+          absent: [],
+        },
+      });
+
+      notifications = await user2Caller.notification.list();
+      expect(
+        notifications.filter(
+          (notification: any) => notification.title === `Marked late in ${testClass.name}`
+        )
+      ).toHaveLength(1);
+
+      await user1Caller.attendance.update({
+        classId: testClass.id,
+        eventId: testEvent.event.id,
+        attendance: {
+          present: [{ id: student1.id, username: student1.username }],
+          late: [],
+          absent: [{ id: student2.id, username: student2.username }],
+        },
+      });
+
+      notifications = await user2Caller.notification.list();
+      expect(
+        notifications.some(
+          (notification: any) => notification.title === `Marked absent in ${testClass.name}`
+        )
+      ).toBe(true);
+    });
+
     test('should update attendance without event', async () => {
       const result = await user1Caller.attendance.update({
         classId: testClass.id,
@@ -157,4 +217,3 @@ describe('Attendance Router', () => {
       })));
   });
 });
-

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

@@ -1,4 +1,4 @@
-import { test, expect, describe, beforeAll } from 'vitest';
+import { test, expect, describe, beforeAll, afterAll } from 'vitest';
 import { prisma } from '../../../src/lib/prisma';
 import { user1Caller, user2Caller, user3Caller } from '../setup';
 import { expectUnauth } from '../helpers';
@@ -7,16 +7,19 @@ describe('Conversation Router', () => {
   let dmConversation: any;
   let groupConversation: any;
   let user1Id: string;
+  let user2Id: string;
   let user3Id: string;
   let hideConversationCounter = 0;
 
   beforeAll(async () => {
-    const [user1Profile, user3Profile] = await Promise.all([
+    const [user1Profile, user2Profile, user3Profile] = await Promise.all([
       user1Caller.user.getProfile(),
+      user2Caller.user.getProfile(),
       user3Caller.user.getProfile(),
     ]);
 
     user1Id = user1Profile.id;
+    user2Id = user2Profile.id;
     user3Id = user3Profile.id;
   });
 
@@ -89,6 +92,122 @@ describe('Conversation Router', () => {
     });
   });
 
+  describe('searchMembers', () => {
+    let schoolId: string;
+    let previousUser2DisplayName: string | null = null;
+    let user2ProfileExisted = false;
+
+    beforeAll(async () => {
+      const existingProfile = await prisma.userProfile.findUnique({
+        where: { userId: user2Id },
+        select: { displayName: true },
+      });
+      user2ProfileExisted = Boolean(existingProfile);
+      previousUser2DisplayName = existingProfile?.displayName ?? null;
+
+      const school = await prisma.school.create({
+        data: {
+          name: 'Conversation Search School',
+          memberships: {
+            create: [
+              { userId: user1Id, role: 'TEACHER', status: 'ACTIVE' },
+              { userId: user2Id, role: 'STUDENT', status: 'ACTIVE' },
+            ],
+          },
+        },
+      });
+      schoolId = school.id;
+
+      await prisma.userProfile.upsert({
+        where: { userId: user2Id },
+        update: { displayName: 'Searchable Student' },
+        create: { userId: user2Id, displayName: 'Searchable Student' },
+      });
+    });
+
+    test('should search active institution members by username', async () => {
+      const results = await user1Caller.conversation.searchMembers({
+        query: 'testuser2',
+      });
+
+      expect(results.map((user) => user.id)).toContain(user2Id);
+      expect(results.map((user) => user.id)).not.toContain(user1Id);
+      expect(results.map((user) => user.id)).not.toContain(user3Id);
+    });
+
+    test('should not search active institution members for one-character queries', async () => {
+      const results = await user1Caller.conversation.searchMembers({
+        query: 't',
+      });
+
+      expect(results).toEqual([]);
+    });
+
+    test('should search active institution members by display name', async () => {
+      const results = await user1Caller.conversation.searchMembers({
+        query: 'searchable',
+      });
+
+      expect(results).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            id: user2Id,
+            username: 'testuser2',
+            profile: expect.objectContaining({
+              displayName: 'Searchable Student',
+            }),
+          }),
+        ]),
+      );
+    });
+
+    test('should not expose users outside the requester institution', async () => {
+      const results = await user1Caller.conversation.searchMembers({
+        query: 'testuser3',
+      });
+
+      expect(results).toEqual([]);
+    });
+
+    test('should not expose inactive members from the requester institution', async () => {
+      await prisma.schoolMembership.create({
+        data: {
+          schoolId,
+          userId: user3Id,
+          role: 'STUDENT',
+          status: 'INACTIVE',
+        },
+      });
+
+      const results = await user1Caller.conversation.searchMembers({
+        query: 'testuser3',
+      });
+
+      expect(results).toEqual([]);
+    });
+
+    test('should return no institution search results for users without an active school', async () => {
+      const results = await user3Caller.conversation.searchMembers({
+        query: 'testuser1',
+      });
+
+      expect(results).toEqual([]);
+    });
+
+    afterAll(async () => {
+      if (user2ProfileExisted) {
+        await prisma.userProfile.update({
+          where: { userId: user2Id },
+          data: { displayName: previousUser2DisplayName },
+        });
+      } else {
+        await prisma.userProfile.deleteMany({ where: { userId: user2Id } });
+      }
+
+      await prisma.school.delete({ where: { id: schoolId } });
+    });
+  });
+
   describe('get', () => {
     test('should get conversation by ID', async () => {
       const conversation = await user1Caller.conversation.get({