@studious-lms/server 1.15.0 → 1.16.0

package/src/services/openaiDocumentGen.ts

@@ -8,34 +8,10 @@ import { logger } from '../utils/logger.js';
 
 const DOCUMENT_GEN_MODEL = 'gpt-4o-mini';
 
-/**
- * Extensions OpenAI Code Interpreter can read/write in its sandbox.
- * @see https://developers.openai.com/api/docs/guides/tools-code-interpreter
- */
 export const SUPPORTED_DOCUMENT_FORMATS = [
-  'pdf',
-  'docx',
-  'doc',
-  'xlsx',
-  'pptx',
-  'csv',
-  'md',
-  'html',
-  'txt',
-  'json',
-  'xml',
-  'tex',
-  'png',
-  'jpeg',
-  'jpg',
-  'gif',
-  'zip',
-  'tar',
-  'py',
-  'js',
-  'ts',
-  'css',
-  'sh',
+  'pdf', 'docx', 'doc', 'xlsx', 'pptx', 'csv', 'md', 'html', 'txt', 'json',
+  'xml', 'tex', 'png', 'jpeg', 'jpg', 'gif', 'zip', 'tar', 'py', 'js', 'ts',
+  'css', 'sh',
 ] as const;
 
 export type DocumentFormat = (typeof SUPPORTED_DOCUMENT_FORMATS)[number];
@@ -67,36 +43,34 @@ const FORMAT_MIME: Record<DocumentFormat, string> = {
 };
 
 const FORMAT_HINTS: Record<DocumentFormat, string> = {
-  pdf: 'fpdf2 or reportlab — structured document with headings and body text',
-  docx: 'python-docx — Word document with headings and paragraphs',
-  doc: 'python-docx saving as .doc if supported, otherwise .docx',
-  xlsx: 'openpyxl or pandas — spreadsheet with labelled columns/rows',
-  pptx: 'python-pptx — slides with title + bullet content per slide',
-  csv: 'pandas or csv module — tabular data with headers',
-  md: 'write the markdown file directly',
-  html: 'write a complete, styled HTML page',
-  txt: 'write plain text with clear section breaks',
-  json: 'json.dumps with readable indentation',
-  xml: 'well-formed XML document',
-  tex: 'LaTeX source that compiles to the requested content',
-  png: 'matplotlib or Pillow — chart, diagram, or visual',
-  jpeg: 'matplotlib or Pillow — save as JPEG',
-  jpg: 'matplotlib or Pillow — save as JPEG',
-  gif: 'matplotlib or Pillow — save as GIF',
-  zip: 'zipfile — bundle multiple related files if needed',
-  tar: 'tarfile — archive if multiple files are required',
-  py: 'valid Python source code file',
-  js: 'valid JavaScript source file',
-  ts: 'valid TypeScript source file',
-  css: 'stylesheet file',
-  sh: 'shell script file',
+  pdf: 'fpdf2 or reportlab',
+  docx: 'python-docx',
+  doc: 'python-docx',
+  xlsx: 'openpyxl or pandas',
+  pptx: 'python-pptx',
+  csv: 'pandas or csv module',
+  md: 'write markdown directly',
+  html: 'write a complete HTML page',
+  txt: 'write plain text',
+  json: 'json.dumps with indentation',
+  xml: 'well-formed XML',
+  tex: 'LaTeX source',
+  png: 'matplotlib or Pillow',
+  jpeg: 'matplotlib or Pillow',
+  jpg: 'matplotlib or Pillow',
+  gif: 'matplotlib or Pillow',
+  zip: 'zipfile',
+  tar: 'tarfile',
+  py: 'Python source',
+  js: 'JavaScript source',
+  ts: 'TypeScript source',
+  css: 'CSS stylesheet',
+  sh: 'shell script',
 };
 
 export interface GenerateDocumentInput {
   title: string;
-  /** Markdown or plain-text source material for the output file. */
   content: string;
-  /** Output format. Defaults to pdf. */
   format?: DocumentFormat | string;
 }
 
