@studious-lms/server 1.1.19 → 1.1.21

package/src/lib/fileUpload.ts

@@ -1,14 +1,15 @@
 import { TRPCError } from "@trpc/server";
 import { v4 as uuidv4 } from "uuid";
-import { uploadFile as uploadToGCS, getSignedUrl } from "./googleCloudStorage.js";
-import { generateThumbnail, storeThumbnail, generateMediaThumbnail } from "./thumbnailGenerator.js";
+import { getSignedUrl, objectExists } from "./googleCloudStorage.js";
+import { generateMediaThumbnail } from "./thumbnailGenerator.js";
 import { prisma } from "./prisma.js";
+import { logger } from "src/utils/logger.js";
 
 export interface FileData {
   name: string;
   type: string;
   size: number;
-  data: string; // base64 encoded file data
+  // No data field - for direct file uploads
 }
 
 export interface DirectFileData {
@@ -27,13 +28,22 @@ export interface UploadedFile {
   thumbnailId?: string;
 }
 
+export interface DirectUploadFile {
+  id: string;
+  name: string;
+  type: string;
+  size: number;
+  path: string;
+  uploadUrl: string;
+  uploadExpiresAt: Date;
+  uploadSessionId: string;
+}
+
+// DEPRECATED: These functions are no longer used - files are uploaded directly to GCS
+// Use createDirectUploadFile() and createDirectUploadFiles() instead
+
 /**
- * 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
+ * @deprecated Use createDirectUploadFile instead
  */
 export async function uploadFile(
   file: FileData,
@@ -41,6 +51,59 @@ export async function uploadFile(
   directory?: string,
   assignmentId?: string
 ): Promise<UploadedFile> {
+  throw new TRPCError({
+    code: 'NOT_IMPLEMENTED',
+    message: 'uploadFile is deprecated. Use createDirectUploadFile instead.',
+  });
+}
+
+/**
+ * @deprecated Use createDirectUploadFiles instead
+ */
+export async function uploadFiles(
+  files: FileData[], 
+  userId: string,
+  directory?: string
+): Promise<UploadedFile[]> {
+  throw new TRPCError({
+    code: 'NOT_IMPLEMENTED',
+    message: 'uploadFiles is deprecated. Use createDirectUploadFiles instead.',
+  });
+}
+
+/**
+ * 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',
+    });
+  }
+}
+
+/**
+ * Creates a file record for direct upload and generates signed URL
+ * @param file The file metadata (no base64 data)
+ * @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
+ * @param submissionId Optional submission ID to associate the file with
+ * @returns The direct upload file information with signed URL
+ */
+export async function createDirectUploadFile(
+  file: DirectFileData,
+  userId: string,
+  directory?: string,
+  assignmentId?: string,
+  submissionId?: string
+): Promise<DirectUploadFile> {
   try {
     // Validate file extension matches MIME type
     const fileExtension = file.name.split('.').pop()?.toLowerCase();
@@ -63,59 +126,30 @@ export async function uploadFile(
     // Create a unique filename
     const uniqueFilename = `${uuidv4()}.${fileExtension}`;
     
-  //   // Construct the full path
+    // 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 upload session ID
+    const uploadSessionId = uuidv4();
     
-  //   // Generate and store thumbnail if supported
-    let thumbnailId: string | undefined;
-    try {
-  //         // Convert base64 to buffer for thumbnail generation
-    // Handle both data URI format (data:image/jpeg;base64,...) and raw base64
-    const base64Data = file.data.includes(',') ? file.data.split(',')[1] : file.data;
-    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${Math.random()}`,
-            type: 'image/jpeg',
-            path: thumbnailPath,
-            // path: '/dummyPath' + Math.random().toString(36).substring(2, 15),
-            user: {
-              connect: { id: userId }
-            }
-          }
-        });
-        
-        thumbnailId = thumbnailFile.id;
-      }
-    } catch (error) {
-      console.warn('Failed to generate thumbnail:', error);
-      // Continue without thumbnail - this is not a critical failure
-    }
+    // Generate backend proxy upload URL (not direct GCS)
+    const baseUrl = process.env.BACKEND_URL || 'http://localhost:3001';
+    const uploadUrl = `${baseUrl}/api/upload/${encodeURIComponent(filePath)}`;
+    const uploadExpiresAt = new Date(Date.now() + 15 * 60 * 1000); // 15 minutes from now
     
-    // Create file record in database
-
-    // const uploadedPath = '/dummyPath' + Math.random().toString(36).substring(2, 15);
+    // Create file record in database with PENDING status
     const fileRecord = await prisma.file.create({
       data: {
         name: file.name,
         type: file.type,
         size: file.size,
-        path: uploadedPath,
+        path: filePath,
+        uploadStatus: 'PENDING',
+        uploadUrl,
+        uploadExpiresAt,
+        uploadSessionId,
         user: {
           connect: { id: userId }
         },
@@ -124,75 +158,187 @@ export async function uploadFile(
             connect: {id: directory},
           },
         }),
-        ...(thumbnailId && {
-          thumbnail: {
-            connect: { id: thumbnailId }
-          }
-        }),
         ...(assignmentId && {
           assignment: {
             connect: { id: assignmentId }
           }
+        }),
+        ...(submissionId && {
+          submission: {
+            connect: { id: submissionId }
+          }
         })
       },
     });
     
-    // Return file information
     return {
       id: fileRecord.id,
       name: file.name,
       type: file.type,
       size: file.size,
-      path: uploadedPath,
-      thumbnailId: thumbnailId
+      path: filePath,
+      uploadUrl,
+      uploadExpiresAt,
+      uploadSessionId
     };
+  } catch (error) {
+    logger.error('Error creating direct upload file:', {error: error instanceof Error ? {
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+    } : error});
+    throw new TRPCError({
+      code: 'INTERNAL_SERVER_ERROR',
+      message: 'Failed to create direct upload file',
+    });
   }
-   catch (error) {
-    console.error('Error uploading file:', error);
+}
+
+/**
+ * Confirms a direct upload was successful
+ * @param fileId The ID of the file record
+ * @param uploadSuccess Whether the upload was successful
+ * @param errorMessage Optional error message if upload failed
+ */
+export async function confirmDirectUpload(
+  fileId: string,
+  uploadSuccess: boolean,
+  errorMessage?: string
+): Promise<void> {
+  try {
+    // First fetch the file record to get the object path
+    const fileRecord = await prisma.file.findUnique({
+      where: { id: fileId },
+      select: { path: true }
+    });
+
+    if (!fileRecord) {
+      throw new TRPCError({
+        code: 'NOT_FOUND',
+        message: 'File record not found',
+      });
+    }
+
+    let actualUploadSuccess = uploadSuccess;
+    let actualErrorMessage = errorMessage;
+
+    // If uploadSuccess is true, verify the object actually exists in GCS
+    if (uploadSuccess) {
+      try {
+        const exists = await objectExists(process.env.GOOGLE_CLOUD_BUCKET_NAME!, fileRecord.path);
+        if (!exists) {
+          actualUploadSuccess = false;
+          actualErrorMessage = 'File upload reported as successful but object not found in Google Cloud Storage';
+          logger.error(`File upload verification failed for ${fileId}: object ${fileRecord.path} not found in GCS`);
+        }
+      } catch (error) {
+        logger.error(`Error verifying file existence in GCS for ${fileId}:`, {error: error instanceof Error ? {
+          name: error.name,
+          message: error.message,
+          stack: error.stack,
+        } : error});
+        actualUploadSuccess = false;
+        actualErrorMessage = 'Failed to verify file existence in Google Cloud Storage';
+      }
+    }
+
+    const updateData: any = {
+      uploadStatus: actualUploadSuccess ? 'COMPLETED' : 'FAILED',
+      uploadProgress: actualUploadSuccess ? 100 : 0,
+    };
+    
+    if (!actualUploadSuccess && actualErrorMessage) {
+      updateData.uploadError = actualErrorMessage;
+      updateData.uploadRetryCount = { increment: 1 };
+    }
+    
+    if (actualUploadSuccess) {
+      updateData.uploadedAt = new Date();
+    }
+    
+    await prisma.file.update({
+      where: { id: fileId },
+      data: updateData
+    });
+  } catch (error) {
+    logger.error('Error confirming direct upload:', {error});
     throw new TRPCError({
       code: 'INTERNAL_SERVER_ERROR',
-      message: 'Failed to upload file',
+      message: 'Failed to confirm upload',
     });
   }
 }
 
 /**
- * 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
+ * Updates upload progress for a direct upload
+ * @param fileId The ID of the file record
+ * @param progress Progress percentage (0-100)
  */
-export async function uploadFiles(
-  files: FileData[], 
-  userId: string,
-  directory?: string
-): Promise<UploadedFile[]> {
+export async function updateUploadProgress(
+  fileId: string,
+  progress: number
+): Promise<void> {
   try {
-    const uploadPromises = files.map(file => uploadFile(file, userId, directory));
-    return await Promise.all(uploadPromises);
+    // await prisma.file.update({
+    //   where: { id: fileId },
+    //   data: {
+    //     uploadStatus: 'UPLOADING',
+    //     uploadProgress: Math.min(100, Math.max(0, progress))
+    //   }
+    // });
+    const current = await prisma.file.findUnique({ where: { id: fileId }, select: { uploadStatus: true } });
+    if (!current || ['COMPLETED','FAILED','CANCELLED'].includes(current.uploadStatus as string)) return;
+    const clamped = Math.min(100, Math.max(0, progress));
+    await prisma.file.update({
+      where: { id: fileId },
+      data: {
+        uploadStatus: 'UPLOADING',
+        uploadProgress: clamped
+      }
+    });
   } catch (error) {
-    console.error('Error uploading files:', error);
+    logger.error('Error updating upload progress:', {error: error instanceof Error ? {
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+    } : error});  
     throw new TRPCError({
       code: 'INTERNAL_SERVER_ERROR',
-      message: 'Failed to upload files',
+      message: 'Failed to update upload progress',
     });
   }
 }
 
 /**
- * Gets a signed URL for a file
- * @param filePath The path of the file in Google Cloud Storage
- * @returns The signed URL
+ * Creates multiple direct upload files
+ * @param files Array of file metadata
+ * @param userId The ID of the user uploading the files
+ * @param directory Optional subdirectory to store the files in
+ * @param assignmentId Optional assignment ID to associate files with
+ * @param submissionId Optional submission ID to associate files with
+ * @returns Array of direct upload file information
  */
-export async function getFileUrl(filePath: string): Promise<string> {
+export async function createDirectUploadFiles(
+  files: DirectFileData[], 
+  userId: string,
+  directory?: string,
+  assignmentId?: string,
+  submissionId?: string
+): Promise<DirectUploadFile[]> {
   try {
-    return await getSignedUrl(filePath);
+    const uploadPromises = files.map(file => 
+      createDirectUploadFile(file, userId, directory, assignmentId, submissionId)
+    );
+    return await Promise.all(uploadPromises);
   } catch (error) {
-    console.error('Error getting signed URL:', error);
+    logger.error('Error creating direct upload files:', {error: error instanceof Error ? {
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+    } : error});
     throw new TRPCError({
       code: 'INTERNAL_SERVER_ERROR',
-      message: 'Failed to get file URL',
+      message: 'Failed to create direct upload files',
     });
   }
 }

package/src/lib/googleCloudStorage.ts

@@ -16,46 +16,8 @@ export 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',
-    });
-  }
-}
+// DEPRECATED: This function is no longer used - files are uploaded directly to GCS
+// The backend proxy upload endpoint in index.ts handles direct uploads
 
 /**
  * Gets a signed URL for a file
@@ -100,4 +62,23 @@ export async function deleteFile(filePath: string): Promise<void> {
       message: 'Failed to delete file from storage',
     });
   }
+}
+
+/**
+ * Checks if an object exists in Google Cloud Storage
+ * @param bucketName The name of the bucket (unused, uses default bucket)
+ * @param objectPath The path of the object to check
+ * @returns Promise<boolean> True if the object exists, false otherwise
+ */
+export async function objectExists(bucketName: string, objectPath: string): Promise<boolean> {
+  try {
+    const [exists] = await bucket.file(objectPath).exists();
+    return exists;
+  } catch (error) {
+    console.error('Error checking if object exists in Google Cloud Storage:', error);
+    throw new TRPCError({
+      code: 'INTERNAL_SERVER_ERROR',
+      message: 'Failed to check object existence',
+    });
+  }
 } 

package/src/lib/thumbnailGenerator.ts

@@ -1,6 +1,6 @@
 import sharp from 'sharp';
 import { prisma } from './prisma.js';
-import { uploadFile, deleteFile, getSignedUrl } from './googleCloudStorage.js';
+import { deleteFile, getSignedUrl } from './googleCloudStorage.js';
 
 // Thumbnail size configuration
 const THUMBNAIL_WIDTH = 200;
@@ -166,20 +166,5 @@ export async function generateThumbnail(fileName: string, fileType: string): Pro
  * @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;
-} 
+// DEPRECATED: This function is no longer used - thumbnails are generated during direct uploads
+// Thumbnail generation is now handled in the direct upload flow