@studious-lms/server 1.0.2 → 1.0.3

package/package.json

@@ -1,14 +1,9 @@
 {
   "name": "@studious-lms/server",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Backend server for Studious application",
   "main": "dist/exportType.js",
   "types": "dist/exportType.d.ts",
-  "files": [
-    "dist/**/*",
-    "generated/**/*",
-    "README.md"
-  ],
   "scripts": {
     "dev": "ts-node-dev -r tsconfig-paths/register --respawn --transpile-only src/index.ts",
     "build": "tsc",

package/prisma/schema.prisma

@@ -0,0 +1,228 @@
+// This is your Prisma schema file,
+// learn more about it in the docs: https://pris.ly/d/prisma-schema
+
+// Looking for ways to speed up your queries, or scale easily with your serverless or edge functions?
+// Try Prisma Accelerate: https://pris.ly/cli/accelerate-init
+
+generator client {
+  provider = "prisma-client-js"
+  // output   = "../generated/prisma"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+enum AssignmentType {
+  HOMEWORK
+  QUIZ
+  TEST
+  PROJECT
+  ESSAY
+  DISCUSSION
+  PRESENTATION
+  LAB
+  OTHER
+}
+
+
+model User {
+  id           String      @id @default(uuid())
+  username     String
+  email        String
+  password     String
+  profile      UserProfile?
+  verified     Boolean     @default(false)
+
+  profileId    String?     @unique
+
+  teacherIn   Class[] @relation("UserTeacherToClass")
+  studentIn   Class[] @relation("UserStudentToClass")
+
+  submissions Submission[]
+  sessions    Session[]
+  files       File[]
+  assignments Assignment[]
+  events      Event[]
+  announcements Announcement[]
+
+  presentAttendance  Attendance[] @relation("PresentAttendance")
+  lateAttendance    Attendance[] @relation("LateAttendance")
+  absentAttendance  Attendance[] @relation("AbsentAttendance")
+}
+
+model UserProfile {
+  id String @id @default(uuid())
+  userId String @unique
+  user User? @relation(fields: [userId], references: [id])
+
+} 
+
+model Class {
+  id            String         @id @default(uuid())
+  name          String
+  subject       String
+  color         String?        @default("#3B82F6")
+  section       String
+  announcements Announcement[]
+  assignments   Assignment[]
+  attendance    Attendance[]
+  events        Event[]
+  sections      Section[]
+  sessions      Session[]
+  students      User[]         @relation("UserStudentToClass")
+  teachers      User[]         @relation("UserTeacherToClass")
+  markSchemes   MarkScheme[] @relation("ClassToMarkScheme")
+  gradingBoundaries GradingBoundary[] @relation("ClassToGradingBoundary")
+}
+
+model MarkScheme {
+  id String @id @default(uuid())
+  classId String
+  class Class[] @relation("ClassToMarkScheme")
+  structured String
+  assignments Assignment[]
+}
+
+model GradingBoundary {
+  id String @id @default(uuid())
+  classId String
+  class Class[] @relation("ClassToGradingBoundary")
+  structured String
+  assignments Assignment[]
+}
+
+model File {
+  id         String @id @default(uuid())
+  name       String
+  path       String
+  size       Int?
+  type       String
+  user       User? @relation(fields: [userId], references: [id])
+  userId     String?
+  uploadedAt DateTime? @default(now())
+
+  // Thumbnail relationship
+  thumbnail   File?  @relation("Thumbnail", fields: [thumbnailId], references: [id])
+  thumbnailId String? @unique
+  originalFile File? @relation("Thumbnail")
+
+  assignment Assignment? @relation(fields: [assignmentId], references: [id], onDelete: Cascade)
+  assignmentId String?
+
+  submission Submission? @relation("SubmissionFile", fields: [submissionId], references: [id], onDelete: Cascade)
+  submissionId String?
+
+  annotations Submission? @relation("SubmissionAnnotations", fields: [annotationId], references: [id], onDelete: Cascade)
+  annotationId String?
+}
+
+model Assignment {
+  id            String         @id @default(uuid())
+  title         String
+  instructions  String
+  dueDate       DateTime
+  createdAt     DateTime?      @default(now())
+  modifiedAt    DateTime?      @updatedAt
+  teacher       User           @relation(fields: [teacherId], references: [id], onDelete: NoAction)
+  teacherId     String
+  class         Class          @relation(fields: [classId], references: [id], onDelete: Cascade)
+  classId       String
+  attachments   File[]
+  submissions   Submission[]
+  section       Section?       @relation(fields: [sectionId], references: [id], onDelete: Cascade)
+  sectionId     String?
+  graded        Boolean        @default(false)
+  maxGrade      Int?          @default(0)
+  weight        Float         @default(1)
+  type          AssignmentType @default(HOMEWORK)
+  eventAttached Event?        @relation(fields: [eventId], references: [id], onDelete: NoAction)
+  eventId       String?
+  markScheme    MarkScheme? @relation(fields: [markSchemeId], references: [id], onDelete: Cascade)
+  markSchemeId  String?
+  gradingBoundary GradingBoundary? @relation(fields: [gradingBoundaryId], references: [id], onDelete: Cascade)
+  gradingBoundaryId String?
+}
+
+model Announcement {
+  id      String @id @default(uuid())
+  remarks String
+  teacher User @relation(fields: [teacherId], references: [id])
+  teacherId String
+  createdAt DateTime @default(now())
+  class   Class @relation(fields: [classId], references: [id], onDelete: Cascade)
+  classId String
+}
+
+model Submission {
+  id      String @id @default(uuid())
+  createdAt DateTime @default(now())
+  modifiedAt DateTime @default(now())
+
+  assignment Assignment @relation(fields: [assignmentId], references: [id], onDelete: Cascade)
+  assignmentId String
+
+  student User @relation(fields: [studentId], references: [id])
+  studentId String
+
+  attachments File[]  @relation("SubmissionFile")
+  annotations File[]  @relation("SubmissionAnnotations")
+
+  gradeReceived Int?
+
+  rubricState String?
+
+  submittedAt DateTime?
+  submitted   Boolean? @default(false)
+  returned    Boolean? @default(false)
+}
+
+model Section {
+  id        String @id @default(uuid())
+  name      String
+  classId   String
+  class     Class @relation(fields: [classId], references: [id], onDelete: Cascade)
+  assignments Assignment[]
+}
+
+model Session {
+  id        String @id @default(uuid())
+  createdAt DateTime? @default(now())
+  expiresAt DateTime?
+  userId    String?
+  user      User? @relation(fields: [userId], references: [id], onDelete: NoAction)
+  classId   String?
+  class     Class? @relation(fields: [classId], references: [id], onDelete: Cascade)
+}
+
+model Event {
+  id        String @id @default(uuid())
+  name      String?
+  startTime DateTime
+  endTime   DateTime
+  location  String?
+  remarks   String?
+  userId    String?
+  user      User? @relation(fields: [userId], references: [id], onDelete: Cascade)
+  classId   String?
+  class     Class? @relation(fields: [classId], references: [id], onDelete: Cascade)
+  color         String? @default("#3B82F6")
+  assignmentsAttached Assignment[]
+  attendance Attendance[]
+}
+
+model Attendance {
+  id        String   @id @default(uuid())
+  date      DateTime @default(now())
+  
+  class     Class    @relation(fields: [classId], references: [id], onDelete: Cascade)
+  classId   String
+
+  event     Event?   @relation(fields: [eventId], references: [id], onDelete: Cascade)
+  eventId   String?
+
+  present   User[]   @relation("PresentAttendance")
+  late      User[]   @relation("LateAttendance")
+  absent    User[]   @relation("AbsentAttendance")
+}

package/src/exportType.ts

@@ -0,0 +1,9 @@
+/**
+ * Export types for the server
+ * This is used to export the types for the server
+ * to the client via npmjs
+ */
+
+export type { AppRouter } from "./routers/_app";
+export type { RouterInputs } from "./routers/_app";
+export type { RouterOutputs } from "./routers/_app";

package/src/index.ts

@@ -0,0 +1,94 @@
+import express from 'express';
+import type { Request, Response } from 'express';
+import { createServer } from 'http';
+import { Server } from 'socket.io';
+import cors from 'cors';
+import dotenv from 'dotenv';
+import { createExpressMiddleware } from '@trpc/server/adapters/express';
+import { appRouter } from './routers/_app';
+import { createTRPCContext, createCallerFactory } from './trpc';
+import { logger } from './utils/logger';
+import { setupSocketHandlers } from './socket/handlers';
+
+dotenv.config();
+
+const app = express();
+
+// CORS middleware
+app.use(cors({
+  origin: process.env.NEXT_PUBLIC_APP_URL || 'http://localhost:3000',
+  credentials: true,
+}));
+
+// Response time logging middleware
+app.use((req, res, next) => {
+  const start = Date.now();
+  res.on('finish', () => {
+    const duration = Date.now() - start;
+    logger.info('Request completed', {
+      method: req.method,
+      path: req.path,
+      statusCode: res.statusCode,
+      duration: `${duration}ms`
+    });
+  });
+  next();
+});
+
+// Create HTTP server
+const httpServer = createServer(app);
+
+// Setup Socket.IO
+const io = new Server(httpServer, {
+  cors: {
+    origin: process.env.NEXT_PUBLIC_APP_URL || 'http://localhost:3000',
+    methods: ['GET', 'POST'],
+    credentials: true,
+    allowedHeaders: ['Access-Control-Allow-Origin']
+  },
+  transports: ['websocket', 'polling'],
+  pingTimeout: 60000,
+  pingInterval: 25000,
+  connectTimeout: 45000,
+  path: '/socket.io/',
+  allowEIO3: true
+});
+
+// Add server-level logging
+io.engine.on('connection_error', (err) => {
+  logger.error('Socket connection error', { error: err.message });
+});
+
+// Setup socket handlers
+setupSocketHandlers(io);
+
+// Create caller
+const createCaller = createCallerFactory(appRouter);
+
+// Setup tRPC middleware
+app.use(
+  '/trpc',
+  createExpressMiddleware({
+    router: appRouter,
+    createContext: async ({ req, res }: { req: Request; res: Response }) => {
+      return createTRPCContext({ req, res });
+    },
+  })
+);
+
+const PORT = process.env.PORT || 3001;
+
+httpServer.listen(PORT, () => {
+  logger.info(`Server running on port ${PORT}`, { 
+    port: PORT,
+    services: ['tRPC', 'Socket.IO']
+  });
+}); 
+
+// log all env variables
+logger.info('Configurations', {
+  NODE_ENV: process.env.NODE_ENV,
+  PORT: process.env.PORT,
+  NEXT_PUBLIC_APP_URL: process.env.NEXT_PUBLIC_APP_URL,
+  LOG_MODE: process.env.LOG_MODE,
+});

package/src/lib/fileUpload.ts

@@ -0,0 +1,163 @@
+import { TRPCError } from "@trpc/server";
+import { v4 as uuidv4 } from "uuid";
+import { uploadFile as uploadToGCS, getSignedUrl } from "./googleCloudStorage";
+import { generateThumbnail, storeThumbnail, generateMediaThumbnail } from "./thumbnailGenerator";
+import { prisma } from "./prisma";
+
+export interface FileData {
+  name: string;
+  type: string;
+  size: number;
+  data: string; // base64 encoded file data
+}
+
+export interface UploadedFile {
+  id: string;
+  name: string;
+  type: string;
+  size: number;
+  path: string;
+  thumbnailId?: string;
+}
+
+/**
+ * Uploads a single file to Google Cloud Storage and creates a file record
+ * @param file The file data to upload
+ * @param userId The ID of the user uploading the file
+ * @param directory Optional directory to store the file in
+ * @param assignmentId Optional assignment ID to associate the file with
+ * @returns The uploaded file record
+ */
+export async function uploadFile(
+  file: FileData,
+  userId: string,
+  directory?: string,
+  assignmentId?: string
+): Promise<UploadedFile> {
+  try {
+    // Create a unique filename
+    const fileExtension = file.name.split('.').pop();
+    const uniqueFilename = `${uuidv4()}.${fileExtension}`;
+    
+    // Construct the full path
+    const filePath = directory 
+      ? `${directory}/${uniqueFilename}`
+      : uniqueFilename;
+    
+    // Upload to Google Cloud Storage
+    const uploadedPath = await uploadToGCS(file.data, filePath, file.type);
+    
+    // Generate and store thumbnail if supported
+    let thumbnailId: string | undefined;
+    try {
+      // Convert base64 to buffer for thumbnail generation
+      const base64Data = file.data.split(',')[1];
+      const fileBuffer = Buffer.from(base64Data, 'base64');
+      
+      // Generate thumbnail directly from buffer
+      const thumbnailBuffer = await generateMediaThumbnail(fileBuffer, file.type);
+      if (thumbnailBuffer) {
+        // Store thumbnail in a thumbnails directory
+        const thumbnailPath = `thumbnails/${filePath}`;
+        const thumbnailBase64 = `data:image/jpeg;base64,${thumbnailBuffer.toString('base64')}`;
+        await uploadToGCS(thumbnailBase64, thumbnailPath, 'image/jpeg');
+        
+        // Create thumbnail file record
+        const thumbnailFile = await prisma.file.create({
+          data: {
+            name: `${file.name}_thumb.jpg`,
+            type: 'image/jpeg',
+            path: thumbnailPath,
+            user: {
+              connect: { id: userId }
+            }
+          }
+        });
+        
+        thumbnailId = thumbnailFile.id;
+      }
+    } catch (error) {
+      console.warn('Failed to generate thumbnail:', error);
+    }
+    
+    // Create file record in database
+    const fileRecord = await prisma.file.create({
+      data: {
+        name: file.name,
+        type: file.type,
+        size: file.size,
+        path: uploadedPath,
+        user: {
+          connect: { id: userId }
+        },
+        ...(thumbnailId && {
+          thumbnail: {
+            connect: { id: thumbnailId }
+          }
+        }),
+        ...(assignmentId && {
+          assignment: {
+            connect: { id: assignmentId }
+          }
+        })
+      },
+    });
+    
+    // Return file information
+    return {
+      id: fileRecord.id,
+      name: file.name,
+      type: file.type,
+      size: file.size,
+      path: uploadedPath,
+      thumbnailId: thumbnailId
+    };
+  } catch (error) {
+    console.error('Error uploading file:', error);
+    throw new TRPCError({
+      code: 'INTERNAL_SERVER_ERROR',
+      message: 'Failed to upload file',
+    });
+  }
+}
+
+/**
+ * Uploads multiple files
+ * @param files Array of files to upload
+ * @param userId The ID of the user uploading the files
+ * @param directory Optional subdirectory to store the files in
+ * @returns Array of uploaded file information
+ */
+export async function uploadFiles(
+  files: FileData[], 
+  userId: string,
+  directory?: string
+): Promise<UploadedFile[]> {
+  try {
+    const uploadPromises = files.map(file => uploadFile(file, userId, directory));
+    return await Promise.all(uploadPromises);
+  } catch (error) {
+    console.error('Error uploading files:', error);
+    throw new TRPCError({
+      code: 'INTERNAL_SERVER_ERROR',
+      message: 'Failed to upload files',
+    });
+  }
+}
+
+/**
+ * Gets a signed URL for a file
+ * @param filePath The path of the file in Google Cloud Storage
+ * @returns The signed URL
+ */
+export async function getFileUrl(filePath: string): Promise<string> {
+  try {
+    return await getSignedUrl(filePath);
+  } catch (error) {
+    console.error('Error getting signed URL:', error);
+    throw new TRPCError({
+      code: 'INTERNAL_SERVER_ERROR',
+      message: 'Failed to get file URL',
+    });
+  }
+}

package/src/lib/googleCloudStorage.ts

@@ -0,0 +1,94 @@
+import { Storage } from '@google-cloud/storage';
+import { TRPCError } from '@trpc/server';
+
+const storage = new Storage({
+  projectId: process.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'),
+  },
+});
+
+const bucket = storage.bucket(process.env.GOOGLE_CLOUD_BUCKET_NAME || '');
+
+// Short expiration time for signed URLs (5 minutes)
+const SIGNED_URL_EXPIRATION = 5 * 60 * 1000;
+
+/**
+ * Uploads a file to Google Cloud Storage
+ * @param base64Data Base64 encoded file data
+ * @param filePath The path where the file should be stored
+ * @param contentType The MIME type of the file
+ * @returns The path of the uploaded file
+ */
+export async function uploadFile(
+  base64Data: string,
+  filePath: string,
+  contentType: string
+): Promise<string> {
+  try {
+    // Remove the data URL prefix if present
+    const base64Content = base64Data.includes('base64,')
+      ? base64Data.split('base64,')[1]
+      : base64Data;
+
+    // Convert base64 to buffer
+    const fileBuffer = Buffer.from(base64Content, 'base64');
+
+    // Create a new file in the bucket
+    const file = bucket.file(filePath);
+
+    // Upload the file
+    await file.save(fileBuffer, {
+      metadata: {
+        contentType,
+      },
+    });
+
+    return filePath;
+  } catch (error) {
+    console.error('Error uploading to Google Cloud Storage:', error);
+    throw new TRPCError({
+      code: 'INTERNAL_SERVER_ERROR',
+      message: 'Failed to upload file to storage',
+    });
+  }
+}
+
+/**
+ * Gets a signed URL for a file
+ * @param filePath The path of the file in the bucket
+ * @returns The signed URL
+ */
+export async function getSignedUrl(filePath: string): Promise<string> {
+  try {
+    const [url] = await bucket.file(filePath).getSignedUrl({
+      version: 'v4',
+      action: 'read',
+      expires: Date.now() + SIGNED_URL_EXPIRATION,
+    });
+    return url;
+  } catch (error) {
+    console.error('Error getting signed URL:', error);
+    throw new TRPCError({
+      code: 'INTERNAL_SERVER_ERROR',
+      message: 'Failed to get signed URL',
+    });
+  }
+}
+
+/**
+ * Deletes a file from Google Cloud Storage
+ * @param filePath The path of the file to delete
+ */
+export async function deleteFile(filePath: string): Promise<void> {
+  try {
+    await bucket.file(filePath).delete();
+  } catch (error) {
+    console.error('Error deleting file from Google Cloud Storage:', error);
+    throw new TRPCError({
+      code: 'INTERNAL_SERVER_ERROR',
+      message: 'Failed to delete file from storage',
+    });
+  }
+} 

package/src/lib/prisma.ts

@@ -0,0 +1,16 @@
+import { PrismaClient } from '@prisma/client';
+
+const prismaClientSingleton = () => {
+  return new PrismaClient();
+};
+
+// Prevent multiple instances of Prisma Client in development
+declare global {
+  var prisma: undefined | ReturnType<typeof prismaClientSingleton>;
+}
+
+export const prisma = globalThis.prisma ?? prismaClientSingleton();
+
+if (process.env.NODE_ENV !== 'production') {
+  globalThis.prisma = prisma;
+}