@studious-lms/server 1.13.0 → 1.15.0

package/src/services/userPrivacy.ts

@@ -0,0 +1,196 @@
+/**
+ * User privacy service — data export and account erasure (anonymization).
+ */
+import { TRPCError } from "@trpc/server";
+import { randomBytes } from "node:crypto";
+import { hash } from "bcryptjs";
+import { prisma } from "../lib/prisma.js";
+import { deleteSessionsByUserId } from "../models/auth.js";
+
+async function assertAccountCanBeErased(userId: string) {
+  const user = await prisma.user.findUnique({
+    where: { id: userId },
+    select: {
+      id: true,
+      teacherIn: {
+        select: {
+          id: true,
+          name: true,
+          _count: { select: { students: true } },
+        },
+      },
+      _count: {
+        select: {
+          assignments: true,
+          createdLabChats: true,
+        },
+      },
+    },
+  });
+
+  if (!user) {
+    throw new TRPCError({ code: "NOT_FOUND", message: "User not found" });
+  }
+
+  const classesWithStudents = user.teacherIn.filter(
+    (cls) => cls._count.students > 0,
+  );
+  if (classesWithStudents.length > 0) {
+    throw new TRPCError({
+      code: "PRECONDITION_FAILED",
+      message:
+        "Delete or transfer your classes before deleting your account.",
+    });
+  }
+
+  if (user._count.assignments > 0) {
+    throw new TRPCError({
+      code: "PRECONDITION_FAILED",
+      message:
+        "Remove or reassign your assignments before deleting your account.",
+    });
+  }
+
+  if (user._count.createdLabChats > 0) {
+    throw new TRPCError({
+      code: "PRECONDITION_FAILED",
+      message: "Remove your AI lab chats before deleting your account.",
+    });
+  }
+}
+
+/** Export a portable snapshot of the authenticated user's personal data. */
+export async function exportUserData(userId: string) {
+  const user = await prisma.user.findUnique({
+    where: { id: userId },
+    select: {
+      id: true,
+      username: true,
+      email: true,
+      verified: true,
+      termsAcceptedAt: true,
+      termsVersion: true,
+      profile: true,
+      teacherIn: {
+        select: { id: true, name: true, subject: true, section: true },
+      },
+      studentIn: {
+        select: { id: true, name: true, subject: true, section: true },
+      },
+      schoolMemberships: {
+        select: {
+          role: true,
+          status: true,
+          school: { select: { id: true, name: true } },
+        },
+      },
+      submissions: {
+        select: {
+          id: true,
+          createdAt: true,
+          submittedAt: true,
+          gradeReceived: true,
+          extendedResponse: true,
+          assignment: { select: { id: true, title: true, classId: true } },
+        },
+      },
+      events: {
+        select: {
+          id: true,
+          name: true,
+          startTime: true,
+          endTime: true,
+          location: true,
+          remarks: true,
+        },
+      },
+      sentMessages: {
+        select: {
+          id: true,
+          content: true,
+          createdAt: true,
+          conversationId: true,
+        },
+        take: 500,
+        orderBy: { createdAt: "desc" },
+      },
+      notificationsReceived: {
+        select: {
+          id: true,
+          title: true,
+          content: true,
+          read: true,
+          createdAt: true,
+        },
+        take: 200,
+        orderBy: { createdAt: "desc" },
+      },
+    },
+  });
+
+  if (!user) {
+    throw new TRPCError({ code: "NOT_FOUND", message: "User not found" });
+  }
+
+  return {
+    exportedAt: new Date().toISOString(),
+    user,
+  };
+}
+
+/**
+ * Erase personal account data by anonymizing the user record and removing
+ * sessions and memberships. Educational records tied to classes (e.g.
+ * submissions) remain with an anonymized identity where required.
+ */
+export async function deleteUserAccount(userId: string) {
+  await assertAccountCanBeErased(userId);
+  await deleteSessionsByUserId(userId);
+
+  const anonUsername = `deleted_${userId.slice(0, 8)}`;
+  const anonEmail = `deleted+${userId}@studious.invalid`;
+  const randomPassword = await hash(randomBytes(32).toString("hex"), 10);
+
+  await prisma.$transaction([
+    prisma.conversationMember.deleteMany({ where: { userId } }),
+    prisma.notification.deleteMany({
+      where: { OR: [{ senderId: userId }, { receiverId: userId }] },
+    }),
+    prisma.schoolMembership.deleteMany({ where: { userId } }),
+    prisma.permission.deleteMany({
+      where: { OR: [{ userId }, { grantedById: userId }] },
+    }),
+    prisma.user.update({
+      where: { id: userId },
+      data: {
+        teacherIn: { set: [] },
+        studentIn: { set: [] },
+        departments: { set: [] },
+        tags: { set: [] },
+        specificAssignments: { set: [] },
+        presentAttendance: { set: [] },
+        lateAttendance: { set: [] },
+        absentAttendance: { set: [] },
+        schoolId: null,
+        username: anonUsername,
+        email: anonEmail,
+        password: randomPassword,
+        verified: false,
+        termsAcceptedAt: null,
+        termsVersion: null,
+        profile: {
+          update: {
+            displayName: null,
+            bio: null,
+            location: null,
+            website: null,
+            profilePicture: null,
+            profilePictureThumbnail: null,
+          },
+        },
+      },
+    }),
+  ]);
+
+  return { success: true };
+}

