@studious-lms/server 1.2.45 → 1.2.46

package/src/server/pipelines/aiLabChat.ts

@@ -0,0 +1,92 @@
+import { getAIUserId } from "../../utils/aiUser";
+import { prisma } from "../../lib/prisma.js";
+import { Assignment, Class, File, GenerationStatus, User } from "@prisma/client";
+import { inference } from "../../utils/inference.js";
+import z from "zod";
+
+const aiLabChatResponseSchema = z.object({
+    content: z.string(),
+    attachments: z.array(z.object({
+        id: z.string(),
+        name: z.string(),
+        path: z.string(),
+        type: z.string(),
+        size: z.number(),
+    })),
+    assignmentsToCreate: z.array(z.object({
+        title: z.string(),
+        instructions: z.string(),
+        dueDate: z.date(),
+        acceptFiles: z.boolean(),
+        acceptExtendedResponse: z.boolean(),
+        acceptWorksheet: z.boolean(),
+        maxGrade: z.number(),
+        gradingBoundaryId: z.string(),
+        markschemeId: z.string(),
+        worksheetIds: z.array(z.string()),
+        studentIds: z.array(z.string()),
+        sectionId: z.string(),
+        type: z.enum(['HOMEWORK', 'QUIZ', 'TEST', 'PROJECT', 'ESSAY', 'DISCUSSION', 'PRESENTATION', 'LAB', 'OTHER']),
+        attachments: z.array(z.object({
+            id: z.string(),
+        })),
+    })),
+});
+
+
+const getBaseSystemPrompt = (context: Class & { members: User[] , assignments: Assignment[], files: File[] }) => {
+    const systemPrompt = `
+    # Basic Information
+    You are a helpful assistant that helps teachers create course materials for their students.
+    You are provided with the following context:
+
+    Class information: ${context.name} - ${context.subject}
+    Students: ${JSON.stringify(context.members)}
+    Assignments: ${JSON.stringify(context.assignments)}
+    Files: ${JSON.stringify(context.files)}
+
+    You are to generate a response to the user's message.
+    If contextually they would like a file, you are to generate a file.
+    And so on... same for assignments, worksheets, etc.
+
+    You are to generate a response in the following format:
+    {
+        content: string,
+        attachments: File[],
+        assignmentsToCreate: Assignment[],
+    }
+
+    NOTE:
+    - for attachments in Assignment, you may only attach to existing files, based on the file ids provided. if you need to create files and assignments, let the user know that this will take two operations.
+    - the user must accept your changes before they are applied. do know this.
+    - 
+    `;
+}
+
+
+
+/**
+ * Generate labchat responses
+ * Allow for the generation of the following:
+ * - Assignment(s) either individual or bulk as an lesson / course plan.
+ * - Worksheet(s) either individual or bulk as an lesson / course plan.
+ * - Files (PDFs)
+ * @param labChatId 
+ */
+// export const sendAiLabChatResponsePipeline = async (labChatId: string) => {
+//     const message = await prisma?.message.create({
+//         data: {
+//             content: "GENERATING_CONTENT",
+//             senderId: getAIUserId(),
+//             conversationId: labChatId,
+//             status: GenerationStatus.PENDING,   
+//         },
+//     });
+
+//     try {
+
+//         inference(`
+//         `)
+//     }
+    
+// };

package/src/server/pipelines/gradeWorksheet.ts

