@studious-lms/server 1.0.2 → 1.0.4

package/src/exportType.ts

@@ -0,0 +1,9 @@
+/**
+ * Export types for the server
+ * This is used to export the types for the server
+ * to the client via npmjs
+ */
+
+export type { AppRouter } from "./routers/_app";
+export type { RouterInputs } from "./routers/_app";
+export type { RouterOutputs } from "./routers/_app";

package/src/index.ts

@@ -0,0 +1,94 @@
+import express from 'express';
+import type { Request, Response } from 'express';
+import { createServer } from 'http';
+import { Server } from 'socket.io';
+import cors from 'cors';
+import dotenv from 'dotenv';
+import { createExpressMiddleware } from '@trpc/server/adapters/express';
+import { appRouter } from './routers/_app';
+import { createTRPCContext, createCallerFactory } from './trpc';
+import { logger } from './utils/logger';
+import { setupSocketHandlers } from './socket/handlers';
+
+dotenv.config();
+
+const app = express();
+
+// CORS middleware
+app.use(cors({
+  origin: process.env.NEXT_PUBLIC_APP_URL || 'http://localhost:3000',
+  credentials: true,
+}));
+
+// Response time logging middleware
+app.use((req, res, next) => {
+  const start = Date.now();
+  res.on('finish', () => {
+    const duration = Date.now() - start;
+    logger.info('Request completed', {
+      method: req.method,
+      path: req.path,
+      statusCode: res.statusCode,
+      duration: `${duration}ms`
+    });
+  });
+  next();
+});
+
+// Create HTTP server
+const httpServer = createServer(app);
+
+// Setup Socket.IO
+const io = new Server(httpServer, {
+  cors: {
+    origin: process.env.NEXT_PUBLIC_APP_URL || 'http://localhost:3000',
+    methods: ['GET', 'POST'],
+    credentials: true,
+    allowedHeaders: ['Access-Control-Allow-Origin']
+  },
+  transports: ['websocket', 'polling'],
+  pingTimeout: 60000,
+  pingInterval: 25000,
+  connectTimeout: 45000,
+  path: '/socket.io/',
+  allowEIO3: true
+});
+
+// Add server-level logging
+io.engine.on('connection_error', (err) => {
+  logger.error('Socket connection error', { error: err.message });
+});
+
+// Setup socket handlers
+setupSocketHandlers(io);
+
+// Create caller
+const createCaller = createCallerFactory(appRouter);
+
+// Setup tRPC middleware
+app.use(
+  '/trpc',
+  createExpressMiddleware({
+    router: appRouter,
+    createContext: async ({ req, res }: { req: Request; res: Response }) => {
+      return createTRPCContext({ req, res });
+    },
+  })
+);
+
+const PORT = process.env.PORT || 3001;
+
+httpServer.listen(PORT, () => {
+  logger.info(`Server running on port ${PORT}`, { 
+    port: PORT,
+    services: ['tRPC', 'Socket.IO']
+  });
+}); 
+
+// log all env variables
+logger.info('Configurations', {
+  NODE_ENV: process.env.NODE_ENV,
+  PORT: process.env.PORT,
+  NEXT_PUBLIC_APP_URL: process.env.NEXT_PUBLIC_APP_URL,
+  LOG_MODE: process.env.LOG_MODE,
+});

package/src/lib/fileUpload.ts

