@studious-lms/server 1.4.3 → 1.4.5

package/src/pipelines/pdfToWorksheet.ts

@@ -0,0 +1,177 @@
+/**
+ * PDF URL → worksheet: send a remote PDF URL to structured inference,
+ * then persist a Worksheet and WorksheetQuestion rows.
+ */
+import { z } from "zod";
+import type { ResponseInput } from "openai/resources/responses/responses.js";
+import { prisma } from "../lib/prisma.js";
+import { inference } from "../utils/inference.js";
+import { logger } from "../utils/logger.js";
+
+/** Restrict remote fetches to Google-hosted object URLs. */
+function isProbablyGoogleCloudUrl(url: string): boolean {
+  try {
+    const host = new URL(url).hostname;
+    return (
+      host.endsWith("storage.googleapis.com") ||
+      host.endsWith("googleusercontent.com") ||
+      host.includes("storage.cloud.google.com")
+    );
+  } catch {
+    return false;
+  }
+}
+
+function getFilenameFromUrl(url: string): string {
+  try {
+    const parsed = new URL(url);
+    const lastSegment = parsed.pathname.split("/").filter(Boolean).pop();
+    return lastSegment && lastSegment.includes(".") ? lastSegment : "document.pdf";
+  } catch {
+    return "document.pdf";
+  }
+}
+
+function sanitizeUrlForLogs(url: string): string {
+  try {
+    const parsed = new URL(url);
+    return `${parsed.origin}${parsed.pathname}`;
+  } catch {
+    return 'invalid-url';
+  }
+}
+
+/** LLM output shape (validated by inference). */
+const worksheetDraftSchema = z.object({
+  title: z.string(),
+  questions: z
+    .array(
+      z.object({
+        type: z.enum([
+          "MULTIPLE_CHOICE",
+          "TRUE_FALSE",
+          "SHORT_ANSWER",
+          "LONG_ANSWER",
+          "MATH_EXPRESSION",
+          "ESSAY",
+        ]),
+        question: z.string(),
+        answer: z.string(),
+        options: z
+          .array(
+            z.object({
+              id: z.string(),
+              text: z.string(),
+              isCorrect: z.boolean(),
+            })
+          )
+          .optional()
+          .default([]),
+        markScheme: z
+          .array(
+              z.object({
+                id: z.string(),
+                points: z.number().transform((value) => Math.round(value)),
+                description: z.string(),
+              })
+          )
+          .optional()
+          .default([]),
+        points: z.number().optional().default(0),
+        order: z.number().transform((value) => Math.round(value)),
+      })
+    )
+    .default([]),
+});
+
+type WorksheetDraft = z.infer<typeof worksheetDraftSchema>;
+
+const schemaInstructions = `Return ONLY valid JSON matching this schema:
+{
+  "title": string,
+  "questions": [
+    {
+      "type": "MULTIPLE_CHOICE" | "TRUE_FALSE" | "SHORT_ANSWER" | "LONG_ANSWER" | "MATH_EXPRESSION" | "ESSAY",
+      "question": string,
+      "answer": string,
+      "options": [ { "id": string, "text": string, "isCorrect": boolean } ],
+      "markScheme": [ { "id": string, "points": number, "description": string } ],
+      "points": number,
+      "order": number
+    }
+  ]
+}
+Rules: "questions" is an array ([] if none). Non-MCQ "options" can be []. Use "order" 1,2,3,… in reading order. No markdown or extra keys.
+If no answer is provided for a multiple-choice or true/false question, determine the answer from the options.`;
+
+/**
+ * Sends a PDF URL to the model for remote retrieval, extracts a worksheet via
+ * structured inference, and inserts worksheet + questions in one DB transaction.
+ */
+export async function pdfToWorksheet(gcsUrl: string, classId: string) {
+  const sanitizedUrl = sanitizeUrlForLogs(gcsUrl);
+
+  if (!isProbablyGoogleCloudUrl(gcsUrl)) {
+    logger.warn("pdfToWorksheet: rejected unsupported PDF URL", {
+      sanitizedUrl,
+    });
+    throw new Error("Only Google Cloud Storage URLs are supported");
+  }
+
+  const filename = getFilenameFromUrl(gcsUrl);
+  const prompt = `Read the attached PDF and convert it into a single worksheet JSON object.\n\n${schemaInstructions}`;
+
+  // Force Responses API input types so we can pass a remote PDF via `file_url`.
+  const input: ResponseInput = [
+    {
+      role: "user",
+      content: [
+        { type: "input_text", text: prompt },
+        { type: "input_file", file_url: gcsUrl },
+      ],
+    },
+  ];
+
+  const draft = await inference<WorksheetDraft>(
+    input,
+    worksheetDraftSchema,
+    {
+      reason: 'pdf_to_worksheet_draft',
+      metadata: {
+        classId,
+        filename,
+      },
+    }
+  );
+
+  if (!draft) {
+    logger.warn("pdfToWorksheet: no model output", { filename });
+    return null;
+  }
+
+  return prisma.$transaction(async (tx) => {
+    const worksheet = await tx.worksheet.create({
+      data: { classId, name: draft.title },
+    });
+
+    if (draft.questions.length > 0) {
+      await tx.worksheetQuestion.createMany({
+        data: draft.questions.map((question) => ({
+          worksheetId: worksheet.id,
+          type: question.type,
+          question: question.question,
+          answer: question.answer,
+          points: Math.round(question.points ?? 0),
+          options: question.options ?? [],
+          markScheme: (question.markScheme ?? []).map((item) => ({
+            ...item,
+            points: Math.round(item.points),
+          })),
+          order: Math.round(question.order),
+        })),
+      });
+    }
+
+    return worksheet;
+  });
+}

