@studious-lms/server 1.0.1 → 1.0.3

package/src/routers/section.ts

@@ -0,0 +1,138 @@
+import { z } from "zod";
+import { createTRPCRouter, protectedProcedure } from "../trpc";
+import { TRPCError } from "@trpc/server";
+import { prisma } from "../lib/prisma";
+
+const createSectionSchema = z.object({
+  classId: z.string(),
+  name: z.string(),
+});
+
+const updateSectionSchema = z.object({
+  id: z.string(),
+  classId: z.string(),
+  name: z.string(),
+});
+
+const deleteSectionSchema = z.object({
+  id: z.string(),
+  classId: z.string(),
+});
+
+export const sectionRouter = createTRPCRouter({
+  create: protectedProcedure
+    .input(createSectionSchema)
+    .mutation(async ({ ctx, input }) => {
+      if (!ctx.user) {
+        throw new TRPCError({
+          code: "UNAUTHORIZED",
+          message: "User must be authenticated",
+        });
+      }
+
+      // Verify user is a teacher of the class
+      const classData = await prisma.class.findFirst({
+        where: {
+          id: input.classId,
+          teachers: {
+            some: {
+              id: ctx.user.id,
+            },
+          },
+        },
+      });
+
+      if (!classData) {
+        throw new TRPCError({
+          code: "NOT_FOUND",
+          message: "Class not found or you are not a teacher",
+        });
+      }
+
+      const section = await prisma.section.create({
+        data: {
+          name: input.name,
+          class: {
+            connect: { id: input.classId },
+          },
+        },
+      });
+
+      return section;
+    }),
+
+  update: protectedProcedure
+    .input(updateSectionSchema)
+    .mutation(async ({ ctx, input }) => {
+      if (!ctx.user) {
+        throw new TRPCError({
+          code: "UNAUTHORIZED",
+          message: "User must be authenticated",
+        });
+      }
+
+      // Verify user is a teacher of the class
+      const classData = await prisma.class.findFirst({
+        where: {
+          id: input.classId,
+          teachers: {
+            some: {
+              id: ctx.user.id,
+            },
+          },
+        },
+      });
+
+      if (!classData) {
+        throw new TRPCError({
+          code: "NOT_FOUND",
+          message: "Class not found or you are not a teacher",
+        });
+      }
+
+      const section = await prisma.section.update({
+        where: { id: input.id },
+        data: {
+          name: input.name,
+        },
+      });
+
+      return section;
+    }),
+
+  delete: protectedProcedure
+    .input(deleteSectionSchema)
+    .mutation(async ({ ctx, input }) => {
+      if (!ctx.user) {
+        throw new TRPCError({
+          code: "UNAUTHORIZED",
+          message: "User must be authenticated",
+        });
+      }
+
+      // Verify user is a teacher of the class
+      const classData = await prisma.class.findFirst({
+        where: {
+          id: input.classId,
+          teachers: {
+            some: {
+              id: ctx.user.id,
+            },
+          },
+        },
+      });
+
+      if (!classData) {
+        throw new TRPCError({
+          code: "NOT_FOUND",
+          message: "Class not found or you are not a teacher",
+        });
+      }
+
+      await prisma.section.delete({
+        where: { id: input.id },
+      });
+
+      return { id: input.id };
+    }),
+}); 

package/src/routers/user.ts

