@studious-lms/server 1.0.6 → 1.0.8

package/src/routers/notifications.ts

@@ -0,0 +1,93 @@
+import { createTRPCRouter, protectedProcedure } from "../trpc.js";
+import { prisma } from "../lib/prisma.js";
+import { z } from "zod";
+
+export const notificationRouter = createTRPCRouter({
+    list: protectedProcedure.query(async ({ ctx }) => {
+        const notifications = await prisma.notification.findMany({
+            where: {
+                receiverId: ctx.user!.id,
+            },
+            orderBy: {
+                createdAt: "desc",
+            },
+            include: {
+                sender: {
+                    select: {
+                        username: true,
+                    },
+                },
+                receiver: {
+                    select: {
+                        username: true,
+                    },
+                },
+            },
+        });
+
+        return notifications;
+    }),
+    get: protectedProcedure.input(z.object({
+        id: z.string(),
+    })).query(async ({ ctx, input }) => {
+        const { id } = input;
+        const notification = await prisma.notification.findUnique({
+            where: {
+                id,
+            },
+            include: {
+                sender: {
+                    select: {
+                        username: true,
+                    },
+                },
+                receiver: {
+                    select: {
+                        username: true,
+                    },
+                },
+            },
+        });
+        return notification;
+    }),
+    sendTo: protectedProcedure.input(z.object({
+        receiverId: z.string(),
+        title: z.string(),
+        content: z.string(),
+    })).mutation(async ({ ctx, input }) => {
+        const { receiverId, title, content } = input;
+        const notification = await prisma.notification.create({
+            data: {
+                receiverId,
+                title,
+                content,
+            },
+        });
+        return notification;
+    }),
+    sendToMultiple: protectedProcedure.input(z.object({
+        receiverIds: z.array(z.string()),
+        title: z.string(),
+        content: z.string(),
+    })).mutation(async ({ ctx, input }) => {
+        const { receiverIds, title, content } = input;
+        const notifications = await prisma.notification.createMany({
+            data: receiverIds.map(receiverId => ({
+                receiverId,
+                title,
+                content,
+            })),
+        });
+        return notifications;
+    }),
+    markAsRead: protectedProcedure.input(z.object({
+        id: z.string(),
+    })).mutation(async ({ ctx, input }) => {
+        const { id } = input;
+        const notification = await prisma.notification.update({
+            where: { id },
+            data: { read: true },
+        });
+        return notification;
+    }),
+})

package/src/routers/section.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { createTRPCRouter, protectedProcedure } from "../trpc";
+import { createTRPCRouter, protectedProcedure } from "../trpc.js";
 import { TRPCError } from "@trpc/server";
