@studious-lms/server 1.0.2 → 1.0.3

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(); 

package/src/middleware/auth.ts

@@ -0,0 +1,191 @@
+import { TRPCError } from '@trpc/server';
+import { prisma } from '../lib/prisma';
+import type { MiddlewareContext } from '../types/trpc';
+
+export const createAuthMiddleware = (t: any) => {
+
+  // Auth middleware
+  const isAuthed = t.middleware(async ({ next, ctx }: MiddlewareContext) => {
+    const startTime = Date.now();
+    // Get user from request headers
+    const userHeader = ctx.req.headers['x-user'];
+
+    if (!userHeader) {
+      throw new TRPCError({
+        code: 'UNAUTHORIZED',
+        message: 'Not authenticated - no token found',
+      });
+    }
+
+    try {
+      const token = typeof userHeader === 'string' ? userHeader : userHeader[0];
+
+      // Find user by session token
+      const user = await prisma.user.findFirst({
+        where: {
+          sessions: {
+            some: {
+              id: token
+            }
+          }
+        },
+        select: {
+          id: true,
+          username: true,
+          // institutionId: true,
+        }
+      });
+
+      if (!user) {
+        throw new TRPCError({
+          code: 'UNAUTHORIZED',
+          message: 'Invalid or expired session',
+        });
+      }
+
+      console.log(user)
+
+      return next({
+        ctx: {
+          ...ctx,
+          user,
+        },
+      });
+    } catch (error) {
+      console.log(error)
+      throw new TRPCError({
+        code: 'UNAUTHORIZED',
+        message: 'Invalid user data',
+      });
+    }
+  });
+
+  // Add computed flags middleware
+  const addComputedFlags = t.middleware(async ({ next, ctx }: MiddlewareContext) => {
+    if (!ctx.user) {
+      throw new TRPCError({
+        code: 'UNAUTHORIZED',
+        message: 'Not authenticated',
+      });
+    }
+
+    // Get all classes where user is a teacher
+    const teacherClasses = await prisma.class.findMany({
+      where: {
+        teachers: {
+          some: {
+            id: ctx.user.id
+          }
+        }
+      },
+      select: {
+        id: true
+      }
+    });
+
+    return next({
+      ctx: {
+        ...ctx,
+        isTeacher: teacherClasses.length > 0,
+        teacherClassIds: teacherClasses.map((c: { id: string }) => c.id)
+      }
+    });
+  });
+
+  // Student middleware
+  const isMemberInClass = t.middleware(async ({ next, ctx, input }: MiddlewareContext) => {
+    if (!ctx.user) {
+      throw new TRPCError({
+        code: 'UNAUTHORIZED',
+        message: 'Not authenticated',
+      });
+    }
+
+    const classId = (input as { classId: string })?.classId;
+
+    if (!classId) {
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        message: 'classId is required',
+      });
+    }
+
+    const isMember = await prisma.class.findFirst({
+      where: {
+        id: classId,
+        OR: [
+          {
+            students: {
+              some: {
+                id: ctx.user.id
+              }
+            }
+          },
+          {
+            teachers: {
+              some: {
+                id: ctx.user.id
+              }
+            }
+          }
+        ]
+      }
+    });
+
+    if (!isMember) {
+      throw new TRPCError({
+        code: 'FORBIDDEN',
+        message: 'Not a member in this class',
+      });
+    }
+
+    return next();
+  });
+
+  // Teacher middleware
+  const isTeacherInClass = t.middleware(async ({ next, ctx, input }: MiddlewareContext) => {
+    if (!ctx.user) {
+      throw new TRPCError({
+        code: 'UNAUTHORIZED',
+        message: 'Not authenticated',
+      });
+    }
+
+    const classId = input.classId;
+    if (!classId) {
+      throw new TRPCError({
+        code: 'BAD_REQUEST',
+        message: 'classId is required',
+      });
+    }
+
+    const isTeacher = await prisma.class.findFirst({
+      where: {
+        id: classId,
+        teachers: {
+          some: {
+            id: ctx.user.id
+          }
+        }
+      }
+    });
+
+
+
+    if (!isTeacher) {
+      throw new TRPCError({
+        code: 'FORBIDDEN',
+        message: 'Not a teacher in this class',
+      });
+    }
+
+    return next();
+  });
+
+  return {
+    isAuthed,
+    addComputedFlags,
+    isMemberInClass,
+    isTeacherInClass,
+  };
+}; 

package/src/middleware/logging.ts