@@ -0,0 +1,82 @@
+import { z } from "zod";
+import { createTRPCRouter, protectedProcedure } from "../trpc";
+import { TRPCError } from "@trpc/server";
+import { prisma } from "../lib/prisma";
+import { uploadFiles, type UploadedFile } from "../lib/fileUpload";
+
+const fileSchema = z.object({
+  name: z.string(),
+  type: z.string(),
+  size: z.number(),
+  data: z.string(), // base64 encoded file data
+});
+
+const updateProfileSchema = z.object({
+  profile: z.record(z.any()),
+  profilePicture: fileSchema.optional(),
+});
+
+export const userRouter = createTRPCRouter({
+  getProfile: protectedProcedure
+    .query(async ({ ctx }) => {
+      if (!ctx.user) {
+        throw new TRPCError({
+          code: "UNAUTHORIZED",
+          message: "User must be authenticated",
+        });
+      }
+
+      const user = await prisma.user.findUnique({
+        where: { id: ctx.user.id },
+        select: {
+          id: true,
+          username: true,
+          profile: true,
+        },
+      });
+
+      if (!user) {
+        throw new TRPCError({
+          code: "NOT_FOUND",
+          message: "User not found",
+        });
+      }
+
+      return user;
+    }),
+
+  updateProfile: protectedProcedure
+    .input(updateProfileSchema)
+    .mutation(async ({ ctx, input }) => {
+      if (!ctx.user) {
+        throw new TRPCError({
+          code: "UNAUTHORIZED",
+          message: "User must be authenticated",
+        });
+      }
+
+      let uploadedFiles: UploadedFile[] = [];
+      if (input.profilePicture) {
+        // Store profile picture in a user-specific directory
+        uploadedFiles = await uploadFiles([input.profilePicture], ctx.user.id, `users/${ctx.user.id}/profile`);
+        
+        // Add profile picture path to profile data
+        input.profile.profilePicture = uploadedFiles[0].path;
+        input.profile.profilePictureThumbnail = uploadedFiles[0].thumbnailId;
+      }
+
+      const updatedUser = await prisma.user.update({
+        where: { id: ctx.user.id },
+        data: {
+          profile: input.profile,
+        },
+        select: {
+          id: true,
+          username: true,
+          profile: true,
+        },
+      });
+
+      return updatedUser;
+    }),
+}); 

package/src/socket/handlers.ts

@@ -0,0 +1,143 @@
+import { Socket, Server } from 'socket.io';
+import { logger } from '../utils/logger';
+
+export const setupSocketHandlers = (io: Server) => {
+  io.on('connection', (socket: Socket) => {
+    logger.info('Client connected', { socketId: socket.id });
+
+    socket.on('disconnect', (reason) => {
+      logger.info('Client disconnected', { socketId: socket.id, reason });
+    });
+
+    socket.on('error', (error) => {
+      logger.error('Socket error', { socketId: socket.id, error });
+    });
+
+    // Class Room Management
+    socket.on('create-class', (data: { class: any }) => {
+      io.emit('class-created', data.class);
+      logger.info('Class created', { class: data.class });
+    });
+
+    socket.on('delete-class', (data: { classId: string }) => {
+      io.emit('class-deleted', data.classId);
+      logger.info('Class deleted', { classId: data.classId });
+    });
+
+    socket.on('update-class', (data: { class: any }) => {
+      io.emit('class-updated', data.class);
+      logger.info('Class updated', { class: data.class });
+    });
+
+    socket.on('join-class', (classId: string, callback) => {
+      try {
+        socket.join(`class-${classId}`);
+        logger.info('Client joined class room', { socketId: socket.id, classId });
+        
+        if (callback) {
+          callback(classId);
+        } else {
+          socket.emit('joined-class', classId);
+        }
+      } catch (error) {
+        logger.error('Error joining class room', { socketId: socket.id, classId, error });
+        if (callback) {
+          callback(null);
+        }
+      }
+    });
+
+    // Assignment Events
+    socket.on('assignment-create', (data: { classId: string, assignment: any }) => {
+      if (data.classId && data.assignment) {
+        io.in(`class-${data.classId}`).emit('assignment-created', data.assignment);
+        logger.info('Assignment created', { classId: data.classId, assignmentId: data.assignment.id });
+      } else {
+        logger.error('Invalid assignment data format', { data });
+      }
+    });
+
+    socket.on('assignment-update', (data: { classId: string, assignment: any }) => {
+      io.in(`class-${data.classId}`).emit('assignment-updated', data.assignment);
+      logger.info('Assignment updated', { classId: data.classId, assignmentId: data.assignment.id });
+    });
+
+    socket.on('assignment-delete', (data: { classId: string, assignmentId: string }) => {
+      io.in(`class-${data.classId}`).emit('assignment-deleted', data.assignmentId);
+      logger.info('Assignment deleted', { classId: data.classId, assignmentId: data.assignmentId });
+    });
+
+    // Submission Events
+    socket.on('submission-update', (data: { classId: string, submission: any }) => {
+      io.in(`class-${data.classId}`).emit('submission-updated', data.submission);
+      logger.info('Submission updated', { classId: data.classId, submissionId: data.submission.id });
+    });
+
+    // Announcement Events
+    socket.on('new-announcement', (data: { classId: string, announcement: any }) => {
+      io.in(`class-${data.classId}`).emit('announcement-created', data.announcement);
+      logger.info('New announcement created', { classId: data.classId, announcementId: data.announcement.id });
+    });
+
+    // Section Events
+    socket.on('section-create', (data: { classId: string, section: any }) => {
+      io.in(`class-${data.classId}`).emit('section-created', data.section);
+      logger.info('Section created', { classId: data.classId, sectionId: data.section.id });
+    });
+
+    socket.on('section-update', (data: { classId: string, section: any }) => {
+      io.in(`class-${data.classId}`).emit('section-updated', data.section);
+      logger.info('Section updated', { classId: data.classId, sectionId: data.section.id });
+    });
+
+    socket.on('section-delete', (data: { classId: string, sectionId: string }) => {
+      io.in(`class-${data.classId}`).emit('section-deleted', data.sectionId);
+      logger.info('Section deleted', { classId: data.classId, sectionId: data.sectionId });
+    });
+
+    // Member Events
+    socket.on('member-update', (data: { classId: string, member: any }) => {
+      io.in(`class-${data.classId}`).emit('member-updated', data.member);
+      logger.info('Member updated', { classId: data.classId, memberId: data.member.id });
+    });
+
+    socket.on('member-delete', (data: { classId: string, memberId: string }) => {
+      io.in(`class-${data.classId}`).emit('member-deleted', data.memberId);
+      logger.info('Member deleted', { classId: data.classId, memberId: data.memberId });
+    });
+
+    // Attendance Events
+    socket.on('attendance-update', (data: { classId: string, attendance: any }) => {
+      io.in(`class-${data.classId}`).emit('attendance-updated', data.attendance);
+      logger.info('Attendance updated', { classId: data.classId, attendanceId: data.attendance.id });
+    });
+
+    // Event Events
+    socket.on('event-create', (data: { classId: string, event: any }) => {
+      if (data.classId) {
+        io.in(`class-${data.classId}`).emit('event-created', data.event);
+      } else {
+        io.emit('event-created', data.event);
+      }
+      logger.info('Event created', { classId: data.classId, eventId: data.event.id });
+    });
+
+    socket.on('event-update', (data: { classId: string, event: any }) => {
+      if (data.classId) {
+        io.in(`class-${data.classId}`).emit('event-updated', data.event);
+      } else {
+        io.emit('event-updated', data.event);
+      }
+      logger.info('Event updated', { classId: data.classId, eventId: data.event.id });
+    });
+
+    socket.on('event-delete', (data: { classId: string, eventId: string }) => {
+      if (data.classId) {
+        io.in(`class-${data.classId}`).emit('event-deleted', data.eventId);
+      } else {
+        io.emit('event-deleted', data.eventId);
+      }
+      logger.info('Event deleted', { classId: data.classId, eventId: data.eventId });
+    });
+  });
+}; 

