@studious-lms/server 1.4.9 → 1.6.0

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,11 +3,12 @@
  * 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";
-import { pdfToWorksheet } from "../pipelines/pdfToWorksheet.js";
+import { enqueueRunJob } from "../workers/queues.js";
+import { logger } from "../utils/logger.js";
 import {
   findWorksheetByIdMinimal,
   findWorksheetByIdForClassMember,
@@ -170,21 +171,77 @@ export async function duplicateWorksheetRecord(
 }
 
 /**
- * Create a worksheet by converting a PDF (URL) into structured questions.
- * Uses the `pdfToWorksheet` pipeline to do inference + persistence.
+ * Kick off PDF-to-worksheet conversion asynchronously.
+ *
+ * We synchronously create a placeholder Worksheet row (status PENDING) so the
+ * caller has an id to navigate to immediately, then enqueue a BullMQ job that
+ * fills in the real title and questions. Progress is broadcast on the
+ * per-worksheet job Pusher channel; clients should subscribe there to drive
+ * loading UI.
  */
 export async function createWorksheetFromPdf(
   classId: string,
-  url: string
+  url: string,
+  userId?: string,
+  options: { name?: string } = {},
 ) {
-  const created = await pdfToWorksheet(url, classId);
-  if (!created) {
+  const placeholder = await prisma.worksheet.create({
+    data: {
+      classId,
+      name: options.name?.trim() || "Converting PDF…",
+      status: JobStatus.PENDING,
+    },
+  });
+
+  try {
+    const { runJobId } = await enqueueRunJob(
+      "PDF_TO_WORKSHEET",
+      { gcsUrl: url, classId, worksheetId: placeholder.id },
+      { classId, userId: userId ?? null },
+    );
+
+    await prisma.worksheet
+      .update({
+        where: { id: placeholder.id },
+        data: { runJobId },
+      })
+      .catch((linkError) => {
+        logger.error(
+          "createWorksheetFromPdf: failed to link RunJob to Worksheet",
+          {
+            worksheetId: placeholder.id,
+            runJobId,
+            error:
+              linkError instanceof Error
+                ? linkError.message
+                : String(linkError),
+          },
+        );
+      });
+
+    return {
+      ...placeholder,
+      runJobId,
+    };
+  } catch (error) {
+    await prisma.worksheet
+      .update({
+        where: { id: placeholder.id },
+        data: { status: JobStatus.FAILED },
+      })
+      .catch(() => undefined);
+
+    logger.error("createWorksheetFromPdf: failed to enqueue conversion", {
+      worksheetId: placeholder.id,
+      classId,
+      error: error instanceof Error ? error.message : String(error),
+    });
+
     throw new TRPCError({
       code: "INTERNAL_SERVER_ERROR",
-      message: "Failed to create worksheet from PDF",
+      message: "Failed to start worksheet conversion",
     });
   }
-  return created;
 }
 
 /**
@@ -193,7 +250,8 @@ export async function createWorksheetFromPdf(
 export async function createWorksheetFromUploadedPdf(
   classId: string,
   fileId: string,
-  userId: string
+  userId: string,
+  options: { name?: string } = {},
 ) {
   const file = await prisma.file.findFirst({
     where: {
@@ -205,6 +263,7 @@ export async function createWorksheetFromUploadedPdf(
       id: true,
       path: true,
       type: true,
+      name: true,
     },
   });
 
@@ -225,7 +284,9 @@ export async function createWorksheetFromUploadedPdf(
   }
 
   const signedUrl = await getFileUrl(file.path);
-  return createWorksheetFromPdf(classId, signedUrl);
+  return createWorksheetFromPdf(classId, signedUrl, userId, {
+    name: options.name ?? file.name ?? undefined,
+  });
 }
 
 export async function addQuestionToWorksheet(
@@ -283,24 +344,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) =>
@@ -432,7 +491,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/utils/inference.ts

@@ -8,7 +8,7 @@ import { prisma } from '../lib/prisma.js';
 import { chatChannel, pusher } from '../lib/pusher.js';
 import { ensureAIUserExists, getAIUserId } from './aiUser.js';
 import { env } from '../lib/config/env.js';
-import { Prisma } from '@prisma/client';
+import { JobStatus, Prisma } from '@prisma/client';
 import { ZodSchema } from 'zod';
 import { zodTextFormat } from 'openai/helpers/zod';
 
@@ -276,6 +276,214 @@ export async function sendAIMessage(
   };
 }
 
+interface AIMessageSenderInfo {
+  displayName?: string;
+  profilePicture?: string | null;
+}
+
+function buildAISenderInfo(customSender?: AIMessageSenderInfo) {
+  return {
+    id: getAIUserId(),
+    username: 'Newton_AI',
+    profile: {
+      displayName: customSender?.displayName ?? 'Newton AI',
+      profilePicture: customSender?.profilePicture ?? null,
+    },
+  };
+}
+
+/**
+ * Create an AI message placeholder in PENDING state and broadcast it.
+ *
+ * The AI message lifecycle == job lifecycle: this row is the bubble the
+ * client renders for "AI is thinking..." and is later flipped by
+ * {@link completePendingAIMessage} / {@link failPendingAIMessage}.
+ */
+export async function createPendingAIMessage(
+  conversationId: string,
+  options: {
+    customSender?: AIMessageSenderInfo;
+  } = {},
+): Promise<{
+  id: string;
+  conversationId: string;
+  createdAt: Date;
+  senderId: string;
+  status: JobStatus;
+}> {
+  await ensureAIUserExists();
+
+  const aiMessage = await prisma.message.create({
+    data: {
+      content: '',
+      senderId: getAIUserId(),
+      conversationId,
+      status: JobStatus.PENDING,
+    },
+  });
+
+  logger.info('AI placeholder message created', {
+    messageId: aiMessage.id,
+    conversationId,
+  });
+
+  const senderInfo = buildAISenderInfo(options.customSender);
+
+  try {
+    await pusher.trigger(chatChannel(conversationId), 'new-message', {
+      id: aiMessage.id,
+      content: '',
+      senderId: getAIUserId(),
+      conversationId: aiMessage.conversationId,
+      status: JobStatus.PENDING,
+      createdAt: aiMessage.createdAt,
+      sender: senderInfo,
+      mentionedUserIds: [],
+      meta: {},
+      attachments: [],
+    });
+  } catch (error) {
+    logger.error('Failed to broadcast pending AI message:', {
+      error,
+      messageId: aiMessage.id,
+    });
+  }
+
+  return {
+    id: aiMessage.id,
+    conversationId: aiMessage.conversationId,
+    createdAt: aiMessage.createdAt,
+    senderId: aiMessage.senderId,
+    status: JobStatus.PENDING,
+  };
+}
+
+/**
+ * Fill a PENDING AI message with its generated content and flip it to
+ * COMPLETED. Broadcasts a `message-updated` event so clients that already
+ * rendered the placeholder can patch it in place.
+ */
+export async function completePendingAIMessage(
+  messageId: string,
+  content: string,
+  options: {
+    attachments?: { connect: { id: string }[] };
+    meta?: Record<string, any>;
+    customSender?: AIMessageSenderInfo;
+  } = {},
+): Promise<{
+  id: string;
+  content: string;
+  conversationId: string;
+  createdAt: Date;
+  status: JobStatus;
+}> {
+  const updated = await prisma.message.update({
+    where: { id: messageId },
+    data: {
+      content,
+      status: JobStatus.COMPLETED,
+      ...(options.attachments && {
+        attachments: {
+          connect: options.attachments.connect,
+        },
+      }),
+      ...(options.meta !== undefined && {
+        meta: options.meta as Prisma.InputJsonValue,
+      }),
+    },
+    include: {
+      attachments: true,
+    },
+  });
+
+  logger.info('AI message completed', {
+    messageId: updated.id,
+    conversationId: updated.conversationId,
+    contentLength: content.length,
+  });
+
+  const senderInfo = buildAISenderInfo(options.customSender);
+
+  try {
+    await pusher.trigger(chatChannel(updated.conversationId), 'message-updated', {
+      id: updated.id,
+      content: updated.content,
+      senderId: updated.senderId,
+      conversationId: updated.conversationId,
+      status: updated.status,
+      createdAt: updated.createdAt,
+      sender: senderInfo,
+      mentionedUserIds: [],
+      meta: updated.meta ?? {},
+      attachments: updated.attachments.map((attachment) => ({
+        id: attachment.id,
+        attachmentId: attachment.id,
+        name: attachment.name,
+        type: attachment.type,
+        size: attachment.size,
+        path: attachment.path,
+      })),
+    });
+  } catch (error) {
+    logger.error('Failed to broadcast completed AI message:', {
+      error,
+      messageId,
+    });
+  }
+
+  return {
+    id: updated.id,
+    content: updated.content,
+    conversationId: updated.conversationId,
+    createdAt: updated.createdAt,
+    status: (updated.status ?? JobStatus.COMPLETED) as JobStatus,
+  };
+}
+
+/**
+ * Flip a PENDING AI message to FAILED and broadcast the status change.
+ * Does NOT throw — failure paths in the pipelines call this in catch blocks
+ * and we do not want broadcast/DB errors to mask the original error.
+ */
+export async function failPendingAIMessage(
+  messageId: string,
+  options: { reason?: string } = {},
+): Promise<void> {
+  try {
+    const updated = await prisma.message.update({
+      where: { id: messageId },
+      data: { status: JobStatus.FAILED },
+      select: { id: true, conversationId: true, status: true },
+    });
+
+    logger.info('AI message marked as failed', {
+      messageId: updated.id,
+      conversationId: updated.conversationId,
+      reason: options.reason,
+    });
+
+    try {
+      await pusher.trigger(chatChannel(updated.conversationId), 'message-updated', {
+        id: updated.id,
+        conversationId: updated.conversationId,
+        status: updated.status,
+      });
+    } catch (broadcastError) {
+      logger.error('Failed to broadcast failed AI message:', {
+        error: broadcastError,
+        messageId,
+      });
+    }
+  } catch (error) {
+    logger.error('Failed to mark AI message as failed:', {
+      error,
+      messageId,
+      reason: options.reason,
+    });
+  }
+}
+
 /** Responses API user parts use `type: "input_*"`; chat completions use `text` / `image_url` / etc. */
 function isResponseInputWithInputParts(
   content: OpenAI.Chat.Completions.ChatCompletionMessageParam[] | ResponseInput

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();