@@ -0,0 +1,54 @@
+import type { MiddlewareContext } from '../types/trpc';
+import { logger } from '../utils/logger';
+
+export const createLoggingMiddleware = (t: any) => {
+  return t.middleware(async ({ path, type, next, ctx }: MiddlewareContext) => {
+    const start = Date.now();
+    const requestId = crypto.randomUUID();
+
+    // Log request
+    logger.info('tRPC Request', {
+      requestId,
+      path,
+      type,
+      // input,
+      timestamp: new Date().toISOString(),
+    });
+
+    try {
+      const result = await next();
+      const durationMs = Date.now() - start;
+
+      // Log successful response
+      logger.info('tRPC Response', {
+        requestId,
+        path,
+        type,
+        durationMs,
+        ok: result.ok,
+        timestamp: new Date().toISOString(),
+      });
+
+      return result;
+    } catch (error) {
+      const durationMs = Date.now() - start;
+
+      // Log error response
+      logger.error('tRPC Error' + path, {
+        requestId,
+        path,
+        type,
+        durationMs,
+        error: error instanceof Error ? {
+          path,
+          name: error.name,
+          message: error.message,
+          stack: error.stack,
+        } : error,
+        timestamp: new Date().toISOString(),
+      });
+
+      throw error;
+    }
+  });
+}; 

package/src/routers/_app.ts

@@ -0,0 +1,34 @@
+import { createTRPCRouter } from "../trpc";
+import { classRouter } from "./class";
+import { announcementRouter } from "./announcement";
+import { assignmentRouter } from "./assignment";
+import { userRouter } from "./user";
+import { createCallerFactory } from "../trpc";
+import type { inferRouterInputs, inferRouterOutputs } from "@trpc/server";
+import { sectionRouter } from "./section";
+import { attendanceRouter } from "./attendance";
+import { eventRouter } from "./event";
+import { authRouter } from "./auth";
+import { agendaRouter } from "./agenda";
+import { fileRouter } from "./file";
+
+export const appRouter = createTRPCRouter({
+  class: classRouter,
+  announcement: announcementRouter,
+  assignment: assignmentRouter,
+  user: userRouter,
+  section: sectionRouter,
+  attendance: attendanceRouter,
+  event: eventRouter,
+  auth: authRouter,
+  agenda: agendaRouter,
+  file: fileRouter,
+});
+
+// Export type router type definition
+export type AppRouter = typeof appRouter;
+export type RouterInputs = inferRouterInputs<AppRouter>;
+export type RouterOutputs = inferRouterOutputs<AppRouter>;
+
+// Export caller
+export const createCaller = createCallerFactory(appRouter); 

package/src/routers/agenda.ts

@@ -0,0 +1,79 @@
+import { z } from "zod";
+import { createTRPCRouter, protectedProcedure } from "../trpc";
+import { prisma } from "../lib/prisma";
+import { TRPCError } from "@trpc/server";
+import { addDays, startOfDay, endOfDay } from "date-fns";
+
+export const agendaRouter = createTRPCRouter({
+  get: protectedProcedure
+    .input(z.object({
+      weekStart: z.string(),
+    }))
+    .query(async ({ ctx, input }) => {
+      if (!ctx.user) {
+        throw new TRPCError({
+          code: "UNAUTHORIZED",
+          message: "You must be logged in to get your agenda",
+        });
+      }
+
+      const weekStart = startOfDay(new Date(input.weekStart));
+      const weekEnd = endOfDay(addDays(weekStart, 6));
+
+      const [personalEvents, classEvents] = await Promise.all([
+        // Get personal events
+        prisma.event.findMany({
+          where: {
+            userId: ctx.user.id,
+            startTime: {
+              gte: weekStart,
+              lte: weekEnd,
+            },
+            class: {
+              is: null,
+            },
+          },
+          include: {
+            class: true,
+          },
+        }),
+        // Get class events
+        prisma.event.findMany({
+          where: {
+            class: {
+              OR: [
+                {
+                  teachers: {
+                    some: {
+                      id: ctx.user.id,
+                    },
+                  },
+                },
+                {
+                  students: {
+                    some: {
+                      id: ctx.user.id,
+                    },
+                  },
+                },
+              ],
+            },
+            startTime: {
+              gte: weekStart,
+              lte: weekEnd,
+            },
+          },
+          include: {
+            class: true,
+          },
+        }),
+      ]);
+
+      return {
+        events: {
+          personal: personalEvents,
+          class: classEvents,
+        },
+      };
+    }),
+});