@studious-lms/server 1.2.53 → 1.4.0

package/src/index.ts

@@ -11,6 +11,8 @@ import { logger } from './utils/logger.js';
 import { setupSocketHandlers } from './socket/handlers.js';
 import { bucket } from './lib/googleCloudStorage.js';
 import { prisma } from './lib/prisma.js';
+import { pusher } from './lib/pusher.js';
+import { connectRedis, disconnectRedis } from './lib/redis.js';
 
 import { authLimiter, generalLimiter, helmetConfig, uploadLimiter } from './middleware/security.js';
 
@@ -27,6 +29,8 @@ const app = express();
 
 app.use(helmetConfig);
 app.use(compression());
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
 
 app.use((req, res, next) => {
   const requestId = uuidv4();
@@ -38,6 +42,8 @@ const allowedOrigins = env.NODE_ENV === 'production'
 ? [
     'https://www.studious.sh',
     'https://studious.sh',
+    'https://dev.studious.sh',
+    'https://www.dev.studious.sh',
     env.NEXT_PUBLIC_APP_URL,
     'http://localhost:3000',
 
@@ -137,6 +143,103 @@ app.get('/health', async (req, res) => {
   }
 });
 
+// Pusher channel auth (for private-* and presence-* channels)
+// Token from: x-user header, or cookie (same-origin requests send cookies automatically)
+app.post('/api/pusher/auth', async (req, res) => {
+  try {
+    let token = req.headers['x-user'] as string | undefined;
+    if (!token && req.headers.cookie) {
+      const cookieName = env.PUSHER_AUTH_COOKIE_NAME || 'token';
+      const match = req.headers.cookie.match(new RegExp(`${cookieName}=([^;]+)`));
+      token = match?.[1]?.trim();
+    }
+    const { socket_id, channel_name } = req.body as { socket_id?: string; channel_name?: string };
+
+    if (!socket_id || !channel_name) {
+      return res.status(400).json({ error: 'socket_id and channel_name required' });
+    }
+
+    if (!token) {
+      return res.status(401).json({ error: 'Authentication required' });
+    }
+
+    const user = await prisma.user.findFirst({
+      where: { sessions: { some: { id: token } } },
+      select: { id: true, username: true },
+    });
+
+    if (!user) {
+      return res.status(401).json({ error: 'Invalid or expired session' });
+    }
+
+    // Verify channel access for private-conversation-* channels
+    if (channel_name.startsWith('private-conversation-')) {
+      const conversationId = channel_name.replace('private-conversation-', '');
+      const member = await prisma.conversationMember.findFirst({
+        where: { conversationId, userId: user.id },
+      });
+      
+      if (!member) {
+        return res.status(403).json({ error: 'Not a member of this conversation' });
+      }
+    }
+
+    if (channel_name.startsWith('private-worksheet-')) {
+      const worksheetId = channel_name.replace('private-worksheet-', '');
+      const worksheet = await prisma.studentWorksheetResponse.findFirst({
+        where: { id: worksheetId, OR: [
+          { studentId: user.id },
+          { submission: { assignment: { class: { teachers: { some: { id: user.id } } } } } },
+        ] },
+      });
+      if (!worksheet) {
+        return res.status(403).json({ error: 'No access to this worksheet' });
+      }
+    }
+
+    if (channel_name.startsWith('private-teacher-')) {
+      const classId = channel_name.replace('private-teacher-', '');
+      const isTeacher = await prisma.class.findFirst({
+        where: { id: classId, teachers: { some: { id: user.id } } },
+      });
+      if (!isTeacher) {
+        return res.status(403).json({ error: 'Not a teacher of this class' });
+      }
+    }
+
+    // Verify channel access for private-class-* channels
+    // if (channel_name.startsWith('private-class-')) {
+    //   const classId = channel_name.replace('private-class-', '');
+    //   const isMember = await prisma.class.findFirst({
+    //     where: {
+    //       id: classId,
+    //       OR: [
+    //         { students: { some: { id: user.id } } },
+    //         { teachers: { some: { id: user.id } } },
+    //       ],
+    //     },
+    //   });
+    //   if (!isMember) {
+    //     return res.status(403).json({ error: 'Not a member of this class' });
+    //   }
+    // }
+
+    if (channel_name.startsWith('presence-')) {
+      const authResponse = pusher.authorizeChannel(socket_id, channel_name, {
+        user_id: user.id,
+        user_info: { username: user.username },
+      });
+      return res.json(authResponse);
+    }
+
+    const authResponse = pusher.authorizeChannel(socket_id, channel_name);
+    return res.json(authResponse);
+  } catch (error) {
+    logger.error('Pusher auth error', { error });
+    return res.status(500).json({ error: 'Authentication failed' });
+  }
+});
+
 // Setup Socket.IO
 const io = new Server(httpServer, {
   cors: {
@@ -472,10 +575,12 @@ Sentry.setupExpressErrorHandler(app);
 
 const PORT = env.PORT || 3001;
 
-httpServer.listen(PORT, () => {
-  logger.info(`Server running on port ${PORT}`, { 
-    port: PORT,
-    services: ['tRPC', 'Socket.IO']
+connectRedis().then(() => {
+  httpServer.listen(PORT, () => {
+    logger.info(`Server running on port ${PORT}`, {
+      port: PORT,
+      services: ['tRPC', 'Socket.IO', env.REDIS_URL ? 'Redis' : null].filter(Boolean),
+    });
   });
 }); 
 
@@ -506,14 +611,16 @@ const gracefulShutdown = (signal: string) => {
     
     io.close(() => {
       logger.info('Socket.IO server closed');
-      
-      prisma.$disconnect().then(() => {
-        logger.info('Database connections closed');
-        process.exit(0);
-      }).catch((err) => {
-        logger.error('Error disconnecting from database', { error: err });
-        process.exit(1);
-      });
+
+      disconnectRedis().then(() =>
+        prisma.$disconnect().then(() => {
+          logger.info('Database connections closed');
+          process.exit(0);
+        }).catch((err) => {
+          logger.error('Error disconnecting from database', { error: err });
+          process.exit(1);
+        })
+      );
     });
   });
   

package/src/lib/config/env.ts

@@ -36,6 +36,7 @@ const fullSchema = baseSchema.extend({
   BACKEND_URL: z.string().url().default('http://localhost:3001'),
   SENTRY_DSN: z.string().url().optional(),
   EMAIL_HOST: z.string().min(1, 'EMAIL_HOST is required'),
+  EMAIL_PORT: z.string().transform(Number).default('587'),
   EMAIL_USER: z.string().email('EMAIL_USER must be a valid email'),
   EMAIL_PASS: z.string().min(1, 'EMAIL_PASS is required'),
   EMAIL_DRY_RUN: z.string().optional().default('false'),
@@ -47,6 +48,8 @@ const fullSchema = baseSchema.extend({
   PUSHER_KEY: z.string().min(1, 'PUSHER_KEY is required'),
   PUSHER_SECRET: z.string().min(1, 'PUSHER_SECRET is required'),
   PUSHER_CLUSTER: z.string().min(1, 'PUSHER_CLUSTER is required'),
+  PUSHER_AUTH_COOKIE_NAME: z.string().optional(), // Cookie name for session token (default: 'token')
+  REDIS_URL: z.string().url().optional(), // Redis connection URL (e.g. redis://localhost:6379)
   INFERENCE_API_KEY: z.string().optional(),
   INFERENCE_API_BASE_URL: z.string().url().optional(),
   OPENAI_API_KEY: z.string().optional(),
@@ -59,6 +62,7 @@ const testSchema = baseSchema.extend({
   BACKEND_URL: z.string().url().optional().default('http://localhost:3001'),
   SENTRY_DSN: z.string().url().optional(),
   EMAIL_HOST: z.string().optional().default('smtp.test.com'),
+  EMAIL_PORT: z.string().transform(Number).default('587'),
   EMAIL_USER: z.string().email().optional().default('test@test.com'),
   EMAIL_PASS: z.string().optional().default('test'),
   EMAIL_DRY_RUN: z.string().optional().default('false'),
@@ -70,6 +74,8 @@ const testSchema = baseSchema.extend({
   PUSHER_KEY: z.string().optional().default('test-key'),
   PUSHER_SECRET: z.string().optional().default('test-secret'),
   PUSHER_CLUSTER: z.string().optional().default('us2'),
+  PUSHER_AUTH_COOKIE_NAME: z.string().optional(),
+  REDIS_URL: z.string().url().optional(),
   INFERENCE_API_KEY: z.string().optional(),
   OPENAI_API_KEY: z.string().optional(),
   INFERENCE_API_BASE_URL: z.string().url().optional(),

package/src/lib/fileUpload.ts

@@ -1,7 +1,6 @@
 import { TRPCError } from "@trpc/server";
 import { v4 as uuidv4 } from "uuid";
 import { getSignedUrl, objectExists } from "./googleCloudStorage.js";
-import { generateMediaThumbnail } from "./thumbnailGenerator.js";
 import { prisma } from "./prisma.js";
 import { logger } from "../utils/logger.js";
 import { env } from "./config/env.js";

package/src/lib/googleCloudStorage.ts

@@ -81,4 +81,21 @@ export async function objectExists(bucketName: string, objectPath: string): Prom
       message: 'Failed to check object existence',
     });
   }
+}
+
+/**
+ * Copies a file within the same bucket to a new path
+ * @param sourcePath The GCS path of the source file
+ * @param destPath The GCS path for the destination
+ */
+export async function copyFile(sourcePath: string, destPath: string): Promise<void> {
+  try {
+    await bucket.file(sourcePath).copy(destPath);
+  } catch (error) {
+    console.error('Error copying file in Google Cloud Storage:', error);
+    throw new TRPCError({
+      code: 'INTERNAL_SERVER_ERROR',
+      message: 'Failed to copy file in storage',
+    });
+  }
 } 

package/src/lib/pusher.ts

@@ -9,4 +9,8 @@ const pusher = new Pusher({
   useTLS: env.NODE_ENV !== 'development',
 });
 
-export { pusher };
+const chatChannel = (conversationId: string) => `private-conversation-${conversationId}`;
+const worksheetChannel = (worksheetResponseId: string) => `private-worksheet-${worksheetResponseId}`;
+const teacherChannel = (classId: string) => `private-teacher-${classId}`;
+
+export { pusher, chatChannel, worksheetChannel, teacherChannel };

package/src/lib/redis.ts

@@ -0,0 +1,56 @@
+import Redis from 'ioredis';
+import { env } from './config/env.js';
+import { logger } from '../utils/logger.js';
+
+let redis: Redis | null = null;
+
+export function getRedis(): Redis | null {
+  return redis;
+}
+
+export async function connectRedis(): Promise<Redis | null> {
+  const url = env.REDIS_URL;
+  if (!url) {
+    logger.info('Redis not configured (REDIS_URL not set), skipping');
+    return null;
+  }
+
+  if (redis) {
+    return redis;
+  }
+
+  redis = new Redis(url, {
+    maxRetriesPerRequest: 3,
+    retryStrategy(times) {
+      if (times > 3) return null;
+      return Math.min(times * 200, 2000);
+    },
+  });
+
+  redis.on('error', (err) => {
+    logger.error('Redis connection error', { error: err.message });
+  });
+
+  redis.on('connect', () => {
+    logger.info('Redis connected');
+  });
+
+  try {
+    await redis.ping();
+    logger.info('Redis ready');
+    return redis;
+  } catch (error) {
+    logger.error('Redis ping failed', { error });
+    redis.disconnect();
+    redis = null;
+    return null;
+  }
+}
+
+export async function disconnectRedis(): Promise<void> {
+  if (redis) {
+    await redis.quit();
+    redis = null;
+    logger.info('Redis disconnected');
+  }
+}

package/src/lib/thumbnailGenerator.ts

@@ -1,170 +1,172 @@
-import sharp from 'sharp';
-import { prisma } from './prisma.js';
-import { deleteFile, getSignedUrl } from './googleCloudStorage.js';
-
-// Thumbnail size configuration
-const THUMBNAIL_WIDTH = 200;
-const THUMBNAIL_HEIGHT = 200;
-
-// File type configurations
-const SUPPORTED_IMAGE_TYPES = [
-    'image/jpeg',
-    'image/png',
-    'image/gif',
-    'image/webp',
-    'image/tiff',
-    'image/bmp',
-    'image/avif'
-];
-
-const DOCUMENT_TYPES = [
-    'application/pdf',
-    'application/msword',
-    'application/vnd.openxmlformats-officedocument.wordprocessingml.document', // .docx
-    'application/vnd.ms-excel',
-    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', // .xlsx
-    'application/vnd.ms-powerpoint',
-    'application/vnd.openxmlformats-officedocument.presentationml.presentation', // .pptx
-    'text/plain',
-    'text/csv',
-    'application/json',
-    'text/html',
-    'text/javascript',
-    'text/css'
-];
-
-const VIDEO_TYPES = [
-    'video/mp4',
-    'video/webm',
-    'video/ogg',
-    'video/quicktime'
-];
-
-const AUDIO_TYPES = [
-    'audio/mpeg',
-    'audio/ogg',
-    'audio/wav',
-    'audio/webm'
-];
-
-/**
- * Generates a thumbnail for an image or PDF file
- * @param fileBuffer The file buffer
- * @param fileType The MIME type of the file
- * @returns Thumbnail buffer
- */
-export async function generateMediaThumbnail(fileBuffer: Buffer, fileType: string): Promise<Buffer> {
-    if (fileType === 'application/pdf') {
-        // For PDFs, we need to use a different approach
-        try {
-            return await sharp(fileBuffer, { 
-                density: 300, // Higher density for better quality
-                page: 0 // First page only
-            })
-            .resize(THUMBNAIL_WIDTH, THUMBNAIL_HEIGHT, {
-                fit: 'inside',
-                withoutEnlargement: true,
-            })
-            .jpeg({ quality: 80 })
-            .toBuffer();
-        } catch (error) {
-            console.warn('Failed to generate PDF thumbnail:', error);
-            return generateGenericThumbnail(fileType);
-        }
-    }
+// @deprecated: this is not used anymore
+
+// import sharp from 'sharp';
+// import { prisma } from './prisma.js';
+// import { deleteFile, getSignedUrl } from './googleCloudStorage.js';
+
+// // Thumbnail size configuration
+// const THUMBNAIL_WIDTH = 200;
+// const THUMBNAIL_HEIGHT = 200;
+
+// // File type configurations
+// const SUPPORTED_IMAGE_TYPES = [
+//     'image/jpeg',
+//     'image/png',
+//     'image/gif',
+//     'image/webp',
+//     'image/tiff',
+//     'image/bmp',
+//     'image/avif'
+// ];
+
+// const DOCUMENT_TYPES = [
+//     'application/pdf',
+//     'application/msword',
+//     'application/vnd.openxmlformats-officedocument.wordprocessingml.document', // .docx
+//     'application/vnd.ms-excel',
+//     'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', // .xlsx
+//     'application/vnd.ms-powerpoint',
+//     'application/vnd.openxmlformats-officedocument.presentationml.presentation', // .pptx
+//     'text/plain',
+//     'text/csv',
+//     'application/json',
+//     'text/html',
+//     'text/javascript',
+//     'text/css'
+// ];
+
+// const VIDEO_TYPES = [
+//     'video/mp4',
+//     'video/webm',
+//     'video/ogg',
+//     'video/quicktime'
+// ];
+
+// const AUDIO_TYPES = [
+//     'audio/mpeg',
+//     'audio/ogg',
+//     'audio/wav',
+//     'audio/webm'
+// ];
+
+// /**
+//  * Generates a thumbnail for an image or PDF file
+//  * @param fileBuffer The file buffer
+//  * @param fileType The MIME type of the file
+//  * @returns Thumbnail buffer
+//  */
+// export async function generateMediaThumbnail(fileBuffer: Buffer, fileType: string): Promise<Buffer> {
+//     if (fileType === 'application/pdf') {
+//         // For PDFs, we need to use a different approach
+//         try {
+//             return await sharp(fileBuffer, { 
+//                 density: 300, // Higher density for better quality
+//                 page: 0 // First page only
+//             })
+//             .resize(THUMBNAIL_WIDTH, THUMBNAIL_HEIGHT, {
+//                 fit: 'inside',
+//                 withoutEnlargement: true,
+//             })
+//             .jpeg({ quality: 80 })
+//             .toBuffer();
+//         } catch (error) {
+//             console.warn('Failed to generate PDF thumbnail:', error);
+//             return generateGenericThumbnail(fileType);
+//         }
+//     }
     
-    // For regular images
-    return sharp(fileBuffer)
-        .resize(THUMBNAIL_WIDTH, THUMBNAIL_HEIGHT, {
-            fit: 'inside',
-            withoutEnlargement: true,
-        })
-        .jpeg({ quality: 80 })
-        .toBuffer();
-}
-
-/**
- * Generates a generic icon-based thumbnail for a file type
- * @param fileType The MIME type of the file
- * @returns Thumbnail buffer
- */
-async function generateGenericThumbnail(fileType: string): Promise<Buffer> {
-    // Create a blank canvas with a colored background based on file type
-    const canvas = sharp({
-        create: {
-            width: THUMBNAIL_WIDTH,
-            height: THUMBNAIL_HEIGHT,
-            channels: 4,
-            background: { r: 245, g: 245, b: 245, alpha: 1 }
-        }
-    });
-
-    // Add a colored overlay based on file type
-    let color = { r: 200, g: 200, b: 200, alpha: 0.5 }; // Default gray
-
-    if (DOCUMENT_TYPES.includes(fileType)) {
-        color = { r: 52, g: 152, b: 219, alpha: 0.5 }; // Blue for documents
-    } else if (VIDEO_TYPES.includes(fileType)) {
-        color = { r: 231, g: 76, b: 60, alpha: 0.5 }; // Red for videos
-    } else if (AUDIO_TYPES.includes(fileType)) {
-        color = { r: 46, g: 204, b: 113, alpha: 0.5 }; // Green for audio
-    }
-
-    return canvas
-        .composite([{
-            input: Buffer.from([color.r, color.g, color.b, Math.floor(color.alpha * 255)]),
-            raw: {
-                width: 1,
-                height: 1,
-                channels: 4
-            },
-            tile: true,
-            blend: 'overlay'
-        }])
-        .jpeg({ quality: 80 })
-        .toBuffer();
-}
-
-/**
- * Generates a thumbnail for a file
- * @param fileName The name of the file in Google Cloud Storage
- * @param fileType The MIME type of the file
- * @returns The thumbnail buffer or null if thumbnail generation is not supported
- */
-export async function generateThumbnail(fileName: string, fileType: string): Promise<Buffer | null> {
-    try {
-        const signedUrl = await getSignedUrl(fileName);
-        const response = await fetch(signedUrl);
+//     // For regular images
+//     return sharp(fileBuffer)
+//         .resize(THUMBNAIL_WIDTH, THUMBNAIL_HEIGHT, {
+//             fit: 'inside',
+//             withoutEnlargement: true,
+//         })
+//         .jpeg({ quality: 80 })
+//         .toBuffer();
+// }
+
+// /**
+//  * Generates a generic icon-based thumbnail for a file type
+//  * @param fileType The MIME type of the file
+//  * @returns Thumbnail buffer
+//  */
+// async function generateGenericThumbnail(fileType: string): Promise<Buffer> {
+//     // Create a blank canvas with a colored background based on file type
+//     const canvas = sharp({
+//         create: {
+//             width: THUMBNAIL_WIDTH,
+//             height: THUMBNAIL_HEIGHT,
+//             channels: 4,
+//             background: { r: 245, g: 245, b: 245, alpha: 1 }
+//         }
+//     });
+
+//     // Add a colored overlay based on file type
+//     let color = { r: 200, g: 200, b: 200, alpha: 0.5 }; // Default gray
+
+//     if (DOCUMENT_TYPES.includes(fileType)) {
+//         color = { r: 52, g: 152, b: 219, alpha: 0.5 }; // Blue for documents
+//     } else if (VIDEO_TYPES.includes(fileType)) {
+//         color = { r: 231, g: 76, b: 60, alpha: 0.5 }; // Red for videos
+//     } else if (AUDIO_TYPES.includes(fileType)) {
+//         color = { r: 46, g: 204, b: 113, alpha: 0.5 }; // Green for audio
+//     }
+
+//     return canvas
+//         .composite([{
+//             input: Buffer.from([color.r, color.g, color.b, Math.floor(color.alpha * 255)]),
+//             raw: {
+//                 width: 1,
+//                 height: 1,
+//                 channels: 4
+//             },
+//             tile: true,
+//             blend: 'overlay'
+//         }])
+//         .jpeg({ quality: 80 })
+//         .toBuffer();
+// }
+
+// /**
+//  * Generates a thumbnail for a file
+//  * @param fileName The name of the file in Google Cloud Storage
+//  * @param fileType The MIME type of the file
+//  * @returns The thumbnail buffer or null if thumbnail generation is not supported
+//  */
+// export async function generateThumbnail(fileName: string, fileType: string): Promise<Buffer | null> {
+//     try {
+//         const signedUrl = await getSignedUrl(fileName);
+//         const response = await fetch(signedUrl);
         
-        if (!response.ok) {
-            throw new Error(`Failed to download file from storage: ${response.status} ${response.statusText}`);
-        }
-
-        const fileBuffer = await response.arrayBuffer();
-
-        if (SUPPORTED_IMAGE_TYPES.includes(fileType) || fileType === 'application/pdf') {
-            try {
-                const thumbnail = await generateMediaThumbnail(Buffer.from(fileBuffer), fileType);
-                return thumbnail;
-            } catch (error) {
-                return generateGenericThumbnail(fileType);
-            }
-        } else if ([...DOCUMENT_TYPES, ...VIDEO_TYPES, ...AUDIO_TYPES].includes(fileType)) {
-            return generateGenericThumbnail(fileType);
-        }
-
-        return null; // Unsupported file type
-    } catch (error) {
-        return null;
-    }
-}
-
-/**
- * Stores a thumbnail in Google Cloud Storage and creates a File entry
- * @param thumbnailBuffer The thumbnail buffer to store
- * @param originalFileName The original file name
- * @param userId The user ID who owns the file
- * @returns The ID of the created thumbnail File
- */
-// DEPRECATED: This function is no longer used - thumbnails are generated during direct uploads
-// Thumbnail generation is now handled in the direct upload flow 
+//         if (!response.ok) {
+//             throw new Error(`Failed to download file from storage: ${response.status} ${response.statusText}`);
+//         }
+
+//         const fileBuffer = await response.arrayBuffer();
+
+//         if (SUPPORTED_IMAGE_TYPES.includes(fileType) || fileType === 'application/pdf') {
+//             try {
+//                 const thumbnail = await generateMediaThumbnail(Buffer.from(fileBuffer), fileType);
+//                 return thumbnail;
+//             } catch (error) {
+//                 return generateGenericThumbnail(fileType);
+//             }
+//         } else if ([...DOCUMENT_TYPES, ...VIDEO_TYPES, ...AUDIO_TYPES].includes(fileType)) {
+//             return generateGenericThumbnail(fileType);
+//         }
+
+//         return null; // Unsupported file type
+//     } catch (error) {
+//         return null;
+//     }
+// }
+
+// /**
+//  * Stores a thumbnail in Google Cloud Storage and creates a File entry
+//  * @param thumbnailBuffer The thumbnail buffer to store
+//  * @param originalFileName The original file name
+//  * @param userId The user ID who owns the file
+//  * @returns The ID of the created thumbnail File
+//  */
+// // DEPRECATED: This function is no longer used - thumbnails are generated during direct uploads
+// // Thumbnail generation is now handled in the direct upload flow