-import { prisma } from "../lib/prisma";
+import { prisma } from "../lib/prisma.js";
 
 const createSectionSchema = z.object({
   classId: z.string(),

package/src/routers/user.ts

@@ -1,8 +1,8 @@
 import { z } from "zod";
-import { createTRPCRouter, protectedProcedure } from "../trpc";
+import { createTRPCRouter, protectedProcedure } from "../trpc.js";
 import { TRPCError } from "@trpc/server";
-import { prisma } from "../lib/prisma";
-import { uploadFiles, type UploadedFile } from "../lib/fileUpload";
+import { prisma } from "../lib/prisma.js";
+import { uploadFiles, type UploadedFile } from "../lib/fileUpload.js";
 
 const fileSchema = z.object({
   name: z.string(),

package/src/seedDatabase.ts

@@ -0,0 +1,88 @@
+import { prisma } from "./lib/prisma.js";
+import { hash } from "bcryptjs";
+import { logger } from "./utils/logger.js";
+
+export async function clearDatabase() {
+    // Delete in order to respect foreign key constraints
+    // Delete notifications first (they reference users)
+    await prisma.notification.deleteMany();
+    
+    // Delete other records that reference users
+    await prisma.submission.deleteMany();
+    await prisma.assignment.deleteMany();
+    await prisma.announcement.deleteMany();
+    await prisma.event.deleteMany();
+    await prisma.attendance.deleteMany();
+    await prisma.file.deleteMany();
+    
+    // Delete class-related records
+    await prisma.section.deleteMany();
+    await prisma.markScheme.deleteMany();
+    await prisma.gradingBoundary.deleteMany();
+    await prisma.folder.deleteMany();
+    await prisma.class.deleteMany();
+    
+    // Delete user-related records
+    await prisma.session.deleteMany();
+    await prisma.userProfile.deleteMany();
+    
+    // Finally delete users and schools
+    await prisma.user.deleteMany();
+    await prisma.school.deleteMany();
+}
+
+export async function createUser(email: string, password: string, username: string) {
+    logger.debug("Creating user", { email, username, password });
+
+    const hashedPassword = await hash(password, 10);
+    return await prisma.user.create({
+        data: { email, password: hashedPassword, username, verified: true },
+    });
+}
+
+export async function addNotification(userId: string, title: string, content: string) {
+    return await prisma.notification.create({
+        data: {
+            receiverId: userId,
+            title,
+            content,
+        },
+    });
+}
+
+export const seedDatabase = async () => {
+    await clearDatabase();
+    logger.info('Cleared database');
+
+    // create two test users
+    const teacher1 = await createUser('teacher1@studious.sh', '123456', 'teacher1');
+    const student1 = await createUser('student1@studious.sh', '123456', 'student1');
+
+    // create a class
+    const class1 = await prisma.class.create({
+        data: {
+            name: 'Class 1',
+            subject: 'Math',
+            section: 'A',
+            teachers: {
+                connect: {
+                    id: teacher1.id,
+                }
+            },
+            students: {
+                connect: {
+                    id: student1.id,
+                }
+            }
+        },
+    });
+
+    await addNotification(teacher1.id, 'Welcome to Studious', 'Welcome to Studious');
+    await addNotification(student1.id, 'Welcome to Studious', 'Welcome to Studious');
+};
+
+(async () => {
+    logger.info('Seeding database');
+    await seedDatabase();
+    logger.info('Database seeded');
+})();

package/src/socket/handlers.ts

@@ -1,15 +1,15 @@
 import { Socket, Server } from 'socket.io';
-import { logger } from '../utils/logger';
+import { logger } from '../utils/logger.js';
 
 export const setupSocketHandlers = (io: Server) => {
   io.on('connection', (socket: Socket) => {
     logger.info('Client connected', { socketId: socket.id });
 
-    socket.on('disconnect', (reason) => {
+    socket.on('disconnect', (reason: string) => {
       logger.info('Client disconnected', { socketId: socket.id, reason });
     });
 
-    socket.on('error', (error) => {
+    socket.on('error', (error: Error) => {
       logger.error('Socket error', { socketId: socket.id, error });
     });
 
@@ -29,7 +29,7 @@ export const setupSocketHandlers = (io: Server) => {
       logger.info('Class updated', { class: data.class });
     });
 
-    socket.on('join-class', (classId: string, callback) => {
+    socket.on('join-class', (classId: string, callback: (classId: string) => void) => {
       try {
         socket.join(`class-${classId}`);
         logger.info('Client joined class room', { socketId: socket.id, classId });
@@ -42,7 +42,7 @@ export const setupSocketHandlers = (io: Server) => {
       } catch (error) {
         logger.error('Error joining class room', { socketId: socket.id, classId, error });
         if (callback) {
-          callback(null);
+          callback(classId);
         }
       }
     });

package/src/trpc.ts

@@ -1,11 +1,12 @@
 import { initTRPC, TRPCError } from '@trpc/server';
 import { ZodError } from 'zod';
-import { logger } from './utils/logger';
-import { prisma } from './lib/prisma';
-import { createLoggingMiddleware } from './middleware/logging';
-import { createAuthMiddleware } from './middleware/auth';
+import { logger } from './utils/logger.js';
+import { prisma } from './lib/prisma.js';
+import { createLoggingMiddleware } from './middleware/logging.js';
+import { createAuthMiddleware } from './middleware/auth.js';
 import { Request, Response } from 'express';
 import { z } from 'zod';
+import { handlePrismaError, PrismaErrorInfo } from './utils/prismaErrorHandler.js';
 
 interface CreateContextOptions {
   req: Request;
@@ -50,11 +51,22 @@ export const createTRPCContext = async (opts: CreateContextOptions): Promise<Con
 
 export const t = initTRPC.context<Context>().create({
   errorFormatter({ shape, error }) {
+    // Handle Prisma errors specifically
+    let prismaErrorInfo: PrismaErrorInfo | null = null;
+    if (error.cause) {
+      try {
+        prismaErrorInfo = handlePrismaError(error.cause);
+      } catch (e) {
+        // If Prisma error handling fails, continue with normal error handling
+      }
+    }
+
     logger.error('tRPC Error', {
       code: shape.code,
       message: error.message,
       cause: error.cause,
       stack: error.stack,
+      prismaError: prismaErrorInfo,
     });
 
     return {
@@ -63,6 +75,7 @@ export const t = initTRPC.context<Context>().create({
         ...shape.data,
         zodError:
           error.cause instanceof ZodError ? error.cause.flatten() : null,
+        prismaError: prismaErrorInfo,
       },
     };
   },

package/src/types/trpc.ts

@@ -1,5 +1,5 @@
 import { inferAsyncReturnType } from '@trpc/server';
-import { createTRPCContext } from '../trpc';
+import { createTRPCContext } from '../trpc.js';
 
 export type Context = inferAsyncReturnType<typeof createTRPCContext> & {
   isTeacher?: boolean;

package/src/utils/logger.ts

@@ -37,10 +37,13 @@ class Logger {
   private levelEmojis: Record<LogLevel, string>;
 
   private constructor() {
-    this.isDevelopment = process.env.NODE_ENV === 'development';
+
+    // this.isDevelopment = process.env.NODE_ENV === 'development';
+    this.isDevelopment = true;
 
     this.mode = (process.env.LOG_MODE as LogMode) || 'normal';
     
+
     this.levelColors = {
       [LogLevel.INFO]: colors.blue,
       [LogLevel.WARN]: colors.yellow,
@@ -107,9 +110,16 @@ class Logger {
   }
 
   private log(level: LogLevel, message: string, context?: Record<string, any>) {
-    // if (this.shouldLog(level)) 
-    //   return;    
-
+    if (!this.shouldLog(level)) 
+      return;    
+
+    if (level == LogLevel.WARN || level == LogLevel.ERROR) {
+      if (level == LogLevel.ERROR) {
+        // alert me
+      }
+      // store in database
+    }
+    
     const logMessage: LogMessage = {
       level,
       message,

package/src/utils/prismaErrorHandler.ts

@@ -0,0 +1,275 @@
+import { 
+  PrismaClientKnownRequestError, 
+  PrismaClientUnknownRequestError, 
+  PrismaClientValidationError 
+} from '@prisma/client/runtime/library';
+
+export interface PrismaErrorInfo {
+  message: string;
+  code?: string;
+  meta?: any;
+  details?: string;
+}
+
+export function handlePrismaError(error: unknown): PrismaErrorInfo {
+  // PrismaClientKnownRequestError - Database constraint violations, etc.
+  if (error instanceof PrismaClientKnownRequestError) {
+    return handleKnownRequestError(error);
+  }
+  
+  // PrismaClientValidationError - Invalid data format, missing required fields, etc.
+  if (error instanceof PrismaClientValidationError) {
+    return handleValidationError(error);
+  }
+  
+  // PrismaClientUnknownRequestError - Unknown database errors
+  if (error instanceof PrismaClientUnknownRequestError) {
+    return handleUnknownRequestError(error);
+  }
+  
+  // Generic error fallback
+  if (error instanceof Error) {
+    return {
+      message: error.message,
+      details: error.stack
+    };
+  }
+  
+  return {
+    message: 'An unknown database error occurred',
+    details: String(error)
+  };
+}
+
+function handleKnownRequestError(error: PrismaClientKnownRequestError): PrismaErrorInfo {
+  const { code, meta, message } = error;
+  
+  switch (code) {
+    case 'P2002':
+      const target = Array.isArray(meta?.target) ? meta.target.join(', ') : meta?.target || 'field';
+      return {
+        message: `A record with this ${target} already exists`,
+        code,
+        meta,
+        details: `Unique constraint violation on ${target}`
+      };
+      
+    case 'P2003':
+      const fieldName = meta?.field_name || 'related field';
+      return {
+        message: `Cannot delete this record because it's referenced by other records`,
+        code,
+        meta,
+        details: `Foreign key constraint violation on ${fieldName}`
+      };
+      
+    case 'P2025':
+      return {
+        message: 'The record you are trying to update or delete does not exist',
+        code,
+        meta,
+        details: 'Record not found in database'
+      };
+      
+    case 'P2014':
+      return {
+        message: 'The change you are trying to make would violate the required relationship',
+        code,
+        meta,
+        details: 'Required relation violation'
+      };
+      
+    case 'P2011':
+      return {
+        message: 'A required field is missing or empty',
+        code,
+        meta,
+        details: 'Null constraint violation'
+      };
+      
+    case 'P2012':
+      return {
+        message: 'The data you provided is not in the correct format',
+        code,
+        meta,
+        details: 'Data validation error'
+      };
+      
+    case 'P2013':
+      return {
+        message: 'The data you provided is too long for this field',
+        code,
+        meta,
+        details: 'String length constraint violation'
+      };
+      
+    case 'P2015':
+      return {
+        message: 'The record you are looking for could not be found',
+        code,
+        meta,
+        details: 'Record not found'
+      };
+      
+    case 'P2016':
+      return {
+        message: 'The query you are trying to execute is not valid',
+        code,
+        meta,
+        details: 'Query interpretation error'
+      };
+      
+    case 'P2017':
+      return {
+        message: 'The relationship between records is not properly connected',
+        code,
+        meta,
+        details: 'Relation connection error'
+      };
+      
+    case 'P2018':
+      return {
+        message: 'The connected record you are looking for does not exist',
+        code,
+        meta,
+        details: 'Connected record not found'
+      };
+      
+    case 'P2019':
+      return {
+        message: 'The input you provided is not valid',
+        code,
+        meta,
+        details: 'Input error'
+      };
+      
+    case 'P2020':
+      return {
+        message: 'The value you provided is outside the allowed range',
+        code,
+        meta,
+        details: 'Value out of range'
+      };
+      
+    case 'P2021':
+      return {
+        message: 'The table you are trying to access does not exist',
+        code,
+        meta,
+        details: 'Table does not exist'
+      };
+      
+    case 'P2022':
+      return {
+        message: 'The column you are trying to access does not exist',
+        code,
+        meta,
+        details: 'Column does not exist'
+      };
+      
+    case 'P2023':
+      return {
+        message: 'The column data is not valid',
+        code,
+        meta,
+        details: 'Column data validation error'
+      };
+      
+    case 'P2024':
+      return {
+        message: 'The database connection pool is exhausted',
+        code,
+        meta,
+        details: 'Connection pool timeout'
+      };
+      
+    case 'P2026':
+      return {
+        message: 'The current database provider does not support this feature',
+        code,
+        meta,
+        details: 'Feature not supported by database provider'
+      };
+      
+    case 'P2027':
+      return {
+        message: 'Multiple errors occurred during the database operation',
+        code,
+        meta,
+        details: 'Multiple errors in query execution'
+      };
+      
+    default:
+      return {
+        message: 'A database constraint was violated',
+        code,
+        meta,
+        details: message
+      };
+  }
+}
+
+function handleValidationError(error: PrismaClientValidationError): PrismaErrorInfo {
+  return {
+    message: 'The data you provided is not valid',
+    details: error.message,
+    meta: {
+      type: 'validation_error',
+      originalMessage: error.message
+    }
+  };
+}
+
+function handleUnknownRequestError(error: PrismaClientUnknownRequestError): PrismaErrorInfo {
+  return {
+    message: 'An unexpected database error occurred',
+    details: error.message,
+    meta: {
+      type: 'unknown_request_error',
+      originalMessage: error.message
+    }
+  };
+}
+
+// Helper function to get user-friendly field names
+export function getFieldDisplayName(fieldName: string): string {
+  const fieldMap: Record<string, string> = {
+    'username': 'username',
+    'email': 'email address',
+    'password': 'password',
+    'name': 'name',
+    'title': 'title',
+    'content': 'content',
+    'description': 'description',
+    'subject': 'subject',
+    'section': 'section',
+    'color': 'color',
+    'location': 'location',
+    'startTime': 'start time',
+    'endTime': 'end time',
+    'dueDate': 'due date',
+    'maxGrade': 'maximum grade',
+    'grade': 'grade',
+    'feedback': 'feedback',
+    'remarks': 'remarks',
+    'syllabus': 'syllabus',
+    'path': 'file path',
+    'size': 'file size',
+    'type': 'file type',
+    'uploadedAt': 'upload date',
+    'verified': 'verification status',
+    'profileId': 'profile',
+    'schoolId': 'school',
+    'classId': 'class',
+    'assignmentId': 'assignment',
+    'submissionId': 'submission',
+    'userId': 'user',
+    'eventId': 'event',
+    'sessionId': 'session',
+    'thumbnailId': 'thumbnail',
+    'annotationId': 'annotation',
+    'logoId': 'logo'
+  };
+  
+  return fieldMap[fieldName] || fieldName;
+} 

package/src/utils/prismaWrapper.ts

@@ -0,0 +1,91 @@
+import { TRPCError } from '@trpc/server';
+import { handlePrismaError } from './prismaErrorHandler.js';
+
+export async function withPrismaErrorHandling<T>(
+  operation: () => Promise<T>,
+  context: string = 'database operation'
+): Promise<T> {
+  try {
+    return await operation();
+  } catch (error) {
+    const prismaErrorInfo = handlePrismaError(error);
+    
+    // Log the detailed error for debugging
+    console.error(`Prisma error in ${context}:`, {
+      userMessage: prismaErrorInfo.message,
+      details: prismaErrorInfo.details,
+      code: prismaErrorInfo.code,
+      meta: prismaErrorInfo.meta,
+      originalError: error
+    });
+
+    // Throw a tRPC error with the user-friendly message
+    throw new TRPCError({
+      code: getTRPCCode(prismaErrorInfo.code),
+      message: prismaErrorInfo.message,
+      cause: error
+    });
+  }
+}
+
+function getTRPCCode(prismaCode?: string): TRPCError['code'] {
+  if (!prismaCode) return 'INTERNAL_SERVER_ERROR';
+  
+  // Map Prisma error codes to tRPC error codes
+  const codeMap: Record<string, TRPCError['code']> = {
+    'P2002': 'CONFLICT',        // Unique constraint violation
+    'P2003': 'BAD_REQUEST',     // Foreign key constraint violation
+    'P2025': 'NOT_FOUND',       // Record not found
+    'P2014': 'BAD_REQUEST',     // Required relation violation
+    'P2011': 'BAD_REQUEST',     // Null constraint violation
+    'P2012': 'BAD_REQUEST',     // Data validation error
+    'P2013': 'BAD_REQUEST',     // String length constraint violation
+    'P2015': 'NOT_FOUND',       // Record not found
+    'P2016': 'BAD_REQUEST',     // Query interpretation error
+    'P2017': 'BAD_REQUEST',     // Relation connection error
+    'P2018': 'NOT_FOUND',       // Connected record not found
+    'P2019': 'BAD_REQUEST',     // Input error
+    'P2020': 'BAD_REQUEST',     // Value out of range
+    'P2021': 'INTERNAL_SERVER_ERROR', // Table does not exist
+    'P2022': 'INTERNAL_SERVER_ERROR', // Column does not exist
+    'P2023': 'BAD_REQUEST',     // Column data validation error
+    'P2024': 'INTERNAL_SERVER_ERROR', // Connection pool timeout
+    'P2026': 'INTERNAL_SERVER_ERROR', // Feature not supported
+    'P2027': 'INTERNAL_SERVER_ERROR', // Multiple errors
+  };
+  
+  return codeMap[prismaCode] || 'INTERNAL_SERVER_ERROR';
+}
+
+// Convenience functions for common operations
+export const prismaWrapper = {
+  findUnique: <T>(operation: () => Promise<T | null>, context?: string) =>
+    withPrismaErrorHandling(operation, context),
+    
+  findFirst: <T>(operation: () => Promise<T | null>, context?: string) =>
+    withPrismaErrorHandling(operation, context),
+    
+  findMany: <T>(operation: () => Promise<T[]>, context?: string) =>
+    withPrismaErrorHandling(operation, context),
+    
+  create: <T>(operation: () => Promise<T>, context?: string) =>
+    withPrismaErrorHandling(operation, context),
+    
+  update: <T>(operation: () => Promise<T>, context?: string) =>
+    withPrismaErrorHandling(operation, context),
+    
+  delete: <T>(operation: () => Promise<T>, context?: string) =>
+    withPrismaErrorHandling(operation, context),
+    
+  deleteMany: <T>(operation: () => Promise<T>, context?: string) =>
+    withPrismaErrorHandling(operation, context),
+    
+  upsert: <T>(operation: () => Promise<T>, context?: string) =>
+    withPrismaErrorHandling(operation, context),
+    
+  count: <T>(operation: () => Promise<T>, context?: string) =>
+    withPrismaErrorHandling(operation, context),
+    
+  aggregate: <T>(operation: () => Promise<T>, context?: string) =>
+    withPrismaErrorHandling(operation, context),
+};