@studious-lms/server 1.0.2 → 1.0.4

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

package/src/routers/announcement.ts

@@ -0,0 +1,134 @@
+import { z } from "zod";
+import { createTRPCRouter, protectedClassMemberProcedure, protectedTeacherProcedure, protectedProcedure } from "../trpc";
+import { prisma } from "../lib/prisma";
+import { TRPCError } from "@trpc/server";
+
+const AnnouncementSelect = {
+    id: true,
+    teacher: {
+        select: {
+            id: true,
+            username: true,
+        },
+    },
+    remarks: true,
+    createdAt: true,
+};
+
+export const announcementRouter = createTRPCRouter({
+    getAll: protectedClassMemberProcedure
+        .input(z.object({
+            classId: z.string(),
+        }))
+        .query(async ({ ctx, input }) => {
+            const announcements = await prisma.announcement.findMany({
+                where: {
+                    classId: input.classId,
+                },
+                select: AnnouncementSelect,
+                orderBy: {
+                    createdAt: 'desc',
+                },
+            });
+
+            return {
+                announcements,
+            };
+        }),
+
+    create: protectedTeacherProcedure
+        .input(z.object({
+            classId: z.string(),
+            remarks: z.string(),
+        }))
+        .mutation(async ({ ctx, input }) => {
+            const announcement = await prisma.announcement.create({
+                data: {
+                    remarks: input.remarks,
+                    teacher: {
+                        connect: {
+                            id: ctx.user?.id,
+                        },
+                    },
+                    class: {
+                        connect: {
+                            id: input.classId,
+                        },
+                    },
+                },
+                select: AnnouncementSelect,
+            });
+
+            return {
+                announcement,
+            };
+        }),
+
+    update: protectedProcedure
+        .input(z.object({
+            id: z.string(),
+            data: z.object({
+                content: z.string(),
+            }),
+        }))
+        .mutation(async ({ ctx, input }) => {
+
+            const announcement = await prisma.announcement.findUnique({
+                where: { id: input.id },
+                include: {
+                    class: {
+                        include: {
+                            teachers: true,
+                        },
+                    },
+                },
+            });
+
+            if (!announcement) {
+                throw new TRPCError({
+                    code: "NOT_FOUND",
+                    message: "Announcement not found",
+                });
+            }
+
+            const updatedAnnouncement = await prisma.announcement.update({
+                where: { id: input.id },
+                data: {
+                    remarks: input.data.content,
+                },
+            });
+
+            return { announcement: updatedAnnouncement };
+        }),
+
+    delete: protectedProcedure
+        .input(z.object({
+            id: z.string(),
+        }))
+        .mutation(async ({ ctx, input }) => {
+
+            const announcement = await prisma.announcement.findUnique({
+                where: { id: input.id },
+                include: {
+                    class: {
+                        include: {
+                            teachers: true,
+                        },
+                    },
+                },
+            });
+
+            if (!announcement) {
+                throw new TRPCError({
+                    code: "NOT_FOUND",
+                    message: "Announcement not found",
+                });
+            }
+
+            await prisma.announcement.delete({
+                where: { id: input.id },
+            });
+
+            return { success: true };
+        }),
+});