@@ -0,0 +1,152 @@
+import { GenerationStatus, WorksheetQuestionType } from "@prisma/client";
+import { prisma } from "../../lib/prisma.js";
+import { logger } from "../../utils/logger.js";
+import z from "zod";
+import { inference } from "../../utils/inference.js";
+import { getAIUserId } from "../../utils/aiUser.js";
+import { pusher } from "../../lib/pusher.js";
+
+/**
+ * Grades and regrades worksheet (can fixed failed responses)
+ * @param worksheetResponseId worksheet response id
+ * @returns updated worksheet response
+ */
+
+const DO_NOT_INFERENCE_STATUSES = [GenerationStatus.CANCELLED, GenerationStatus.PENDING, GenerationStatus.COMPLETED];
+
+export const gradeWorksheetPipeline = async (worksheetResponseId: string) => {
+    logger.info('Grading worksheet response', { worksheetResponseId });
+    const worksheetResponse = await prisma.studentWorksheetResponse.findUnique({
+        where: { id: worksheetResponseId },
+        include: {
+            worksheet: true,
+            responses: {
+                where: {
+                    status: {
+                        not: {
+                            in: DO_NOT_INFERENCE_STATUSES,
+                        },
+                    },
+                    question: {
+                        type: {
+                            not: {
+                                in: [WorksheetQuestionType.MULTIPLE_CHOICE, WorksheetQuestionType.TRUE_FALSE],
+                            }
+                        },
+                    },
+                },
+                include: {
+                    question: true,
+                    comments: true,
+                },
+            },
+        },
+    });
+
+    console.log(worksheetResponse);
+
+    if (!worksheetResponse) {
+        logger.error('Worksheet response not found');
+        throw new Error('Worksheet response not found');
+    }
+
+    worksheetResponse.responses.forEach(async (response) => {
+        logger.info('Grading question', { questionId: response.questionId });
+        const question = response.question;
+        const comments = response.comments;
+        const responseText = response.response;
+
+        const studentQuestionProgress = await prisma.studentQuestionProgress.update({
+            where: { id: response.id, status: {
+                not: {
+                    in: DO_NOT_INFERENCE_STATUSES,
+                }
+            } },
+            data: { status: GenerationStatus.PENDING },
+        });
+
+        if (studentQuestionProgress.status !== GenerationStatus.PENDING) {
+            return;
+        }
+
+        try {
+            const apiResponse = await inference(
+                `Grade the following worksheet response:
+                
+                Question: ${question.question}
+                Response: ${responseText}
+
+                Comments: ${comments.map((comment) => comment.content).join('\n')}
+                Mark Scheme: ${JSON.stringify(question.markScheme)}
+                
+                Justify your reasoning by including comment(s) and mark the question please.         
+                Return ONLY JSON in the following format (fill in the values as per the question):
+               {
+                "isCorrect": <boolean>,
+                "points": <number>,
+                "markschemeState": [
+                    { "id": <string>, "correct": <boolean> }
+                ],
+                "comments": [<string>, ...]
+                }
+                `,
+                z.object({
+                    isCorrect: z.boolean(),
+                    points: z.number(),
+                    markschemeState: z.array(z.object({
+                        id: z.string(),
+                        correct: z.boolean(),
+                      })), // @note: this has to be converted to [id: string]: correct boolean
+                    comments: z.array(z.string()),
+                }),
+            ).catch((error) => {
+                logger.error('Failed to grade worksheet response', { error });
+                throw error;
+            });
+
+            console.log(apiResponse);
+
+            const updatedStudentQuestionProgress = await prisma.studentQuestionProgress.update({
+                where: { id: studentQuestionProgress.id, status: {
+                    not: {
+                        in: ['CANCELLED'],
+                    },
+                } },
+                data: {
+                    status: GenerationStatus.COMPLETED,
+                    isCorrect: (apiResponse as { isCorrect: boolean }).isCorrect,
+                    points: (apiResponse as { points: number }).points,
+                    markschemeState: (apiResponse as {
+                        markschemeState: { id: string; correct: boolean }[];
+                    }).markschemeState.reduce((acc, curr) => {
+                        acc["item-" + curr.id] = curr.correct;
+                        return acc;
+                    }, {} as Record<string, boolean>),
+                    comments: {
+                        create: (apiResponse as {
+                            comments: string[];
+                        }).comments.map((commentContent) => ({
+                            content: commentContent,
+                            authorId: getAIUserId(),
+                        })),
+                    },
+                },
+            });
+            pusher.trigger(`class-${worksheetResponse.worksheet.classId}`, `ai-worksheet-updated-${worksheetResponse.id}`, {
+                success: true,
+            });
+
+            return updatedStudentQuestionProgress;
+        } catch (error) {
+            logger.error('Failed to grade worksheet response', { error, worksheetResponseId });
+            pusher.trigger(`class-${worksheetResponse.worksheet.classId}`, `ai-worksheet-updated-${worksheetResponse.id}`, {
+                success: false,
+            });
+            await prisma.studentQuestionProgress.update({
+                where: { id: studentQuestionProgress.id },
+                data: { status: GenerationStatus.FAILED },
+            });
+            throw error;
+        }
+    });
+};

package/src/trpc.ts

@@ -7,6 +7,7 @@ import { createAuthMiddleware } from './middleware/auth.js';
 import { Request, Response } from 'express';
 import { z } from 'zod';
 import { handlePrismaError, PrismaErrorInfo } from './utils/prismaErrorHandler.js';
