@studious-lms/server 1.0.1 → 1.0.3

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;
+} 

package/src/logger.ts

@@ -0,0 +1,163 @@
+export enum LogLevel {
+  INFO = 'info',
+  WARN = 'warn',
+  ERROR = 'error',
+  DEBUG = 'debug'
+}
+
+type LogMode = 'silent' | 'minimal' | 'normal' | 'verbose';
+
+interface LogMessage {
+  level: LogLevel;
+  message: string;
+  timestamp: string;
+  context?: Record<string, any>;
+}
+
+// Environment detection
+const isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
+
+// ANSI color codes for Node.js
+const ansiColors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+  gray: '\x1b[90m'
+};
+
+// CSS color codes for browser console
+const cssColors = {
+  reset: '%c',
+  info: 'color: #2196F3; font-weight: bold;',
+  warn: 'color: #FFC107; font-weight: bold;',
+  error: 'color: #F44336; font-weight: bold;',
+  debug: 'color: #9C27B0; font-weight: bold;',
+  gray: 'color: #9E9E9E;',
+  context: 'color: #757575; font-style: italic;'
+};
+
+class Logger {
+  private static instance: Logger;
+  private isDevelopment: boolean;
+  private mode: LogMode;
+  private levelEmojis: Record<LogLevel, string>;
+
+  private constructor() {
+    this.isDevelopment = process.env.NODE_ENV === 'development';
+    this.mode = (process.env.LOG_MODE as LogMode) || 'normal';
+    
+    this.levelEmojis = {
+      [LogLevel.INFO]: 'ℹ️',
+      [LogLevel.WARN]: '⚠️',
+      [LogLevel.ERROR]: '❌',
+      [LogLevel.DEBUG]: '🔍'
+    };
+  }
+
+  public static getInstance(): Logger {
+    if (!Logger.instance) {
+      Logger.instance = new Logger();
+    }
+    return Logger.instance;
+  }
+
+  public setMode(mode: LogMode) {
+    this.mode = mode;
+  }
+
+  private shouldLog(level: LogLevel): boolean {
+    const silent = [LogLevel.ERROR];
+    const minimal = [LogLevel.ERROR, LogLevel.WARN];
+    const normal = [LogLevel.ERROR, LogLevel.WARN, LogLevel.INFO];
+
+    if (this.mode === 'silent') return silent.includes(level);
+    if (this.mode === 'minimal') return minimal.includes(level);
+    if (this.mode === 'normal') return normal.includes(level);
+    return true; // verbose mode
+  }
+
+  private formatMessage(logMessage: LogMessage): string | [string, ...string[]] {
+    const { level, message, timestamp, context } = logMessage;
+    const emoji = this.levelEmojis[level];
+    
+    const timestampStr = `[${timestamp}]`;
+    const levelStr = `[${level.toUpperCase()}]`;
+    const messageStr = `${emoji} ${message}`;
+    
+    const contextStr = context 
+      ? `\nContext: ${JSON.stringify(context, null, 2)}`
+      : '';
+
+    if (isNode) {
+      const color = ansiColors[level === LogLevel.INFO ? 'blue' : 
+                             level === LogLevel.WARN ? 'yellow' :
+                             level === LogLevel.ERROR ? 'red' : 'magenta'];
+      
+      return `${ansiColors.gray}${timestampStr}${ansiColors.reset} ${color}${levelStr}${ansiColors.reset} ${messageStr}${contextStr}`;
+    } else {
+      const color = cssColors[level];
+      return [
+        `${timestampStr} ${levelStr} ${messageStr}${contextStr}`,
+        cssColors.reset,
+        color,
+        cssColors.gray,
+        cssColors.context
+      ];
+    }
+  }
+
+  private log(level: LogLevel, message: string, context?: Record<string, any>) {
+    if (!this.shouldLog(level)) return;
+
+    const logMessage: LogMessage = {
+      level,
+      message,
+      timestamp: new Date().toISOString(),
+      context
+    };
+
+    const formattedMessage = this.formatMessage(logMessage);
+
+    switch (level) {
+      case LogLevel.ERROR:
+        console.error(...(Array.isArray(formattedMessage) ? formattedMessage : [formattedMessage]));
+        break;
+      case LogLevel.WARN:
+        console.warn(...(Array.isArray(formattedMessage) ? formattedMessage : [formattedMessage]));
+        break;
+      case LogLevel.DEBUG:
+        if (this.isDevelopment) {
+          console.debug(...(Array.isArray(formattedMessage) ? formattedMessage : [formattedMessage]));
+        }
+        break;
+      default:
+        console.log(...(Array.isArray(formattedMessage) ? formattedMessage : [formattedMessage]));
+    }
+  }
+
+  public info(message: string, context?: Record<string, any>) {
+    this.log(LogLevel.INFO, message, context);
+  }
+
+  public warn(message: string, context?: Record<string, any>) {
+    this.log(LogLevel.WARN, message, context);
+  }
+
+  public error(message: string, context?: Record<string, any>) {
+    this.log(LogLevel.ERROR, message, context);
+  }
+
+  public debug(message: string, context?: Record<string, any>) {
+    this.log(LogLevel.DEBUG, message, context);
+  }
+}
+
+export const logger = Logger.getInstance();