package/src/trpc.ts

@@ -0,0 +1,90 @@
+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 { Request, Response } from 'express';
+import { z } from 'zod';
+
+interface CreateContextOptions {
+  req: Request;
+  res: Response;
+}
+
+export type Context = {
+  req: Request;
+  res: Response;
+  user: { id: string } | null;
+  meta?: {
+    classId?: string;
+    institutionId?: string;
+  };
+};
+
+export const createTRPCContext = async (opts: CreateContextOptions): Promise<Context> => {
+  const { req, res } = opts;
+  
+  // Get user from session/token
+  const token = req.headers.authorization?.split(' ')[1];
+  const user = token ? await prisma.user.findFirst({
+    where: {
+      sessions: {
+        some: {
+          id: token
+        }
+      },
+    },
+    select: {
+      id: true,
+    }
+  }) : null;
+  
+  return {
+    req,
+    res,
+    user,
+    meta: {},
+  };
+};
+
+export const t = initTRPC.context<Context>().create({
+  errorFormatter({ shape, error }) {
+    logger.error('tRPC Error', {
+      code: shape.code,
+      message: error.message,
+      cause: error.cause,
+      stack: error.stack,
+    });
+
+    return {
+      ...shape,
+      data: {
+        ...shape.data,
+        zodError:
+          error.cause instanceof ZodError ? error.cause.flatten() : null,
+      },
+    };
+  },
+});
+
+// Create middleware
+const loggingMiddleware = createLoggingMiddleware(t);
+const { isAuthed, isMemberInClass, isTeacherInClass } = createAuthMiddleware(t);
+
+// Base procedures
+export const createTRPCRouter = t.router;
+export const publicProcedure = t.procedure.use(loggingMiddleware);
+
+// Protected procedures
+export const protectedProcedure = publicProcedure.use(isAuthed);
+export const protectedClassMemberProcedure = protectedProcedure
+  .input(z.object({ classId: z.string() }).passthrough())
+  .use(isMemberInClass);
+export const protectedTeacherProcedure = protectedProcedure
+  .input(z.object({ classId: z.string() }).passthrough())
+  .use(isTeacherInClass);
+
+
+// Create caller factory
+export const createCallerFactory = t.createCallerFactory; 