package/src/services/worksheet.ts

@@ -3,7 +3,7 @@
  * Integrates with gradeWorksheet pipeline for auto-grading.
  */
 import { TRPCError } from "@trpc/server";
-import { JobStatus, type WorksheetQuestionType } from "@prisma/client";
+import { JobStatus, Prisma, type WorksheetQuestionType } from "@prisma/client";
 import { prisma } from "../lib/prisma.js";
 import { getFileUrl } from "../lib/fileUpload.js";
 import { cancelGradePipeline, regradeWorksheetPipeline } from "../pipelines/gradeWorksheet.js";
@@ -38,6 +38,7 @@ import {
   findStudentQuestionProgressByIdForStudentOrTeacher,
   findStudentQuestionProgressByIdForTeacherAndResponse,
 } from "../models/worksheet.js";
+import { enqueueEmbedding } from "./embedding.js";
 
 type MCQOptions = { id: string; text: string; isCorrect: boolean }[];
 
@@ -108,7 +109,10 @@ export async function updateWorksheetRecord(
       message: "Only class teachers can update worksheets",
     });
   }
-  return updateWorksheet(worksheetId, data);
+  const updated = await updateWorksheet(worksheetId, data);
+  // Re-index worksheet for RAG search
+  enqueueEmbedding(worksheet.classId, 'WORKSHEET', worksheetId);
+  return updated;
 }
 
 export async function deleteWorksheetRecord(worksheetId: string, userId: string) {
@@ -123,7 +127,10 @@ export async function deleteWorksheetRecord(worksheetId: string, userId: string)
 }
 
 export async function createWorksheetRecord(classId: string, name: string) {
-  return createWorksheet({ classId, name });
+  const worksheet = await createWorksheet({ classId, name });
+  // Auto-index worksheet for RAG search
+  enqueueEmbedding(classId, 'WORKSHEET', worksheet.id);
+  return worksheet;
 }
 
 /**
@@ -316,6 +323,73 @@ export async function addQuestionToWorksheet(
   });
 }
 
+/** A question's full editable state as captured before an AI modifier run. */
+export interface WorksheetQuestionSnapshot {
+  id: string;
+  type: WorksheetQuestionType;
+  question: string;
+  answer: string;
+  options: unknown;
+  markScheme: unknown;
+  points: number;
+  order: number | null;
+}
+
+const toJsonInput = (value: unknown) =>
+  value === null || value === undefined
+    ? Prisma.JsonNull
+    : (value as Prisma.InputJsonValue);
+
+/**
+ * Restore a worksheet's questions to a snapshot: deletes questions not in the
+ * snapshot, re-creates deleted ones (with their original ids), and reverts
+ * edited ones. Used by AI modifier undo.
+ */
+export async function restoreWorksheetQuestions(
+  worksheetId: string,
+  userId: string,
+  questions: WorksheetQuestionSnapshot[]
+) {
+  const worksheet = await findWorksheetByIdForTeacher(worksheetId, userId);
+  if (!worksheet) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Only class teachers can modify worksheet questions",
+    });
+  }
+
+  await prisma.$transaction([
+    prisma.worksheetQuestion.deleteMany({
+      where: { worksheetId, id: { notIn: questions.map((q) => q.id) } },
+    }),
+    ...questions.map((q) =>
+      prisma.worksheetQuestion.upsert({
+        where: { id: q.id },
+        create: {
+          id: q.id,
+          worksheetId,
+          type: q.type,
+          question: q.question,
+          answer: q.answer,
+          options: toJsonInput(q.options),
+          markScheme: toJsonInput(q.markScheme),
+          points: q.points,
+          order: q.order,
+        },
+        update: {
+          type: q.type,
+          question: q.question,
+          answer: q.answer,
+          options: toJsonInput(q.options),
+          markScheme: toJsonInput(q.markScheme),
+          points: q.points,
+          order: q.order,
+        },
+      })
+    ),
+  ]);
+}
+
 export async function reorderWorksheetQuestions(
   worksheetId: string,
   userId: string,

package/src/utils/email.ts

@@ -27,7 +27,11 @@ export const transport = nodemailer.createTransport({
 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}`);
+    logger.info("Email dry run enabled. Would have sent email", {
+      to,
+      from,
+      subject,
+    });
     return;
   }
   

package/src/utils/streamBroadcast.ts

@@ -0,0 +1,48 @@
+/**
+ * Broadcast text content as sequential Pusher chunks so connected clients
+ * can render progressive streaming even when the underlying inference call
+ * returns the full text at once (structured-output pipelines).
+ */
+import { pusher, chatChannel } from '../lib/pusher.js';
+
+const CHUNK_SIZE = 80;
+
+interface BroadcastTextChunksOptions {
+  /** When true, skip the `message-stream-complete` event at the end.
+   *  Callers that need to broadcast additional events (e.g. tool-call
+   *  indicators) before the stream ends should set this to `true` and
+   *  call {@link broadcastStreamComplete} explicitly when done. */
+  skipComplete?: boolean;
+}
+
+export async function broadcastTextChunks(
+  conversationId: string,
+  messageId: string,
+  text: string,
+  options?: BroadcastTextChunksOptions,
+): Promise<void> {
+  for (let i = 0; i < text.length; i += CHUNK_SIZE) {
+    const chunk = text.slice(i, i + CHUNK_SIZE);
+    await pusher
+      .trigger(chatChannel(conversationId), 'message-stream-chunk', {
+        messageId,
+        chunk,
+      })
+      .catch(() => {});
+  }
+
+  if (!options?.skipComplete) {
+    await broadcastStreamComplete(conversationId, messageId);
+  }
+}
+
+export async function broadcastStreamComplete(
+  conversationId: string,
+  messageId: string,
+): Promise<void> {
+  await pusher
+    .trigger(chatChannel(conversationId), 'message-stream-complete', {
+      messageId,
+    })
+    .catch(() => {});
+}

package/src/workers/connection.ts

@@ -35,3 +35,22 @@ function buildBullConnection(): IORedis {
 }
 
 export const bullConnection = buildBullConnection();
+
+/**
+ * Key prefix applied to every BullMQ Queue and Worker.
+ *
+ * Without this, BullMQ defaults to the `bull` namespace, so ANY process
+ * pointed at the same Redis instance shares the same queues. That is a
+ * problem when a single Redis (e.g. a shared Upstash instance) is used across
+ * environments while each environment has its own database: a worker can pick
+ * up a job enqueued elsewhere, fail to find its `RunJob` row, and crash-loop
+ * with "No record was found for an update".
+ *
+ * Namespacing by environment keeps each environment's jobs isolated. Override
+ * with `BULL_PREFIX` when you need finer-grained separation (e.g. per
+ * developer sharing one Redis).
+ */
+export function getBullPrefix(): string {
+  const explicit = env.BULL_PREFIX?.trim();
+  return explicit && explicit.length > 0 ? explicit : `bull:${env.NODE_ENV}`;
+}

package/src/workers/index.ts

@@ -17,6 +17,7 @@ import { aiNewtonChatWorker } from './processors/aiNewtonChat.js';
 import { gradeWorksheetWorker } from './processors/gradeWorksheet.js';
 import { pdfToWorksheetWorker } from './processors/pdfToWorksheet.js';
 import { studentProgressChatWorker } from './processors/studentProgressChat.js';
+import { embedContentWorker } from './processors/embedContent.js';
 
 const workers: Worker<any>[] = [
   pdfToWorksheetWorker,
@@ -24,6 +25,7 @@ const workers: Worker<any>[] = [
   aiLabChatWorker,
   aiNewtonChatWorker,
   studentProgressChatWorker,
+  embedContentWorker,
 ];
 
 logger.info('Workers ready', {

package/src/workers/processors/createRunJobWorker.ts

@@ -17,7 +17,7 @@
  */
 import { Worker, type Job, type WorkerOptions } from 'bullmq';
 import { Prisma, type RunJobType } from '@prisma/client';
-import { bullConnection } from '../connection.js';
+import { bullConnection, getBullPrefix } from '../connection.js';
 import { prisma } from '../../lib/prisma.js';
 import { logger } from '../../utils/logger.js';
 import { QUEUE_NAMES, type JobInputs } from '../queues.js';
@@ -69,7 +69,21 @@ export function createRunJobWorker<T extends RunJobType>({
         select: { status: true, result: true, userId: true, classId: true },
       });
 
-      if (existing?.status === 'SUCCEEDED') {
+      if (!existing) {
+        // Orphaned job: the RunJob row this job points at does not exist in
+        // THIS database. Typically caused by a Redis instance shared across
+        // environments/databases (the `prefix` namespacing in this file's
+        // Worker options is the primary guard against that), or by a DB reset
+        // that left jobs behind in Redis. Discard instead of throwing on the
+        // `update` below and burning all retry attempts.
+        logger.warn(`${name} RunJob not found; discarding orphaned job`, {
+          runJobId,
+          bullJobId: job.id,
+        });
+        return null;
+      }
+
+      if (existing.status === 'SUCCEEDED') {
         logger.info(`${name} RunJob already succeeded; skipping re-run`, {
           runJobId,
           bullJobId: job.id,
@@ -81,7 +95,7 @@ export function createRunJobWorker<T extends RunJobType>({
         where: { id: runJobId },
         data: {
           status: 'RUNNING',
-          startedAt: existing?.status === 'RUNNING' ? undefined : new Date(),
+          startedAt: existing.status === 'RUNNING' ? undefined : new Date(),
           attempts: { increment: 1 },
         },
       });
@@ -90,8 +104,8 @@ export function createRunJobWorker<T extends RunJobType>({
         runJobId,
         bullJobId: job.id,
         attempt: job.attemptsMade + 1,
-        userId: existing?.userId ?? null,
-        classId: existing?.classId ?? null,
+        userId: existing.userId ?? null,
+        classId: existing.classId ?? null,
       });
 
       await prisma.runJob.update({
@@ -106,7 +120,7 @@ export function createRunJobWorker<T extends RunJobType>({
 
       return result;
     },
-    { connection: bullConnection, ...workerOptions },
+    { connection: bullConnection, prefix: getBullPrefix(), ...workerOptions },
   );
 
   worker.on('error', (err) => {
@@ -143,6 +157,18 @@ export function createRunJobWorker<T extends RunJobType>({
         },
       })
       .catch((updateError) => {
+        // P2025 = record not found. The RunJob row is gone (orphaned job from a
+        // shared/reset Redis), so there's nothing to flag as FAILED — log
+        // quietly instead of as an error to avoid noise.
+        if (
+          updateError instanceof Prisma.PrismaClientKnownRequestError &&
+          updateError.code === 'P2025'
+        ) {
+          logger.warn(`${name} failure not recorded; RunJob no longer exists`, {
+            runJobId,
+          });
+          return;
+        }
         logger.error(`Failed to record ${name} failure on RunJob`, {
           runJobId,
           error:

package/src/workers/processors/embedContent.ts

@@ -0,0 +1,86 @@
+/**
+ * Background worker for embedding content into pgvector.
+ * Handles indexing of files, assignments, worksheets, announcements,
+ * discussions, submissions, and syllabi.
+ */
+import { createRunJobWorker } from './createRunJobWorker.js';
+import {
+  indexAssignment,
+  indexWorksheet,
+  indexAnnouncement,
+  indexDiscussion,
+  indexSubmission,
+  indexSyllabus,
+  indexFile,
+  indexContent,
+} from '../../services/embedding.js';
+import { prisma } from '../../lib/prisma.js';
+import { logger } from '../../utils/logger.js';
+import type { EmbeddingSourceType } from '@prisma/client';
+
+export const embedContentWorker = createRunJobWorker({
+  type: 'EMBED_CONTENT',
+  workerOptions: {
+    concurrency: 3,
+    limiter: { max: 10, duration: 60_000 },
+  },
+  run: async ({ classId, sourceType, sourceId }) => {
+    const typedSourceType = sourceType as EmbeddingSourceType;
+
+    switch (typedSourceType) {
+      case 'ASSIGNMENT':
+        await indexAssignment(classId, sourceId);
+        break;
+
+      case 'WORKSHEET':
+        await indexWorksheet(classId, sourceId);
+        break;
+
+      case 'ANNOUNCEMENT':
+        await indexAnnouncement(classId, sourceId);
+        break;
+
+      case 'FILE':
+        await indexFile(classId, sourceId);
+        break;
+
+      case 'DISCUSSION':
+        await indexDiscussion(classId, sourceId);
+        break;
+
+      case 'SUBMISSION':
+        await indexSubmission(classId, sourceId);
+        break;
+
+      case 'SYLLABUS':
+        await indexSyllabus(sourceId);
+        break;
+
+      case 'SECTION': {
+        const section = await prisma.section.findUnique({
+          where: { id: sourceId },
+          select: { name: true },
+        });
+
+        if (!section) {
+          return { skipped: true, reason: 'section_not_found' };
+        }
+
+        await indexContent({
+          classId,
+          sourceType: 'SECTION',
+          sourceId,
+          text: `Section: ${section.name}`,
+          metadata: { name: section.name },
+        });
+        break;
+      }
+
+      default:
+        logger.warn('Unknown embedding source type', { sourceType, sourceId });
+        return { skipped: true, reason: 'unknown_source_type' };
+    }
+
+    return { indexed: true, sourceType, sourceId };
+  },
+});

package/src/workers/queues.ts

@@ -8,7 +8,7 @@
  */
 import { Queue, type JobsOptions } from 'bullmq';
 import { Prisma, type RunJobType } from '@prisma/client';
-import { bullConnection } from './connection.js';
+import { bullConnection, getBullPrefix } from './connection.js';
 import { prisma } from '../lib/prisma.js';
 import { logger } from '../utils/logger.js';
 
@@ -47,6 +47,8 @@ export type JobInputs = {
    */
   AI_NEWTON_CHAT: { conversationId: string; aiMessageId: string };
   STUDENT_PROGRESS_CHAT: { classId: string; studentId: string; message: string };
+  /** Embed content into pgvector for RAG search. */
+  EMBED_CONTENT: { classId: string; sourceType: string; sourceId: string };
 };
 
 export const QUEUE_NAMES: Record<RunJobType, string> = {
@@ -55,6 +57,7 @@ export const QUEUE_NAMES: Record<RunJobType, string> = {
   AI_LAB_CHAT: 'aiLabChat',
   AI_NEWTON_CHAT: 'aiNewtonChat',
   STUDENT_PROGRESS_CHAT: 'studentProgressChat',
+  EMBED_CONTENT: 'embedContent',
 };
 
 /**
@@ -68,6 +71,7 @@ function getQueue(type: RunJobType): Queue {
   if (!queue) {
     queue = new Queue(QUEUE_NAMES[type], {
       connection: bullConnection,
+      prefix: getBullPrefix(),
       defaultJobOptions: DEFAULT_JOB_OPTIONS,
     });
     queueCache.set(type, queue);

package/tests/helpers/registerInput.ts

@@ -0,0 +1,20 @@
+import { CURRENT_TERMS_VERSION } from "../../src/lib/legal.js";
+
+export function registerInput(
+  overrides: {
+    username: string;
+    email: string;
+    password?: string;
+    confirmPassword?: string;
+  },
+) {
+  const password = overrides.password ?? "password_is_1234";
+  return {
+    username: overrides.username,
+    email: overrides.email,
+    password,
+    confirmPassword: overrides.confirmPassword ?? password,
+    agreeToTerms: true as const,
+    termsVersion: CURRENT_TERMS_VERSION,
+  };
+}

package/tests/integration/globalSetup.ts

@@ -10,6 +10,7 @@ import { createTRPCContext } from '../../src/trpc';
 import { clearDatabase } from '../../src/seedDatabase';
 import { execSync } from 'child_process';
 import { SessionType } from '@prisma/client';
+import { registerInput } from '../helpers/registerInput.js';
 
 async function runSetup() {
   const ctx = await createTRPCContext({
@@ -20,26 +21,17 @@ async function runSetup() {
 
   execSync('npm run test:pre');
 
-  const user1 = await caller.auth.register({
-    username: 'testuser1',
-    email: 'test@studious.sh',
-    password: 'password_is_1234',
-    confirmPassword: 'password_is_1234',
-  });
+  const user1 = await caller.auth.register(
+    registerInput({ username: 'testuser1', email: 'test@studious.sh' }),
+  );
 
-  const user2 = await caller.auth.register({
-    username: 'testuser2',
-    email: 'test2@studious.sh',
-    password: 'password_is_1234',
-    confirmPassword: 'password_is_1234',
-  });
+  const user2 = await caller.auth.register(
+    registerInput({ username: 'testuser2', email: 'test2@studious.sh' }),
+  );
 
-  const user3 = await caller.auth.register({
-    username: 'testuser3',
-    email: 'test3@studious.sh',
-    password: 'password_is_1234',
-    confirmPassword: 'password_is_1234',
-  });
+  const user3 = await caller.auth.register(
+    registerInput({ username: 'testuser3', email: 'test3@studious.sh' }),
+  );
 
   const session1 = await prisma.session.findFirst({
     where: { userId: user1.user.id, type: SessionType.EMAIL_VERIFICATION },