@studious-lms/server 1.4.7 → 1.5.0

package/src/services/assignment.ts

@@ -6,6 +6,7 @@ import { prisma } from "../lib/prisma.js";
 import {
   findAssignmentById,
   findAssignmentWithDetails,
+  findAssignmentWithClassForTeacher,
   findAssignmentForDelete,
   findAssignmentsDueToday,
   findSubmissionByAssignmentAndStudent,
@@ -15,10 +16,10 @@ import {
   findSubmissionsByAssignmentForTeacher,
   createSubmission,
   findSectionsByClassId,
-  findAssignmentWithClassForTeacher,
   findAvailableEventsForAssignment,
   attachAssignmentToEvent,
   detachAssignmentFromEvent,
+  duplicateAssignment,
 } from "../models/assignment.js";
 import { createDirectUploadFiles, type UploadedFile } from "../lib/fileUpload.js";
 import { deleteFile } from "../lib/googleCloudStorage.js";
@@ -320,6 +321,51 @@ export async function createAssignmentRecord(
   return assignment;
 }
 
+/**
+ * Duplicate an assignment into another class. Caller must teach both the source assignment’s
+ * class and the target class.
+ */
+export async function duplicateAssignmentRecord(
+  assignmentId: string,
+  classId: string,
+  title: string,
+  userId: string
+) {
+  const source = await findAssignmentWithClassForTeacher(assignmentId, userId);
+  if (!source) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message:
+        "Assignment not found or you are not a teacher of the class it belongs to",
+    });
+  }
+
+  const targetOk = await prisma.class.findFirst({
+    where: {
+      id: classId,
+      teachers: { some: { id: userId } },
+    },
+    select: { id: true },
+  });
+
+  if (!targetOk) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "You are not a teacher of the target class",
+    });
+  }
+
+  const created = await duplicateAssignment(assignmentId, classId, title, userId);
+  if (!created) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Assignment not found or could not be duplicated",
+    });
+  }
+
+  return created;
+}
+
 export async function updateAssignmentRecord(
   userId: string,
   input: {

package/src/services/class.ts

@@ -25,9 +25,35 @@ import {
   findFullExportableClass,
   createClassByImport,
 } from "../models/class.js";
-import { listUserSchoolMemberships } from "../models/school.js";
 import { Class, Folder } from "@prisma/client";
 
+async function requireActiveSchoolMembers(schoolId: string, userIds: string[]) {
+  const uniqueUserIds = [...new Set(userIds)];
+  if (!uniqueUserIds.length) {
+    return;
+  }
+
+  const memberships = await prisma.schoolMembership.findMany({
+    where: {
+      schoolId,
+      status: "ACTIVE",
+      userId: { in: uniqueUserIds },
+    },
+    select: { userId: true },
+  });
+  const activeMemberIds = new Set(
+    memberships.map((membership) => membership.userId)
+  );
+  const hasNonMember = uniqueUserIds.some((id) => !activeMemberIds.has(id));
+
+  if (hasNonMember) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "All class members must belong to this school",
+    });
+  }
+}
+
 /** Get all classes where user is teacher or student, with assignments and members. */
 export async function getAllClasses(userId: string) {
   const [teacherClasses, studentClasses] = await Promise.all([
@@ -128,8 +154,10 @@ export async function createClass(
   const { students, teachers, name, section, subject, color, schoolId } = input;
 
   if (schoolId) {
-    const memberships = await listUserSchoolMemberships(userId);
-    const membership = memberships.find((item) => item.schoolId === schoolId);
+    const membership = await prisma.schoolMembership.findFirst({
+      where: { userId, schoolId, status: "ACTIVE" },
+      select: { role: true },
+    });
 
     if (!membership) {
       throw new TRPCError({
@@ -146,19 +174,11 @@ export async function createClass(
     }
   }
 
-  if (teachers && teachers.length > 0 && students && students.length > 0) {
-    return prisma.class.create({
-      data: {
-        name,
-        section,
-        subject,
-        color,
-        schoolId,
-        teachers: { connect: teachers.map((id) => ({ id })) },
-        students: { connect: students.map((id) => ({ id })) },
-      },
-      include: { teachers: true, students: true },
-    });
+  const teacherIds = teachers?.length ? teachers : [userId];
+  const studentIds = students?.length ? students : [];
+
+  if (schoolId) {
+    await requireActiveSchoolMembers(schoolId, [...teacherIds, ...studentIds]);
   }
 
   return prisma.class.create({
@@ -168,8 +188,12 @@ export async function createClass(
       subject,
       color,
       schoolId,
-      teachers: { connect: { id: userId } },
+      teachers: { connect: teacherIds.map((id) => ({ id })) },
+      ...(studentIds.length
+        ? { students: { connect: studentIds.map((id) => ({ id })) } }
+        : {}),
     },
+    include: { teachers: true, students: true },
   });
 }
 

package/src/services/labChat.ts

@@ -3,7 +3,7 @@
  * trigger AI responses, and broadcast via Pusher.
  */
 import { TRPCError } from "@trpc/server";
-import { GenerationStatus } from "@prisma/client";
+import { JobStatus } from "@prisma/client";
 import { prisma } from "../lib/prisma.js";
 import { chatChannel, teacherChannel, pusher } from "../lib/pusher.js";
 import {
@@ -175,7 +175,7 @@ export async function getLabChat(userId: string, labChatId: string) {
   const pendingMessage = await prisma.message.findFirst({
     where: {
       conversationId: labChat.conversationId,
-      status: GenerationStatus.PENDING,
+      status: JobStatus.PENDING,
       senderId: { not: "AI_ASSISTANT" },
     },
     orderBy: { createdAt: "desc" },
@@ -252,7 +252,7 @@ export async function postToLabChat(
         content: normalizedContent,
         senderId: userId,
         conversationId: labChat.conversationId,
-        ...(isAIUser(userId) ? {} : { status: GenerationStatus.PENDING }),
+        ...(isAIUser(userId) ? {} : { status: JobStatus.PENDING }),
       },
     });
 
@@ -452,7 +452,7 @@ export async function rerunLastResponse(userId: string, labChatId: string) {
     }),
     prisma.message.update({
       where: { id: teacherMessage.id },
-      data: { status: GenerationStatus.PENDING },
+      data: { status: JobStatus.PENDING },
     }),
   ]);
 

package/src/services/message.ts

@@ -110,6 +110,19 @@ export async function confirmMessageUpload(
     });
   }
 
+  if (input.uploadSuccess) {
+    await prisma.$transaction(async (tx) => {
+      await tx.file.update({
+        where: { id: input.fileId },
+        data: { uploadStatus: "FAILED", uploadError: input.errorMessage },
+      });
+    });
+    throw new TRPCError({
+      code: "INTERNAL_SERVER_ERROR",
+      message: "Failed to confirm upload",
+    });
+  }
+
   const file = await prisma.file.findFirst({
     where: {
       id: input.fileId,

package/src/services/school.ts

@@ -1,13 +1,23 @@
 /**
  * School service - school admin workflow, memberships, and invites.
  */
-import { SchoolMembershipRole } from "@prisma/client";
+import { SchoolMembershipRole, SessionType } from "@prisma/client";
 import { TRPCError } from "@trpc/server";
+import { hash } from "bcryptjs";
 import { v4 as uuidv4 } from "uuid";
 import { env } from "../lib/config/env.js";
 import { prisma } from "../lib/prisma.js";
 import { sendMail } from "../utils/email.js";
+import { generateUniqueUsername } from "../utils/generateUsername.js";
 import { logger } from "../utils/logger.js";
+import {
+  createSession,
+  createUser,
+  findUserByEmail,
+  findUserById,
+  findUserByUsername,
+} from "../models/auth.js";
+import { upsertUserProfile } from "../models/user.js";
 import {
   acceptSchoolInvite,
   countActiveAdmins,
@@ -16,7 +26,6 @@ import {
   findActiveSchoolAdminMembership,
   findPendingInviteByToken,
   findSchoolMembership,
-  findUserByIdForSchool,
   getSchoolById,
   getSchoolOverview,
   listSchoolClasses,
@@ -225,9 +234,61 @@ export async function listInvites(userId: string, schoolId: string) {
 
 export async function createInvite(
   userId: string,
-  input: { schoolId: string; email: string; role: SchoolMembershipRole }
+  input: {
+    schoolId: string;
+    email: string;
+    role: SchoolMembershipRole;
+    username?: string;
+    displayName?: string;
+  }
 ) {
   await requireSchoolAdmin(input.schoolId, userId);
+
+  const existingUser = await findUserByEmail(input.email);
+
+  let createdUser: { id: string; username: string } | null = null;
+  let passwordResetToken: string | null = null;
+
+  if (!existingUser) {
+    let username: string;
+    if (input.username) {
+      const taken = await findUserByUsername(input.username);
+      if (taken) {
+        throw new TRPCError({
+          code: "CONFLICT",
+          message: "Username already taken",
+        });
+      }
+      username = input.username;
+    } else {
+      username = await generateUniqueUsername(async (candidate) => {
+        const existing = await findUserByUsername(candidate);
+        return Boolean(existing);
+      });
+    }
+
+    const placeholderPassword = await hash(uuidv4(), 10);
+    const user = await createUser({
+      username,
+      email: input.email,
+      password: placeholderPassword,
+      verified: true,
+    });
+    createdUser = { id: user.id, username: user.username };
+
+    if (input.displayName) {
+      await upsertUserProfile(user.id, { displayName: input.displayName });
+    }
+
+    const resetSession = await createSession({
+      id: uuidv4(),
+      type: SessionType.PASSWORD_RESET,
+      userId: user.id,
+      expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 14),
+    });
+    passwordResetToken = resetSession.id;
+  }
+
   const token = uuidv4();
   const invite = await createSchoolInvite({
     schoolId: input.schoolId,
@@ -238,12 +299,34 @@ export async function createInvite(
     expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 14),
   });
 
+  if (createdUser) {
+    await acceptSchoolInvite(invite.id, createdUser.id);
+  }
+
+  const inviteUrl = `${env.NEXT_PUBLIC_APP_URL}/school/invite/${token}`;
+  const passwordResetUrl = passwordResetToken
+    ? `${env.NEXT_PUBLIC_APP_URL}/reset-password/${passwordResetToken}`
+    : null;
+
+  const emailLines = [
+    `You've been invited to ${invite.school.name} on Studious.`,
+    "",
+  ];
+  if (createdUser && passwordResetUrl) {
+    emailLines.push(
+      `We created an account for you with the username "${createdUser.username}" and added you to ${invite.school.name}.`,
+      `Set your password to get started: ${passwordResetUrl}`
+    );
+  } else {
+    emailLines.push(`Click the link to confirm: ${inviteUrl}`);
+  }
+
   try {
     await sendMail({
       from: "hello@studious.sh",
       to: input.email,
       subject: `Join ${invite.school.name} on Studious`,
-      text: `Click the link to join ${invite.school.name}: ${env.NEXT_PUBLIC_APP_URL}/school/invite/${token}`,
+      text: emailLines.join("\n"),
     });
   } catch (err) {
     logger.error("Failed to send school invite email", {
@@ -253,7 +336,7 @@ export async function createInvite(
     });
   }
 
-  return { invite };
+  return { invite, createdUser };
 }
 
 export async function revokeInvite(
@@ -292,7 +375,7 @@ export async function acceptInvite(userId: string, token: string) {
     throw new TRPCError({ code: "UNAUTHORIZED", message: "Invite expired" });
   }
 
-  const user = await findUserByIdForSchool(userId);
+  const user = await findUserById(userId);
   if (!user) {
     throw new TRPCError({ code: "NOT_FOUND", message: "User not found" });
   }

package/src/services/worksheet.ts

@@ -3,7 +3,7 @@
  * Integrates with gradeWorksheet pipeline for auto-grading.
  */
 import { TRPCError } from "@trpc/server";
-import { GenerationStatus, type WorksheetQuestionType } from "@prisma/client";
+import { JobStatus, type WorksheetQuestionType } from "@prisma/client";
 import { prisma } from "../lib/prisma.js";
 import { getFileUrl } from "../lib/fileUpload.js";
 import { cancelGradePipeline, regradeWorksheetPipeline } from "../pipelines/gradeWorksheet.js";
@@ -14,6 +14,7 @@ import {
   findWorksheetByIdForTeacher,
   findWorksheetsByClassId,
   createWorksheet,
+  duplicateWorksheet,
   updateWorksheet,
   deleteWorksheet,
   findQuestionsByWorksheetId,
@@ -123,6 +124,51 @@ export async function createWorksheetRecord(classId: string, name: string) {
   return createWorksheet({ classId, name });
 }
 
+/**
+ * Duplicate a worksheet into another class. Caller must teach both the source worksheet's class
+ * and the target class.
+ */
+export async function duplicateWorksheetRecord(
+  worksheetId: string,
+  classId: string,
+  name: string,
+  userId: string
+) {
+  const source = await findWorksheetByIdForTeacher(worksheetId, userId);
+  if (!source) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message:
+        "Worksheet not found or you are not a teacher of the class it belongs to",
+    });
+  }
+
+  const targetOk = await prisma.class.findFirst({
+    where: {
+      id: classId,
+      teachers: { some: { id: userId } },
+    },
+    select: { id: true },
+  });
+
+  if (!targetOk) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "You are not a teacher of the target class",
+    });
+  }
+
+  const created = await duplicateWorksheet(worksheetId, classId, name);
+  if (!created) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Worksheet not found",
+    });
+  }
+
+  return created;
+}
+
 /**
  * Create a worksheet by converting a PDF (URL) into structured questions.
  * Uses the `pdfToWorksheet` pipeline to do inference + persistence.
@@ -237,24 +283,22 @@ export async function reorderWorksheetQuestions(
       message: "Target question not found",
     });
   }
+  if (movedId === targetId) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Moved question and target question must be different",
+    });
+  }
 
   const withoutMoved = questions.filter((q) => q.id !== movedId);
-  const next =
-    position === "before"
-      ? [
-          ...withoutMoved.slice(0, targetIdx).map((item) => ({ id: item.id })),
-          { id: movedId },
-          ...withoutMoved.slice(targetIdx).map((item) => ({ id: item.id })),
-        ]
-      : [
-          ...withoutMoved
-            .slice(0, targetIdx + 1)
-            .map((item) => ({ id: item.id })),
-          { id: movedId },
-          ...withoutMoved
-            .slice(targetIdx + 1)
-            .map((item) => ({ id: item.id })),
-        ];
+  const targetIdxWithoutMoved = withoutMoved.findIndex((q) => q.id === targetId);
+  const insertIdx =
+    position === "before" ? targetIdxWithoutMoved : targetIdxWithoutMoved + 1;
+  const next = [
+    ...withoutMoved.slice(0, insertIdx).map((item) => ({ id: item.id })),
+    { id: movedId },
+    ...withoutMoved.slice(insertIdx).map((item) => ({ id: item.id })),
+  ];
 
   await prisma.$transaction(
     next.map((item, index) =>
@@ -386,7 +430,7 @@ export async function answerWorksheetQuestion(
       ...(isMarkableByAlgo && {
         points: response === correctAnswer ? marksAwardedIfCorrect : 0,
       }),
-      status: GenerationStatus.NOT_STARTED,
+      status: JobStatus.NOT_STARTED,
     });
   } else {
     await createStudentQuestionProgress({

package/src/utils/generateUsername.ts

@@ -0,0 +1,108 @@
+/**
+ * Username generator – produces playful adjective+noun+number combos like "greenegg6767".
+ * Pass an `isTaken` checker to retry until a unique username is found.
+ */
+
+const ADJECTIVES = [
+  "green",
+  "blue",
+  "red",
+  "purple",
+  "yellow",
+  "orange",
+  "pink",
+  "silver",
+  "golden",
+  "fuzzy",
+  "happy",
+  "sleepy",
+  "sneaky",
+  "silly",
+  "brave",
+  "clever",
+  "lucky",
+  "mighty",
+  "quiet",
+  "quick",
+  "loud",
+  "tiny",
+  "giant",
+  "spicy",
+  "jolly",
+  "wild",
+  "shiny",
+  "cosmic",
+  "mystic",
+  "swift",
+  "lazy",
+  "grumpy",
+  "fluffy",
+  "zesty",
+];
+
+const NOUNS = [
+  "egg",
+  "cat",
+  "dog",
+  "fox",
+  "owl",
+  "bear",
+  "duck",
+  "frog",
+  "wolf",
+  "panda",
+  "tiger",
+  "otter",
+  "moose",
+  "shark",
+  "whale",
+  "raven",
+  "robin",
+  "koala",
+  "llama",
+  "sloth",
+  "narwhal",
+  "penguin",
+  "dragon",
+  "phoenix",
+  "muffin",
+  "pickle",
+  "noodle",
+  "potato",
+  "taco",
+  "pancake",
+  "waffle",
+  "cookie",
+  "biscuit",
+  "donut",
+];
+
+function pick<T>(items: readonly T[]) {
+  return items[Math.floor(Math.random() * items.length)]!;
+}
+
+function randomDigits(n: number) {
+  let out = "";
+  for (let i = 0; i < n; i += 1) {
+    out += Math.floor(Math.random() * 10).toString();
+  }
+  return out;
+}
+
+export function generateRandomUsername() {
+  return `${pick(ADJECTIVES)}${pick(NOUNS)}${randomDigits(4)}`;
+}
+
+/** Generate a unique username, calling `isTaken` until one is free. */
+export async function generateUniqueUsername(
+  isTaken: (username: string) => Promise<boolean>,
+  maxAttempts = 10
+) {
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    const candidate = generateRandomUsername();
+    if (!(await isTaken(candidate))) {
+      return candidate;
+    }
+  }
+  return `${generateRandomUsername()}${randomDigits(4)}`;
+}

package/src/workers/connection.ts

@@ -0,0 +1,37 @@
+import IORedis from 'ioredis';
+import { env } from '../lib/config/env.js';
+import { logger } from '../utils/logger.js';
+
+/**
+ * BullMQ-specific Redis connection.
+ *
+ * Kept separate from `src/lib/redis.ts` (which is used for caching and
+ * rate-limiting) because BullMQ requires `maxRetriesPerRequest: null` and
+ * `enableReadyCheck: false` on its connection. Mixing those settings with
+ * general Redis usage causes unwanted behaviour on transient errors.
+ */
+function buildBullConnection(): IORedis {
+  if (!env.REDIS_URL) {
+    throw new Error(
+      'REDIS_URL is required for BullMQ. Set it in .env / .env.production / your hosting env.',
+    );
+  }
+
+  const connection = new IORedis(env.REDIS_URL, {
+    maxRetriesPerRequest: null,
+    enableReadyCheck: false,
+    lazyConnect: false,
+  });
+
+  connection.on('error', (err) => {
+    logger.error('BullMQ Redis connection error', { error: err.message });
+  });
+
+  connection.on('connect', () => {
+    logger.info('BullMQ Redis connected');
+  });
+
+  return connection;
+}
+
+export const bullConnection = buildBullConnection();

package/src/workers/index.ts

@@ -0,0 +1,61 @@
+/**
+ * Worker process entrypoint.
+ *
+ * Run separately from the HTTP server (e.g. `node dist/workers/index.js` on
+ * Render/Railway/Fly). Importing this file boots every BullMQ Worker
+ * declared under `src/workers/processors/*`. Do NOT import this from the
+ * HTTP server — that would spin up workers in your serverless functions.
+ */
+import '../instrument.js';
+
+import { Worker } from 'bullmq';
+import { prisma } from '../lib/prisma.js';
+import { logger } from '../utils/logger.js';
+import { bullConnection } from './connection.js';
+import { pdfToWorksheetWorker } from './processors/pdfToWorksheet.js';
+
+const workers: Worker<any>[] = [pdfToWorksheetWorker];
+
+logger.info('Workers ready', {
+  pid: process.pid,
+  queues: workers.map((w) => w.name),
+});
+
+let shuttingDown = false;
+
+async function shutdown(signal: string): Promise<void> {
+  if (shuttingDown) return;
+  shuttingDown = true;
+
+  logger.info(`Received ${signal}, draining workers...`);
+
+  // `worker.close()` waits for in-flight jobs to finish (up to the worker's
+  // settings) before resolving. Run them in parallel.
+  await Promise.allSettled(workers.map((w) => w.close()));
+
+  await Promise.allSettled([
+    bullConnection.quit(),
+    prisma.$disconnect(),
+  ]);
+
+  logger.info('Workers shut down cleanly');
+  process.exit(0);
+}
+
+process.on('SIGTERM', () => void shutdown('SIGTERM'));
+process.on('SIGINT', () => void shutdown('SIGINT'));
+
+process.on('uncaughtException', (error) => {
+  logger.error('Uncaught exception in worker process', {
+    error: error.message,
+    stack: error.stack,
+  });
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (reason) => {
+  logger.error('Unhandled rejection in worker process', {
+    reason: reason instanceof Error ? reason.message : String(reason),
+  });
+  process.exit(1);
+});