+import { generalLimiter } from './middleware/security.js';
 
 interface CreateContextOptions {
   req: Request;
@@ -89,6 +90,7 @@ const { isAuthed, isMemberInClass, isTeacherInClass } = createAuthMiddleware(t);
 export const createTRPCRouter = t.router;
 export const publicProcedure = t.procedure.use(loggingMiddleware);
 
+
 // Protected procedures
 export const protectedProcedure = publicProcedure.use(isAuthed);
 

package/src/utils/email.ts

@@ -1,11 +1,38 @@
 import nodemailer from 'nodemailer';
+import { env } from '../lib/config/env.js';
+import { logger } from './logger.js';
+
+
+type sendMailProps = {
+  from: string;
+  to: string;
+  subject: string;
+  text: string;
+};
+
 
 export const transport = nodemailer.createTransport({
-    host: process.env.EMAIL_HOST,
+    host: env.EMAIL_HOST,
     port: 587,
     secure: false,
     auth: {
-      user: process.env.EMAIL_USER,
-      pass: process.env.EMAIL_PASS,
+      user: env.EMAIL_USER,
+      pass: env.EMAIL_PASS,
     },
   });
+
+
+export const sendMail = async ({ from, to, subject, text }: sendMailProps) => {
+  // Wrapper function for sending emails
+  if (env.EMAIL_DRY_RUN == "true") {
+    logger.info(`Email dry run enabled. Would have sent email to ${to} from ${from} with subject ${subject} and text ${text}`);
+    return;
+  }
+  
+  await transport.sendMail({
+    from,
+    to,
+    subject,
+    text,
+  });
+};

package/src/utils/inference.ts

@@ -3,13 +3,19 @@ import { logger } from './logger.js';
 import { prisma } from '../lib/prisma.js';
 import { pusher } from '../lib/pusher.js';
 import { ensureAIUserExists, getAIUserId } from './aiUser.js';
+import { env } from '../lib/config/env.js';
+import { ZodSchema } from 'zod';
+import { zodTextFormat } from "openai/helpers/zod";
+
 
 
 export const inferenceClient = new OpenAI({
-  apiKey: process.env.INFERENCE_API_KEY,
-  baseURL: process.env.INFERENCE_API_BASE_URL,
+  apiKey: env.INFERENCE_API_KEY,
+  baseURL: env.INFERENCE_API_BASE_URL,
 });
 
+export const openAIClient = new OpenAI();
+
 // Types for lab chat context
 export interface LabChatContext {
   subject: string;
@@ -122,6 +128,45 @@ export async function sendAIMessage(
   };
 }
 
+export async function inference(
+  content: string,
+  format?: ZodSchema
+): Promise<string | object> {
+  try {
+
+    const completion = await openAIClient.responses.parse({
+      model: 'gpt-5-nano',
+      input: [
+        {
+          role: 'user',
+          content: content,
+        },
+      ],
+      ...(format ? { text: {
+          format: zodTextFormat(format, "newton_response_format"),
+        },
+      } : {}),
+    });
+
+
+    if (!completion) {
+      throw new Error('No response generated from inference API');
+    }
+
+    // if (format) {
+    //   if (typeof completion.output === 'string') {
+    //     return JSON.parse(completion.output);
+    //   }
+    //   return JSON.parse(completion.output);
+    // }
+
+    return completion.output_parsed;
+  } catch (error) {
+    logger.error('Failed to generate inference response', { error });
+    throw error;
+  }
+}
+
 /**
  * Simple inference function for general use
  */
@@ -133,10 +178,10 @@ export async function generateInferenceResponse(
     maxTokens?: number;
   } = {}
 ): Promise<InferenceResponse> {
-  const { model = 'command-r-plus', maxTokens = 500 } = options;
+  const { model = 'gpt-5-nano', maxTokens = 500 } = options;
 
   try {
-    const completion = await inferenceClient.chat.completions.create({
+    const completion = await openAIClient.chat.completions.create({
       model,
       messages: [
         {
@@ -176,7 +221,7 @@ export async function generateInferenceResponse(
  * Validate inference configuration
  */
 export function validateInferenceConfig(): boolean {
-  if (!process.env.INFERENCE_API_KEY) {
+  if (!env.INFERENCE_API_KEY) {
     logger.error('Inference API key not configured for Cohere');
     return false;
   }

package/src/utils/logger.ts

@@ -1,3 +1,4 @@
+
 export enum LogLevel {
   INFO = 'info',
   WARN = 'warn',
@@ -59,7 +60,7 @@ class Logger {
     // this.isDevelopment = process.env.NODE_ENV === 'development';
     this.isDevelopment = true;
 
-    this.mode = (process.env.LOG_MODE as LogMode) || 'normal';
+    this.mode = (process.env.NODE_ENV === 'test' ? 'silent' : ((process.env.LOG_MODE as LogMode) || 'normal'));
     
 
     this.levelColors = {

package/tests/announcement.test.ts

@@ -0,0 +1,164 @@
+import { test, expect, describe, beforeEach } from 'vitest';
+import { user1Caller, user2Caller } from './setup';
+import { createTRPCContext } from '../src/trpc';
+import { appRouter } from '../src/routers/_app';
+
+describe('Announcement Router', () => {
+  let testClass: any;
+  let testAnnouncement: any;
+
+  beforeEach(async () => {
+    // Create a test class
+    testClass = await user1Caller.class.create({
+      name: 'Test Class for Announcements',
+      subject: 'Mathematics',
+      section: '10th Grade',
+    });
+
+    // Create a test announcement
+    testAnnouncement = await user1Caller.announcement.create({
+      classId: testClass.id,
+      remarks: 'This is a test announcement',
+    });
+  });
+
+  describe('create', () => {
+    test('should create announcement successfully', async () => {
+      expect(testAnnouncement).toBeDefined();
+      expect(testAnnouncement.announcement).toBeDefined();
+      expect(testAnnouncement.announcement.remarks).toBe('This is a test announcement');
+      expect(testAnnouncement.announcement.teacher.id).toBeDefined();
+    });
+
+    test('should create announcement with attachments', async () => {
+      const announcement = await user1Caller.announcement.create({
+        classId: testClass.id,
+        remarks: 'Announcement with attachments',
+        files: [
+          {
+            name: 'test.pdf',
+            type: 'application/pdf',
+            size: 1024,
+          },
+        ],
+      });
+
+      expect(announcement.announcement).toBeDefined();
+      expect(announcement.announcement.attachments).toBeDefined();
+    });
+
+    test('should fail to create announcement for class user is not teacher of', async () => {
+      await expect(user2Caller.announcement.create({
+        classId: testClass.id,
+        remarks: 'Unauthorized announcement',
+      })).rejects.toThrow();
+    });
+
+    test('should fail without authentication', async () => {
+      const invalidCaller = await createTRPCContext({
+        req: { headers: {} } as any,
+        res: {} as any,
+      });
+      const router = appRouter.createCaller(invalidCaller);
+
+      await expect(router.announcement.create({
+        classId: testClass.id,
+        remarks: 'Test',
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('getAll', () => {
+    test('should get all announcements for class', async () => {
+      const result = await user1Caller.announcement.getAll({
+        classId: testClass.id,
+      });
+
+      expect(result.announcements).toBeDefined();
+      expect(Array.isArray(result.announcements)).toBe(true);
+      expect(result.announcements.length).toBeGreaterThanOrEqual(1);
+      expect(result.announcements.some((a: any) => a.id === testAnnouncement.announcement.id)).toBe(true);
+    });
+
+    test('should fail to get announcements for class user is not member of', async () => {
+      await expect(user2Caller.announcement.getAll({
+        classId: testClass.id,
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('get', () => {
+    test('should get single announcement successfully', async () => {
+      const announcement = await user1Caller.announcement.get({
+        id: testAnnouncement.announcement.id,
+        classId: testClass.id,
+      });
+
+      expect(announcement.announcement).toBeDefined();
+      expect(announcement.announcement.id).toBe(testAnnouncement.announcement.id);
+      expect(announcement.announcement.remarks).toBe('This is a test announcement');
+    });
+
+    test('should fail to get announcement for class user is not member of', async () => {
+      await expect(user2Caller.announcement.get({
+        id: testAnnouncement.announcement.id,
+        classId: testClass.id,
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('update', () => {
+    test('should update announcement successfully', async () => {
+      const updated = await user1Caller.announcement.update({
+        id: testAnnouncement.announcement.id,
+        classId: testClass.id,
+        data: {
+          remarks: 'Updated announcement remarks',
+        },
+      });
+
+      expect(updated.announcement.remarks).toBe('Updated announcement remarks');
+    });
+
+    test('should fail to update announcement user is not teacher of', async () => {
+      await expect(user2Caller.announcement.update({
+        id: testAnnouncement.announcement.id,
+        classId: testClass.id,
+        data: {
+          remarks: 'Unauthorized update',
+        },
+      })).rejects.toThrow();
+    });
+  });
+
+  describe('delete', () => {
+    test('should delete announcement successfully', async () => {
+      // Create a new announcement to delete
+      const newAnnouncement = await user1Caller.announcement.create({
+        classId: testClass.id,
+        remarks: 'To be deleted',
+      });
+
+      const result = await user1Caller.announcement.delete({
+        id: newAnnouncement.announcement.id,
+        classId: testClass.id,
+      });
+
+      expect(result.success).toBe(true);
+
+      // Verify announcement is deleted
+      await expect(user1Caller.announcement.get({
+        id: newAnnouncement.announcement.id,
+        classId: testClass.id,
+      })).rejects.toThrow();
+    });
+
+    test('should fail to delete announcement user is not teacher of', async () => {
+      await expect(user2Caller.announcement.delete({
+        id: testAnnouncement.announcement.id,
+        classId: testClass.id,
+      })).rejects.toThrow();
+    });
+  });
+});
+