@@ -0,0 +1,163 @@
+import { TRPCError } from "@trpc/server";
+import { v4 as uuidv4 } from "uuid";
+import { uploadFile as uploadToGCS, getSignedUrl } from "./googleCloudStorage";
+import { generateThumbnail, storeThumbnail, generateMediaThumbnail } from "./thumbnailGenerator";
+import { prisma } from "./prisma";
+
+export interface FileData {
+  name: string;
+  type: string;
+  size: number;
+  data: string; // base64 encoded file data
+}
+
+export interface UploadedFile {
+  id: string;
+  name: string;
+  type: string;
+  size: number;
+  path: string;
+  thumbnailId?: string;
+}
+
+/**
+ * Uploads a single file to Google Cloud Storage and creates a file record
+ * @param file The file data to upload
+ * @param userId The ID of the user uploading the file
+ * @param directory Optional directory to store the file in
+ * @param assignmentId Optional assignment ID to associate the file with
+ * @returns The uploaded file record
+ */
+export async function uploadFile(
+  file: FileData,
+  userId: string,
+  directory?: string,
+  assignmentId?: string
+): Promise<UploadedFile> {
+  try {
+    // Create a unique filename
+    const fileExtension = file.name.split('.').pop();
+    const uniqueFilename = `${uuidv4()}.${fileExtension}`;
+    
+    // Construct the full path
+    const filePath = directory 
+      ? `${directory}/${uniqueFilename}`
+      : uniqueFilename;
+    
+    // Upload to Google Cloud Storage
+    const uploadedPath = await uploadToGCS(file.data, filePath, file.type);
+    
+    // Generate and store thumbnail if supported
+    let thumbnailId: string | undefined;
+    try {
+      // Convert base64 to buffer for thumbnail generation
+      const base64Data = file.data.split(',')[1];
+      const fileBuffer = Buffer.from(base64Data, 'base64');
+      
+      // Generate thumbnail directly from buffer
+      const thumbnailBuffer = await generateMediaThumbnail(fileBuffer, file.type);
+      if (thumbnailBuffer) {
+        // Store thumbnail in a thumbnails directory
+        const thumbnailPath = `thumbnails/${filePath}`;
+        const thumbnailBase64 = `data:image/jpeg;base64,${thumbnailBuffer.toString('base64')}`;
+        await uploadToGCS(thumbnailBase64, thumbnailPath, 'image/jpeg');
+        
+        // Create thumbnail file record
+        const thumbnailFile = await prisma.file.create({
+          data: {
+            name: `${file.name}_thumb.jpg`,
+            type: 'image/jpeg',
+            path: thumbnailPath,
+            user: {
+              connect: { id: userId }
+            }
+          }
+        });
+        
+        thumbnailId = thumbnailFile.id;
+      }
+    } catch (error) {
+      console.warn('Failed to generate thumbnail:', error);
+    }
+    
+    // Create file record in database
+    const fileRecord = await prisma.file.create({
+      data: {
+        name: file.name,
+        type: file.type,
+        size: file.size,
+        path: uploadedPath,
+        user: {
+          connect: { id: userId }
+        },
+        ...(thumbnailId && {
+          thumbnail: {
+            connect: { id: thumbnailId }
+          }
+        }),
+        ...(assignmentId && {
+          assignment: {
+            connect: { id: assignmentId }
+          }
+        })
+      },
+    });
+    
+    // Return file information
+    return {
+      id: fileRecord.id,
+      name: file.name,
+      type: file.type,
+      size: file.size,
+      path: uploadedPath,
+      thumbnailId: thumbnailId
+    };
+  } catch (error) {
+    console.error('Error uploading file:', error);
+    throw new TRPCError({
+      code: 'INTERNAL_SERVER_ERROR',
+      message: 'Failed to upload file',
+    });
+  }
+}
+
+/**
+ * Uploads multiple files
+ * @param files Array of files to upload
+ * @param userId The ID of the user uploading the files
+ * @param directory Optional subdirectory to store the files in
+ * @returns Array of uploaded file information
+ */
+export async function uploadFiles(
+  files: FileData[], 
+  userId: string,
+  directory?: string
+): Promise<UploadedFile[]> {
+  try {
+    const uploadPromises = files.map(file => uploadFile(file, userId, directory));
+    return await Promise.all(uploadPromises);
+  } catch (error) {
+    console.error('Error uploading files:', error);
+    throw new TRPCError({
+      code: 'INTERNAL_SERVER_ERROR',
+      message: 'Failed to upload files',
+    });
+  }
+}
+
+/**
+ * Gets a signed URL for a file
+ * @param filePath The path of the file in Google Cloud Storage
+ * @returns The signed URL
+ */
+export async function getFileUrl(filePath: string): Promise<string> {
+  try {
+    return await getSignedUrl(filePath);
+  } catch (error) {
+    console.error('Error getting signed URL:', error);
+    throw new TRPCError({
+      code: 'INTERNAL_SERVER_ERROR',
+      message: 'Failed to get file URL',
+    });
+  }
+}

package/src/lib/googleCloudStorage.ts