@@ -113,9 +87,7 @@ export interface ContainerGeneratedFile {
   filename: string;
 }
 
-export function normalizeDocumentFormat(
-  format?: string | null,
-): DocumentFormat {
+export function normalizeDocumentFormat(format?: string | null): DocumentFormat {
   const raw = (format ?? 'pdf').toLowerCase().replace(/^\./, '');
   if ((SUPPORTED_DOCUMENT_FORMATS as readonly string[]).includes(raw)) {
     return raw as DocumentFormat;
@@ -127,25 +99,13 @@ export function mimeTypeForFormat(format: DocumentFormat): string {
   return FORMAT_MIME[format];
 }
 
-export function extensionForFormat(format: DocumentFormat): string {
-  return format === 'jpg' ? 'jpg' : format;
-}
-
-/** Pull generated-file citations for a given extension out of a Responses output. */
 export function extractContainerGeneratedFiles(
   response: Response,
   extension: DocumentFormat,
 ): ContainerGeneratedFile[] {
+  const suffix = `.${extension}`;
   const seen = new Set<string>();
   const files: ContainerGeneratedFile[] = [];
-  const suffix = `.${extension}`;
-
-  const add = (containerId: string, fileId: string, filename: string) => {
-    const key = `${containerId}:${fileId}`;
-    if (seen.has(key)) return;
-    seen.add(key);
-    files.push({ containerId, fileId, filename });
-  };
 
   for (const item of response.output ?? []) {
     if (item.type !== 'message') continue;
@@ -154,13 +114,18 @@ export function extractContainerGeneratedFiles(
       for (const ann of block.annotations ?? []) {
         if (ann.type !== 'container_file_citation') continue;
         const name = ann.filename?.toLowerCase() ?? '';
-        if (name.endsWith(suffix)) {
-          add(ann.container_id, ann.file_id, ann.filename);
-        }
+        if (!name.endsWith(suffix)) continue;
+        const key = `${ann.container_id}:${ann.file_id}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        files.push({
+          containerId: ann.container_id,
+          fileId: ann.file_id,
+          filename: ann.filename,
+        });
       }
     }
   }
-
   return files;
 }
 
@@ -193,46 +158,13 @@ async function listContainerGeneratedFiles(
   return files;
 }
 
-async function downloadContainerFile(
-  client: OpenAI,
-  file: ContainerGeneratedFile,
-): Promise<Buffer | null> {
-  try {
-    const res = await client.containers.files.content.retrieve(file.fileId, {
-      container_id: file.containerId,
-    });
-    const bytes = await res.arrayBuffer();
-    return Buffer.from(bytes);
-  } catch (error) {
-    logger.error('Failed to download container file', { error, file });
-    return null;
-  }
-}
-
 function safeBasename(title: string): string {
-  const base = title
-    .replace(/[^a-zA-Z0-9\s\-_]/g, '')
-    .replace(/\s+/g, '_')
-    .substring(0, 60);
-  return base || 'document';
-}
-
-function buildDocumentGenInstructions(format: DocumentFormat): string {
-  return [
-    'You are a document generator for K-12 and university teachers.',
-    'When given a title, output format, and source content:',
-    '1. Use the python tool to create exactly ONE output file of the requested type.',
-    `2. For this format use: ${FORMAT_HINTS[format]}.`,
-    `3. You MUST output a ${format.toUpperCase()} file — not any other format.`,
-    `4. The saved filename MUST end with .${extensionForFormat(format)}.`,
-    '5. Structure content clearly — headings, sections, lists, tables/charts as appropriate.',
-    '6. Include the document title prominently where the format allows.',
-    '7. Put ONLY the educational content in the file — no meta commentary.',
-    '8. You MUST save the file to disk in the working directory before you finish.',
-    ...(format !== 'pdf'
-      ? [`9. Do NOT create a PDF when ${format.toUpperCase()} was requested.`]
-      : []),
-  ].join(' ');
+  return (
+    title
+      .replace(/[^a-zA-Z0-9\s\-_]/g, '')
+      .replace(/\s+/g, '_')
+      .substring(0, 60) || 'document'
+  );
 }
 
 /** Generate a file via OpenAI Code Interpreter. */
@@ -241,32 +173,33 @@ export async function generateDocumentWithOpenAI(
 ): Promise<GeneratedDocumentResult | null> {
   const client = new OpenAI();
   const format = normalizeDocumentFormat(input.format);
-  const ext = extensionForFormat(format);
+  const ext = format === 'jpg' ? 'jpg' : format;
   const filename = `${safeBasename(input.title)}.${ext}`;
 
   try {
     const response = await client.responses.create({
       model: DOCUMENT_GEN_MODEL,
-      instructions: buildDocumentGenInstructions(format),
-      tools: [
-        {
-          type: 'code_interpreter',
-          container: { type: 'auto' },
-        },
-      ],
+      instructions: [
+        'You generate classroom-ready files for teachers using the python tool.',
+        `You MUST output a ${ext.toUpperCase()} file — not any other format.`,
+        `Use: ${FORMAT_HINTS[format]}.`,
+        `The saved filename MUST end with .${ext}.`,
+        'Save exactly one output file with the requested filename.',
+        'Include only educational content — no chat commentary.',
+        ...(format !== 'pdf' ? [`Do NOT create a PDF when ${ext.toUpperCase()} was requested.`] : []),
+      ].join(' '),
+      tools: [{ type: 'code_interpreter', container: { type: 'auto' } }],
       tool_choice: 'required',
       input: [
-        `Create a ${ext.toUpperCase()} file using the python tool.`,
-        `Output filename (exact): ${filename}`,
-        `Output format: ${ext}`,
-        `Document title: ${input.title}`,
-        'Source content (markdown or plain text — adapt to the output format):',
+        `Create a ${ext.toUpperCase()} file.`,
+        `Filename (exact): ${filename}`,
+        `Title: ${input.title}`,
+        'Content:',
         input.content,
       ].join('\n\n'),
     });
 
     let matches = extractContainerGeneratedFiles(response, format);
-
     if (matches.length === 0) {
       const containerId = containerIdFromResponse(response);
       if (containerId) {
@@ -275,10 +208,9 @@ export async function generateDocumentWithOpenAI(
     }
 
     if (matches.length === 0) {
-      logger.error('OpenAI document gen produced no matching files', {
+      logger.error('OpenAI document gen: no output file', {
         title: input.title,
         format,
-        outputTypes: (response.output ?? []).map((o) => o.type),
       });
       return null;
     }
@@ -287,8 +219,10 @@ export async function generateDocumentWithOpenAI(
       matches.find((f) => f.filename.toLowerCase() === filename.toLowerCase()) ??
       matches[0];
 
-    const bytes = await downloadContainerFile(client, preferred);
-    if (!bytes) return null;
+    const res = await client.containers.files.content.retrieve(preferred.fileId, {
+      container_id: preferred.containerId,
+    });
+    const bytes = Buffer.from(await res.arrayBuffer());
 
     return {
       bytes,
@@ -297,23 +231,7 @@ export async function generateDocumentWithOpenAI(
       format,
     };
   } catch (error) {
-    logger.error('OpenAI document generation failed', {
-      error,
-      title: input.title,
-      format,
-    });
+    logger.error('OpenAI document generation failed', { error, title: input.title, format });
     return null;
   }
 }
-
-/** @deprecated Use {@link generateDocumentWithOpenAI} */
-export async function generatePdfWithOpenAI(
-  input: Omit<GenerateDocumentInput, 'format'>,
-): Promise<Buffer | null> {
-  const result = await generateDocumentWithOpenAI({ ...input, format: 'pdf' });
-  return result?.bytes ?? null;
-}
-
-/** @deprecated Use {@link extractContainerGeneratedFiles} */
-export const extractContainerPdfFiles = (response: Response) =>
-  extractContainerGeneratedFiles(response, 'pdf');

package/src/utils/email.ts

@@ -27,11 +27,7 @@ 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,
-      from,
-      subject,
-    });
+    logger.info(`Email dry run enabled. Would have sent email to ${to} from ${from} with subject ${subject} and text ${text}`);
     return;
   }
   

package/tests/integration/globalSetup.ts

@@ -10,7 +10,6 @@ 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({
@@ -21,17 +20,26 @@ async function runSetup() {
 
   execSync('npm run test:pre');
 
-  const user1 = await caller.auth.register(
-    registerInput({ username: 'testuser1', email: 'test@studious.sh' }),
-  );
+  const user1 = await caller.auth.register({
+    username: 'testuser1',
+    email: 'test@studious.sh',
+    password: 'password_is_1234',
+    confirmPassword: 'password_is_1234',
+  });
 
-  const user2 = await caller.auth.register(
-    registerInput({ username: 'testuser2', email: 'test2@studious.sh' }),
-  );
+  const user2 = await caller.auth.register({
+    username: 'testuser2',
+    email: 'test2@studious.sh',
+    password: 'password_is_1234',
+    confirmPassword: 'password_is_1234',
+  });
 
-  const user3 = await caller.auth.register(
-    registerInput({ username: 'testuser3', email: 'test3@studious.sh' }),
-  );
+  const user3 = await caller.auth.register({
+    username: 'testuser3',
+    email: 'test3@studious.sh',
+    password: 'password_is_1234',
+    confirmPassword: 'password_is_1234',
+  });
 
   const session1 = await prisma.session.findFirst({
     where: { userId: user1.user.id, type: SessionType.EMAIL_VERIFICATION },

package/tests/integration/routers/auth.test.ts

@@ -6,7 +6,6 @@ import { test, expect, describe } from 'vitest';
 import { appRouter } from '../../../src/routers/_app';
 import { createTRPCContext } from '../../../src/trpc';
 import { prisma } from '../../../src/lib/prisma';
-import { registerInput } from '../../helpers/registerInput.js';
 import {
   caller,
   login1,
@@ -65,9 +64,12 @@ describe('Auth Router', () => {
   test('check fails when unauthenticated', () => expectUnauth((c) => c.auth.check()));
 
   test('resendVerificationEmail succeeds for existing user', async () => {
-    await caller.auth.register(
-      registerInput({ username: 'resendtest', email: 'resend@studious.sh' }),
-    );
+    await caller.auth.register({
+      username: 'resendtest',
+      email: 'resend@studious.sh',
+      password: 'password_is_1234',
+      confirmPassword: 'password_is_1234',
+    });
     const result = await caller.auth.resendVerificationEmail({
       email: 'resend@studious.sh',
     });
@@ -225,20 +227,23 @@ describe('Auth Router', () => {
 
   test('register fails when username already exists', async () => {
     await expect(
-      caller.auth.register(
-        registerInput({
-          username: 'testuser1',
-          email: 'newemail@studious.sh',
-        }),
-      )
+      caller.auth.register({
+        username: 'testuser1',
+        email: 'newemail@studious.sh',
+        password: 'password_is_1234',
+        confirmPassword: 'password_is_1234',
+      })
     ).rejects.toThrow();
   });
 
   test('register fails when email already exists', async () => {
     await expect(
-      caller.auth.register(
-        registerInput({ username: 'newuser', email: 'test@studious.sh' }),
-      )
+      caller.auth.register({
+        username: 'newuser',
+        email: 'test@studious.sh',
+        password: 'password_is_1234',
+        confirmPassword: 'password_is_1234',
+      })
     ).rejects.toThrow();
   });
 

package/dist/lib/legal.d.ts

@@ -1,3 +0,0 @@
-/** Must match the "Last updated" month in the client privacy/terms copy. */
-export declare const CURRENT_TERMS_VERSION = "2025-11";
-//# sourceMappingURL=legal.d.ts.map

package/dist/lib/legal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"legal.d.ts","sourceRoot":"/","sources":["lib/legal.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,eAAO,MAAM,qBAAqB,YAAY,CAAC"}

package/dist/lib/legal.js

@@ -1,6 +0,0 @@
-/** Must match the "Last updated" month in the client privacy/terms copy. */
-
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="ad0b3a8e-96d8-5634-84c5-fec20e40859b")}catch(e){}}();
-export const CURRENT_TERMS_VERSION = "2025-11";
-//# sourceMappingURL=legal.js.map
-//# debugId=ad0b3a8e-96d8-5634-84c5-fec20e40859b

package/dist/lib/legal.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"legal.js","sources":["lib/legal.ts"],"sourceRoot":"/","sourcesContent":["/** Must match the \"Last updated\" month in the client privacy/terms copy. */\nexport const CURRENT_TERMS_VERSION = \"2025-11\";\n"],"names":[],"mappings":"AAAA,4EAA4E;;;AAC5E,MAAM,CAAC,MAAM,qBAAqB,GAAG,SAAS,CAAC","debug_id":"ad0b3a8e-96d8-5634-84c5-fec20e40859b"}

package/dist/services/userPrivacy.d.ts

@@ -1,86 +0,0 @@
-/** Export a portable snapshot of the authenticated user's personal data. */
-export declare function exportUserData(userId: string): Promise<{
-    exportedAt: string;
-    user: {
-        id: string;
-        username: string;
-        email: string;
-        verified: boolean;
-        termsAcceptedAt: Date | null;
-        termsVersion: string | null;
-        profile: {
-            id: string;
-            userId: string;
-            displayName: string | null;
-            bio: string | null;
-            location: string | null;
-            website: string | null;
-            createdAt: Date;
-            updatedAt: Date;
-            profilePicture: string | null;
-            profilePictureThumbnail: string | null;
-        } | null;
-        teacherIn: {
-            section: string;
-            id: string;
-            name: string;
-            subject: string;
-        }[];
-        studentIn: {
-            section: string;
-            id: string;
-            name: string;
-            subject: string;
-        }[];
-        submissions: {
-            assignment: {
-                id: string;
-                classId: string;
-                title: string;
-            };
-            id: string;
-            createdAt: Date;
-            extendedResponse: string | null;
-            gradeReceived: number | null;
-            submittedAt: Date | null;
-        }[];
-        events: {
-            id: string;
-            location: string | null;
-            name: string | null;
-            startTime: Date;
-            endTime: Date;
-            remarks: string | null;
-        }[];
-        notificationsReceived: {
-            id: string;
-            createdAt: Date;
-            title: string;
-            content: string;
-            read: boolean;
-        }[];
-        schoolMemberships: {
-            status: import(".prisma/client").$Enums.SchoolMembershipStatus;
-            school: {
-                id: string;
-                name: string;
-            };
-            role: import(".prisma/client").$Enums.SchoolMembershipRole;
-        }[];
-        sentMessages: {
-            id: string;
-            createdAt: Date;
-            content: string;
-            conversationId: string;
-        }[];
-    };
-}>;
-/**
- * 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 declare function deleteUserAccount(userId: string): Promise<{
-    success: boolean;
-}>;
-//# sourceMappingURL=userPrivacy.d.ts.map

package/dist/services/userPrivacy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"userPrivacy.d.ts","sourceRoot":"/","sources":["services/userPrivacy.ts"],"names":[],"mappings":"AA6DA,4EAA4E;AAC5E,wBAAsB,cAAc,CAAC,MAAM,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4ElD;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,MAAM;;GAkDrD"}