package/src/routers/_app.ts

@@ -21,6 +21,7 @@ import { marketingRouter } from "./marketing.js";
 import { worksheetRouter } from "./worksheet.js";
 import { commentRouter } from "./comment.js";
 import { studentProgressRouter } from "./studentProgress.js";
+import { searchRouter } from "./search.js";
 
 export const appRouter = createTRPCRouter({
   class: classRouter,
@@ -43,6 +44,7 @@ export const appRouter = createTRPCRouter({
   worksheet: worksheetRouter,
   comment: commentRouter,
   studentProgress: studentProgressRouter,
+  search: searchRouter,
 });
 
 // Export type router type definition

package/src/routers/conversation.ts

@@ -5,6 +5,7 @@ import {
   createConversationRecord,
   getConversation,
   addMemberToConversation,
+  hideConversation,
   removeMemberFromConversation,
 } from "../services/conversation.js";
 
@@ -36,6 +37,12 @@ export const conversationRouter = createTRPCRouter({
       getConversation(ctx.user!.id, input.conversationId)
     ),
 
+  hide: protectedProcedure
+    .input(z.object({ conversationId: z.string() }))
+    .mutation(({ ctx, input }) =>
+      hideConversation(ctx.user!.id, input.conversationId)
+    ),
+
   addMember: protectedProcedure
     .input(
       z.object({

package/src/routers/search.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import { createTRPCRouter, protectedProcedure } from "../trpc.js";
+import { searchGlobalClasses } from "../services/search.js";
+
+export const searchRouter = createTRPCRouter({
+  global: protectedProcedure
+    .input(
+      z.object({
+        query: z.string().max(80).optional(),
+        limit: z.number().int().min(1).max(30).optional(),
+      })
+    )
+    .query(({ ctx, input }) => searchGlobalClasses(ctx.user!.id, input)),
+});

package/src/routers/worksheet.ts

@@ -1,4 +1,10 @@
 import { TRPCError } from "@trpc/server";
+import { prisma } from "../lib/prisma.js";
+import {
+  confirmDirectUpload,
+  createDirectUploadFiles,
+  updateUploadProgress,
+} from "../lib/fileUpload.js";
 import {
   createTRPCRouter,
   protectedClassMemberProcedure,
@@ -13,6 +19,8 @@ import {
   updateWorksheetRecord,
   deleteWorksheetRecord,
   createWorksheetRecord,
+  createWorksheetFromPdf,
+  createWorksheetFromUploadedPdf,
   addQuestionToWorksheet,
   reorderWorksheetQuestions,
   updateWorksheetQuestionRecord,
@@ -25,6 +33,40 @@ import {
   addCommentToResponse,
 } from "../services/worksheet.js";
 
+const directFileSchema = z.object({
+  name: z.string(),
+  type: z.string(),
+  size: z.number(),
+});
+
+const pdfFileSchema = directFileSchema.superRefine((file, ctx) => {
+  const isPdf =
+    file.type === "application/pdf" && file.name.toLowerCase().endsWith(".pdf");
+  if (!isPdf) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "Only PDF files are supported",
+    });
+  }
+});
+
+const getWorksheetUploadUrlsSchema = z.object({
+  classId: z.string(),
+  files: z.array(pdfFileSchema),
+});
+
+const confirmWorksheetUploadSchema = z.object({
+  classId: z.string(),
+  fileId: z.string(),
+  uploadSuccess: z.boolean(),
+  errorMessage: z.string().optional(),
+});
+
+const updateUploadProgressSchema = z.object({
+  fileId: z.string(),
+  progress: z.number().min(0).max(100),
+});
+
 export const worksheetRouter = createTRPCRouter({
   getWorksheet: protectedProcedure
     .input(z.object({ worksheetId: z.string() }))
@@ -66,6 +108,75 @@ export const worksheetRouter = createTRPCRouter({
       createWorksheetRecord(input.classId, input.name)
     ),
 
+  createFromPdf: protectedTeacherProcedure
+    .input(z.object({ classId: z.string(), url: z.string().url() }))
+    .mutation(({ input }) => createWorksheetFromPdf(input.classId, input.url)),
+
+  getWorksheetUploadUrls: protectedTeacherProcedure
+    .input(getWorksheetUploadUrlsSchema)
+    .mutation(async ({ ctx, input }) => {
+      if (!ctx.user) {
+        throw new TRPCError({
+          code: "UNAUTHORIZED",
+          message: "You must be logged in to upload files",
+        });
+      }
+
+      const uploadFiles = await createDirectUploadFiles(
+        input.files,
+        ctx.user.id
+      );
+
+      return {
+        success: true,
+        uploadFiles,
+      };
+    }),
+
+  confirmWorksheetUpload: protectedTeacherProcedure
+    .input(confirmWorksheetUploadSchema)
+    .mutation(async ({ ctx, input }) => {
+      if (!ctx.user) {
+        throw new TRPCError({
+          code: "UNAUTHORIZED",
+          message: "You must be logged in",
+        });
+      }
+
+      const file = await prisma.file.findFirst({
+        where: {
+          id: input.fileId,
+          userId: ctx.user.id,
+        },
+      });
+
+      if (!file) {
+        throw new TRPCError({
+          code: "NOT_FOUND",
+          message: "File not found or you don't have permission",
+        });
+      }
+
+      await confirmDirectUpload(
+        input.fileId,
+        input.uploadSuccess,
+        input.errorMessage
+      );
+
+      return {
+        success: true,
+        message: input.uploadSuccess
+          ? "Upload confirmed successfully"
+          : "Upload failed",
+      };
+    }),
+
+  createFromUploadedPdf: protectedTeacherProcedure
+    .input(z.object({ classId: z.string(), fileId: z.string() }))
+    .mutation(({ ctx, input }) =>
+      createWorksheetFromUploadedPdf(input.classId, input.fileId, ctx.user!.id)
+    ),
+
   addQuestion: protectedProcedure
     .input(
       z.object({
@@ -261,4 +372,36 @@ export const worksheetRouter = createTRPCRouter({
         ctx.user!.id
       )
     ),
+
+  updateUploadProgress: protectedProcedure
+    .input(updateUploadProgressSchema)
+    .mutation(async ({ ctx, input }) => {
+      if (!ctx.user) {
+        throw new TRPCError({
+          code: "UNAUTHORIZED",
+          message: "You must be logged in",
+        });
+      }
+
+      const file = await prisma.file.findFirst({
+        where: {
+          id: input.fileId,
+          userId: ctx.user.id,
+        },
+      });
+
+      if (!file) {
+        throw new TRPCError({
+          code: "NOT_FOUND",
+          message: "File not found or you don't have permission",
+        });
+      }
+
+      await updateUploadProgress(input.fileId, input.progress);
+
+      return {
+        success: true,
+        progress: input.progress,
+      };
+    }),
 });

package/src/services/conversation.ts

@@ -13,15 +13,25 @@ import {
   createConversation,
   findConversationByIdAndMember,
   createConversationMember,
+  hideConversationMember,
   deleteConversationMember,
 } from "../models/conversation.js";
 
 /** List user's conversations with unread and mention counts. */
 export async function listConversations(userId: string) {
   const conversations = await findConversationsByUserId(userId);
+  const visibleConversations = conversations.filter((conversation) => {
+    const userMembership = conversation.members.find((member) => member.userId === userId);
+
+    if (!userMembership?.hiddenAt) {
+      return true;
+    }
+
+    return conversation.updatedAt > userMembership.hiddenAt;
+  });
 
   const conversationsWithUnread = await Promise.all(
-    conversations.map(async (conversation) => {
+    visibleConversations.map(async (conversation) => {
       const userMembership = conversation.members.find(
         (m) => m.userId === userId
       );
@@ -65,6 +75,20 @@ export async function listConversations(userId: string) {
   return conversationsWithUnread;
 }
 
+export async function hideConversation(userId: string, conversationId: string) {
+  const conversation = await findConversationByIdAndMember(conversationId, userId);
+  if (!conversation) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Not a member of this conversation",
+    });
+  }
+
+  await hideConversationMember(userId, conversationId);
+
+  return { success: true };
+}
+
 /** Create a DM or group conversation with the given members. */
 export async function createConversationRecord(
   userId: string,
@@ -87,11 +111,11 @@ export async function createConversationRecord(
   }
 
   if (type === "DM") {
-    const targetUser = await findUserByUsername(memberIds[0]);
+    const [targetUser] = await findUsersByIdsOrUsernames([memberIds[0]]);
     if (!targetUser) {
       throw new TRPCError({
         code: "BAD_REQUEST",
-        message: `User "${memberIds[0]}" not found`,
+        message: `User not found`,
       });
     }
 

package/src/services/message.ts

@@ -259,6 +259,14 @@ export async function sendMessage(
       });
     }
 
+    await tx.conversationMember.updateMany({
+      where: {
+        conversationId,
+        hiddenAt: { not: null },
+      },
+      data: { hiddenAt: null },
+    });
+
     await tx.conversation.update({
       where: { id: conversationId },
       data: { updatedAt: new Date() },