package/src/types/trpc.ts

@@ -0,0 +1,15 @@
+import { inferAsyncReturnType } from '@trpc/server';
+import { createTRPCContext } from '../trpc';
+
+export type Context = inferAsyncReturnType<typeof createTRPCContext> & {
+  isTeacher?: boolean;
+  teacherClassIds?: string[];
+};
+
+export interface MiddlewareContext {
+  ctx: Context;
+  next: (opts?: { ctx: Partial<Context> }) => Promise<any>;
+  input?: any;
+  path?: string;
+  type?: string;
+} 

package/src/utils/email.ts

@@ -0,0 +1,11 @@
+import nodemailer from 'nodemailer';
+
+export const transport = nodemailer.createTransport({
+    host: process.env.EMAIL_HOST,
+    port: 587,
+    secure: false,
+    auth: {
+      user: process.env.EMAIL_USER,
+      pass: process.env.EMAIL_PASS,
+    },
+  });

package/src/utils/generateInviteCode.ts

@@ -0,0 +1,8 @@
+/**
+ * Generates a random invite code
+ * @returns {string} The invite code with length 5
+ */
+
+export const generateInviteCode = () => {
+    return (Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15)).slice(0, 5);
+}

package/src/utils/logger.ts

@@ -0,0 +1,156 @@
+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>;
+}
+
+// ANSI color codes
+const colors = {
+  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'
+};
+
+class Logger {
+  private static instance: Logger;
+  private isDevelopment: boolean;
+  private mode: LogMode;
+  private levelColors: Record<LogLevel, string>;
+  private levelEmojis: Record<LogLevel, string>;
+
+  private constructor() {
+    this.isDevelopment = process.env.NODE_ENV === 'development';
+
+    this.mode = (process.env.LOG_MODE as LogMode) || 'normal';
+    
+    this.levelColors = {
+      [LogLevel.INFO]: colors.blue,
+      [LogLevel.WARN]: colors.yellow,
+      [LogLevel.ERROR]: colors.red,
+      [LogLevel.DEBUG]: colors.magenta
+    };
+
+    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 {
+    const { level, message, timestamp, context } = logMessage;
+    const color = this.levelColors[level];
+    const emoji = this.levelEmojis[level];
+    
+    const timestampStr = colors.gray + `[${timestamp}]` + colors.reset;
+    const levelStr = color + `[${level.toUpperCase()}]` + colors.reset;
+    const emojiStr = emoji + ' ';
+    const messageStr = colors.bright + message + colors.reset;
+    
+    const contextStr = context 
+      ? '\n' + colors.dim + 'Context: ' + JSON.stringify(context, null, 2) + colors.reset
+      : '';
+
+    return `${timestampStr} ${levelStr} ${emojiStr}${messageStr}${contextStr}`;
+  }
+
+  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(formattedMessage);
+        break;
+      case LogLevel.WARN:
+        console.warn(formattedMessage);
+        break;
+      case LogLevel.DEBUG:
+        if (this.isDevelopment) {
+          console.debug(formattedMessage);
+        }
+        break;
+      default:
+        console.log(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/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "dist",
+    "baseUrl": ".", 
+    "declaration": true,
+    "declarationMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+} 

package/generated/prisma/client.d.ts

@@ -1 +0,0 @@
-export * from "./index"

package/generated/prisma/client.js

@@ -1,4 +0,0 @@
-
-/* !!! This is code generated by Prisma. Do not edit directly. !!!
-/* eslint-disable */
-module.exports = { ...require('.') }

package/generated/prisma/default.d.ts

@@ -1 +0,0 @@
-export * from "./index"

package/generated/prisma/default.js

@@ -1,4 +0,0 @@
-
-/* !!! This is code generated by Prisma. Do not edit directly. !!!
-/* eslint-disable */
-module.exports = { ...require('.') }

package/generated/prisma/edge.d.ts

@@ -1 +0,0 @@
-export * from "./default"