@studious-lms/server 1.1.24 → 1.2.6

package/src/lib/googleCloudStorage.ts

@@ -1,17 +1,17 @@
-import dotenv from 'dotenv';
-dotenv.config();
+
 import { Storage } from '@google-cloud/storage';
 import { TRPCError } from '@trpc/server';
+import { env } from './config/env.js';
 
 const storage = new Storage({
-  projectId: process.env.GOOGLE_CLOUD_PROJECT_ID,
+  projectId: 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'),
+    client_email: env.GOOGLE_CLOUD_CLIENT_EMAIL,
+    private_key: env.GOOGLE_CLOUD_PRIVATE_KEY?.replace(/\\n/g, '\n'),
   },
 });
 
-export const bucket = storage.bucket(process.env.GOOGLE_CLOUD_BUCKET_NAME!);
+export const bucket = storage.bucket(env.GOOGLE_CLOUD_BUCKET_NAME!);
 
 // Short expiration time for signed URLs (5 minutes)
 const SIGNED_URL_EXPIRATION = 5 * 60 * 1000;
@@ -62,4 +62,40 @@ 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',
+    });
+  }
+}
+
+/**
+ * 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/jsonConversion.ts

@@ -4,12 +4,13 @@ import { readFileSync } from 'fs'
 import { join } from 'path'
 import { writeFile } from 'fs'
 import { DocumentBlock, FormatTypes, Fonts } from './jsonStyles.js'
+import { logger } from '../utils/logger.js'
 
 export async function createPdf(blocks: DocumentBlock[]) {
-    console.log('createPdf: Starting PDF creation with', blocks.length, 'blocks');
+    logger.info(`createPdf: Starting PDF creation with ${blocks.length} blocks`);
     try {
         const pdfDoc = await PDFDocument.create()
-        console.log('createPdf: PDFDocument created successfully');
+        logger.info('createPdf: PDFDocument created successfully');
         
         // Register fontkit to enable custom font embedding
         pdfDoc.registerFontkit(fontkit)
@@ -33,9 +34,9 @@ export async function createPdf(blocks: DocumentBlock[]) {
             notoSansItalic = await pdfDoc.embedFont(italicFontBytes)
             courierFont = await pdfDoc.embedFont(StandardFonts.Courier) // Keep Courier for code blocks
             
-            console.log('createPdf: Unicode fonts loaded successfully');
+            logger.info('createPdf: Unicode fonts loaded successfully');
         } catch (fontError) {
-            console.warn('createPdf: Failed to load custom fonts, falling back to standard fonts:', fontError);
+            logger.warn(`createPdf: Failed to load custom fonts, falling back to standard fonts: ${fontError}`);
             // Fallback to standard fonts if custom fonts fail
             notoSansRegular = await pdfDoc.embedFont(StandardFonts.Helvetica)
             notoSansBold = await pdfDoc.embedFont(StandardFonts.HelveticaBold)
@@ -342,10 +343,10 @@ export async function createPdf(blocks: DocumentBlock[]) {
 
     let y = height - marginTop
     let lastLineHeight = -1
-    console.log('createPdf: Starting to process', blocks.length, 'blocks');
+    logger.info(`createPdf: Starting to process ${blocks.length} blocks`);
     for (let i = 0; i < blocks.length; i++) {
         const block = blocks[i];
-        console.log(`createPdf: Processing block ${i + 1}/${blocks.length}, format: ${block.format}, content type: ${typeof block.content}`);
+        logger.info(`createPdf: Processing block ${i + 1}/${blocks.length}, format: ${block.format}, content type: ${typeof block.content}`);
         try {
         const preset = STYLE_PRESETS[block.format] || { fontSize: defaultFontSize, lineHeight: defaultLineHeight }
 
@@ -725,24 +726,21 @@ export async function createPdf(blocks: DocumentBlock[]) {
                 }
             }
         }
-        console.log(`createPdf: Successfully processed block ${i + 1}`);
+        logger.info(`createPdf: Successfully processed block ${i + 1}`);
         y -= paragraphSpacing
         lastLineHeight = lineHeight
         } catch (blockError) {
-            console.error(`createPdf: Error processing block ${i + 1}:`, blockError);
+            logger.error(`createPdf: Error processing block ${i + 1}: ${blockError}`);
             throw blockError;
         }
     }
 
-        console.log('createPdf: About to save PDF document');
+        logger.info('createPdf: About to save PDF document');
         const pdfBytes = await pdfDoc.save()
-        console.log('createPdf: PDF saved successfully, bytes length:', pdfBytes.length);
-        // writeFile('output.pdf', pdfBytes, () => {
-        //     console.log('PDF created successfully') // Still only saves file, no API yet
-        // })
+        logger.info(`createPdf: PDF saved successfully, bytes length: ${pdfBytes.length}`);
         return pdfBytes
     } catch (error) {
-        console.error('createPdf: Error during PDF creation:', error);
+        logger.error(`createPdf: Error during PDF creation: ${error}`);
         throw error;
     }
 }

package/src/lib/prisma.ts

@@ -1,6 +1,23 @@
 import { PrismaClient } from '@prisma/client';
+import { env } from './config/env.js';
+
+const getLogLevel = () => {
+  switch (env.NODE_ENV) {
+    case 'development':
+      return ['query', 'error', 'warn'];
+    case 'production':
+      return ['error'];
+    default:
+      return ['error'];
+  }
+}
 
 const prismaClientSingleton = () => {
+  // return new PrismaClient({
+  //   log: env.NODE_ENV === 'development' 
+  //     ? ['query', 'error', 'warn'] 
+  //     : ['error'],
+  // });
   return new PrismaClient();
 };
 
@@ -11,6 +28,10 @@ declare global {
 
 export const prisma = globalThis.prisma ?? prismaClientSingleton();
 
-if (process.env.NODE_ENV !== 'production') {
+if (env.NODE_ENV !== 'production') {
   globalThis.prisma = prisma;
-}
+}
+
+process.on('beforeExit', async () => {
+  await prisma.$disconnect();
+});

package/src/lib/pusher.ts

@@ -1,11 +1,16 @@
 import Pusher from 'pusher';
+import { env } from './config/env.js';
 
 const pusher = new Pusher({
-  appId: process.env.PUSHER_APP_ID!,
-  key: process.env.PUSHER_KEY!,
-  secret: process.env.PUSHER_SECRET!,
-  cluster: process.env.PUSHER_CLUSTER!,
-  useTLS: true,
+  appId: env.PUSHER_APP_ID,
+  key: env.PUSHER_KEY,
+  secret: env.PUSHER_SECRET,
+  cluster: env.PUSHER_CLUSTER,
+  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