@@ -0,0 +1,94 @@
+import { Storage } from '@google-cloud/storage';
+import { TRPCError } from '@trpc/server';
+
+const storage = new Storage({
+  projectId: process.env.GOOGLE_CLOUD_PROJECT_ID,
+  credentials: {
+    client_email: process.env.GOOGLE_CLOUD_CLIENT_EMAIL,
+    private_key: process.env.GOOGLE_CLOUD_PRIVATE_KEY?.replace(/\\n/g, '\n'),
+  },
+});
+
+const bucket = storage.bucket(process.env.GOOGLE_CLOUD_BUCKET_NAME || '');
+
+// Short expiration time for signed URLs (5 minutes)
+const SIGNED_URL_EXPIRATION = 5 * 60 * 1000;
+
+/**
+ * Uploads a file to Google Cloud Storage
+ * @param base64Data Base64 encoded file data
+ * @param filePath The path where the file should be stored
+ * @param contentType The MIME type of the file
+ * @returns The path of the uploaded file
+ */
+export async function uploadFile(
+  base64Data: string,
+  filePath: string,
+  contentType: string
+): Promise<string> {
+  try {
+    // Remove the data URL prefix if present
+    const base64Content = base64Data.includes('base64,')
+      ? base64Data.split('base64,')[1]
+      : base64Data;
+
+    // Convert base64 to buffer
+    const fileBuffer = Buffer.from(base64Content, 'base64');
+
+    // Create a new file in the bucket
+    const file = bucket.file(filePath);
+
+    // Upload the file
+    await file.save(fileBuffer, {
+      metadata: {
+        contentType,
+      },
+    });
+
+    return filePath;
+  } catch (error) {
+    console.error('Error uploading to Google Cloud Storage:', error);
+    throw new TRPCError({
+      code: 'INTERNAL_SERVER_ERROR',
+      message: 'Failed to upload file to storage',
+    });
+  }
+}
+
+/**
+ * Gets a signed URL for a file
+ * @param filePath The path of the file in the bucket
+ * @returns The signed URL
+ */
+export async function getSignedUrl(filePath: string): Promise<string> {
+  try {
+    const [url] = await bucket.file(filePath).getSignedUrl({
+      version: 'v4',
+      action: 'read',
+      expires: Date.now() + SIGNED_URL_EXPIRATION,
+    });
+    return url;
+  } catch (error) {
+    console.error('Error getting signed URL:', error);
+    throw new TRPCError({
+      code: 'INTERNAL_SERVER_ERROR',
+      message: 'Failed to get signed URL',
+    });
+  }
+}
+
+/**
+ * Deletes a file from Google Cloud Storage
+ * @param filePath The path of the file to delete
+ */
+export async function deleteFile(filePath: string): Promise<void> {
+  try {
+    await bucket.file(filePath).delete();
+  } catch (error) {
+    console.error('Error deleting file from Google Cloud Storage:', error);
+    throw new TRPCError({
+      code: 'INTERNAL_SERVER_ERROR',
+      message: 'Failed to delete file from storage',
+    });
+  }
+} 

package/src/lib/prisma.ts

@@ -0,0 +1,16 @@
+import { PrismaClient } from '@prisma/client';
+
+const prismaClientSingleton = () => {
+  return new PrismaClient();
+};
+
+// Prevent multiple instances of Prisma Client in development
+declare global {
+  var prisma: undefined | ReturnType<typeof prismaClientSingleton>;
+}
+
+export const prisma = globalThis.prisma ?? prismaClientSingleton();
+
+if (process.env.NODE_ENV !== 'production') {
+  globalThis.prisma = prisma;
+}

package/src/lib/thumbnailGenerator.ts

@@ -0,0 +1,185 @@
+import sharp from 'sharp';
+import { prisma } from './prisma';
+import { uploadFile, deleteFile, getSignedUrl } from './googleCloudStorage';
+
+// 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);
+        
+        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
+ */
+export async function storeThumbnail(thumbnailBuffer: Buffer, originalFileName: string, userId: string): Promise<string> {
+    // Convert buffer to base64 for uploadFile function
+    const base64Data = `data:image/jpeg;base64,${thumbnailBuffer.toString('base64')}`;
+    const thumbnailFileName = await uploadFile(base64Data, `thumbnails/${originalFileName}_thumb`, 'image/jpeg');
+    
+    // Create a new File entry for the thumbnail
+    const newThumbnail = await prisma.file.create({
+        data: {
+            name: `${originalFileName}_thumb.jpg`,
+            path: thumbnailFileName,
+            type: 'image/jpeg',
+            userId: userId,
+        },
+    });
+    
+    return newThumbnail.id;
+}