@studious-lms/server 1.1.8 → 1.1.10

package/prisma/migrations/20250922172208_add_mentions_system/migration.sql

@@ -0,0 +1,21 @@
+-- AlterTable
+ALTER TABLE "ConversationMember" ADD COLUMN     "lastViewedMentionAt" TIMESTAMP(3);
+
+-- CreateTable
+CREATE TABLE "Mention" (
+    "id" TEXT NOT NULL,
+    "messageId" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "Mention_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "Mention_messageId_userId_key" ON "Mention"("messageId", "userId");
+
+-- AddForeignKey
+ALTER TABLE "Mention" ADD CONSTRAINT "Mention_messageId_fkey" FOREIGN KEY ("messageId") REFERENCES "Message"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "Mention" ADD CONSTRAINT "Mention_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;

package/prisma/schema.prisma

@@ -76,6 +76,11 @@ model User {
   school School? @relation(fields: [schoolId], references: [id])
   schoolId String?
 
+  // Chat relations
+  conversationMemberships ConversationMember[]
+  sentMessages Message[] @relation("SentMessages")
+  mentions Mention[] @relation("UserMentions")
+
 }
 
 model UserProfile {
@@ -306,4 +311,66 @@ model Notification {
   read Boolean @default(false)
   sender User? @relation("SentNotifications", fields: [senderId], references: [id])
   receiver User @relation("ReceivedNotifications", fields: [receiverId], references: [id], onDelete: Cascade)
-}
+}
+
+enum ConversationType {
+  DM
+  GROUP
+}
+
+enum ConversationRole {
+  ADMIN
+  MEMBER
+}
+
+model Conversation {
+  id String @id @default(uuid())
+  type ConversationType
+  name String?
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  displayInChat Boolean @default(true)
+  
+  members ConversationMember[]
+  messages Message[]
+}
+
+model ConversationMember {
+  id String @id @default(uuid())
+  userId String
+  conversationId String
+  role ConversationRole @default(MEMBER)
+  joinedAt DateTime @default(now())
+  lastViewedAt DateTime? // When user last viewed this conversation
+  lastViewedMentionAt DateTime? // When user last viewed mentions in this conversation
+  
+  user User @relation(fields: [userId], references: [id], onDelete: Cascade)
+  conversation Conversation @relation(fields: [conversationId], references: [id], onDelete: Cascade)
+  
+  @@unique([userId, conversationId])
+}
+
+model Message {
+  id String @id @default(uuid())
+  content String
+  senderId String
+  conversationId String
+  createdAt DateTime @default(now())
+  
+  sender User @relation("SentMessages", fields: [senderId], references: [id], onDelete: Cascade)
+  conversation Conversation @relation(fields: [conversationId], references: [id], onDelete: Cascade)
+  mentions Mention[]
+}
+
+model Mention {
+  id String @id @default(uuid())
+  messageId String
+  userId String
+  createdAt DateTime @default(now())
+  
+  message Message @relation(fields: [messageId], references: [id], onDelete: Cascade)
+  user User @relation("UserMentions", fields: [userId], references: [id], onDelete: Cascade)
+  
+  @@unique([messageId, userId])
+}

package/src/index.ts

@@ -22,6 +22,8 @@ app.use(cors({
     'http://localhost:3001',  // Server port
     'http://127.0.0.1:3000',  // Alternative localhost
     'http://127.0.0.1:3001',  // Alternative localhost
+    'https://www.studious.sh',  // Production frontend
+    'https://studious.sh',     // Production frontend (without www)
     process.env.NEXT_PUBLIC_APP_URL || 'http://localhost:3000'
   ],
   credentials: true,
@@ -37,6 +39,8 @@ app.options('*', (req, res) => {
     'http://localhost:3001', 
     'http://127.0.0.1:3000',
     'http://127.0.0.1:3001',
+    'https://www.studious.sh',  // Production frontend
+    'https://studious.sh',     // Production frontend (without www)
     process.env.NEXT_PUBLIC_APP_URL || 'http://localhost:3000'
   ];
   
@@ -92,6 +96,8 @@ const io = new Server(httpServer, {
       'http://localhost:3001',  // Server port
       'http://127.0.0.1:3000',  // Alternative localhost
       'http://127.0.0.1:3001',  // Alternative localhost
+      'https://www.studious.sh',  // Production frontend
+      'https://studious.sh',     // Production frontend (without www)
       process.env.NEXT_PUBLIC_APP_URL || 'http://localhost:3000'
     ],
     methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
@@ -158,6 +164,79 @@ app.get('/api/files/:filePath', async (req, res) => {
   }
 });
 
+// File upload endpoint for secure file uploads (supports both POST and PUT)
+app.post('/api/upload/:filePath', async (req, res) => {
+  handleFileUpload(req, res);
+});
+
+app.put('/api/upload/:filePath', async (req, res) => {
+  handleFileUpload(req, res);
+});
+
+function handleFileUpload(req: any, res: any) {
+  try {
+    const filePath = decodeURIComponent(req.params.filePath);
+    console.log('File upload request:', { filePath, originalPath: req.params.filePath, method: req.method });
+    
+    // Set CORS headers for upload endpoint
+    const origin = req.headers.origin;
+    const allowedOrigins = [
+      'http://localhost:3000',
+      'http://localhost:3001', 
+      'http://127.0.0.1:3000',
+      'http://127.0.0.1:3001',
+      'https://www.studious.sh',  // Production frontend
+      'https://studious.sh',     // Production frontend (without www)
+      process.env.NEXT_PUBLIC_APP_URL || 'http://localhost:3000'
+    ];
+    
+    if (origin && allowedOrigins.includes(origin)) {
+      res.header('Access-Control-Allow-Origin', origin);
+    } else {
+      res.header('Access-Control-Allow-Origin', 'http://localhost:3000');
+    }
+    
+    res.header('Access-Control-Allow-Credentials', 'true');
+    
+    // Get content type from headers
+    const contentType = req.headers['content-type'] || 'application/octet-stream';
+    
+    // Create a new file in the bucket
+    const file = bucket.file(filePath);
+    
+    // Create a write stream to Google Cloud Storage
+    const writeStream = file.createWriteStream({
+      metadata: {
+        contentType,
+      },
+    });
+    
+    // Handle stream events
+    writeStream.on('error', (error) => {
+      console.error('Error uploading file:', error);
+      if (!res.headersSent) {
+        res.status(500).json({ error: 'Error uploading file' });
+      }
+    });
+    
+    writeStream.on('finish', () => {
+      console.log('File uploaded successfully:', filePath);
+      res.status(200).json({ 
+        success: true, 
+        filePath,
+        message: 'File uploaded successfully' 
+      });
+    });
+    
+    // Pipe the request body to the write stream
+    req.pipe(writeStream);
+    
+  } catch (error) {
+    console.error('Error handling file upload:', error);
+    res.status(500).json({ error: 'Internal server error' });
+  }
+}
+
 // Create caller
 const createCaller = createCallerFactory(appRouter);
 

package/src/lib/pusher.ts

@@ -0,0 +1,11 @@
+import Pusher from 'pusher';
+
+const pusher = new Pusher({
+  appId: process.env.PUSHER_APP_ID!,
+  key: process.env.PUSHER_KEY!,
+  secret: process.env.PUSHER_SECRET!,
+  cluster: process.env.PUSHER_CLUSTER!,
+  useTLS: true,
+});
+
+export { pusher };

package/src/routers/_app.ts

@@ -13,6 +13,8 @@ import { agendaRouter } from "./agenda.js";
 import { fileRouter } from "./file.js";
 import { folderRouter } from "./folder.js";
 import { notificationRouter } from "./notifications.js";
+import { conversationRouter } from "./conversation.js";
+import { messageRouter } from "./message.js";
 
 export const appRouter = createTRPCRouter({
   class: classRouter,
@@ -27,6 +29,8 @@ export const appRouter = createTRPCRouter({
   file: fileRouter,
   folder: folderRouter,
   notification: notificationRouter,
+  conversation: conversationRouter,
+  message: messageRouter,
 }); 
 
 // Export type router type definition

package/src/routers/auth.ts

@@ -197,6 +197,7 @@ export const authRouter = createTRPCRouter({
       return { success: true };
     }),
 
+
   check: protectedProcedure
     .query(async ({ ctx }) => {
       if (!ctx.user) {

package/src/routers/class.ts

@@ -54,6 +54,7 @@ export const classRouter = createTRPCRouter({
                 id: true,
                 title: true,
                 type: true,
+                dueDate: true,
               },
             },
           },

package/src/routers/conversation.ts

@@ -0,0 +1,292 @@
+import { z } from 'zod';
+import { createTRPCRouter, protectedProcedure } from '../trpc.js';
+import { prisma } from '../lib/prisma.js';
+import { TRPCError } from '@trpc/server';
+
+export const conversationRouter = createTRPCRouter({
+  list: protectedProcedure.query(async ({ ctx }) => {
+    const userId = ctx.user!.id;
+
+    const conversations = await prisma.conversation.findMany({
+      where: {
+        members: {
+          some: {
+            userId,
+          },
+        },
+      },
+      include: {
+        members: {
+          include: {
+            user: {
+              select: {
+                id: true,
+                username: true,
+                profile: {
+                  select: {
+                    displayName: true,
+                    profilePicture: true,
+                  },
+                },
+              },
+            },
+          },
+        },
+        messages: {
+          orderBy: {
+            createdAt: 'desc',
+          },
+          take: 1,
+          include: {
+            sender: {
+              select: {
+                id: true,
+                username: true,
+                profile: {
+                  select: {
+                    displayName: true,
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+      orderBy: {
+        updatedAt: 'desc',
+      },
+    });
+
+    // Calculate unread counts for each conversation
+    const conversationsWithUnread = await Promise.all(
+      conversations.map(async (conversation) => {
+        const userMembership = conversation.members.find(m => m.userId === userId);
+        const lastViewedAt = userMembership?.lastViewedAt;
+        const lastViewedMentionAt = userMembership?.lastViewedMentionAt;
+        
+        // Count regular unread messages
+        const unreadCount = await prisma.message.count({
+          where: {
+            conversationId: conversation.id,
+            senderId: { not: userId },
+            ...(lastViewedAt && {
+              createdAt: { gt: lastViewedAt }
+            }),
+          },
+        });
+
+        // Count unread mentions
+        // Use the later of lastViewedAt or lastViewedMentionAt
+        // This means if user viewed conversation after mention, mention is considered read
+        const mentionCutoffTime = lastViewedMentionAt && lastViewedAt 
+          ? (lastViewedMentionAt > lastViewedAt ? lastViewedMentionAt : lastViewedAt)
+          : (lastViewedMentionAt || lastViewedAt);
+        
+        const unreadMentionCount = await prisma.mention.count({
+          where: {
+            userId,
+            message: {
+              conversationId: conversation.id,
+              senderId: { not: userId },
+              ...(mentionCutoffTime && {
+                createdAt: { gt: mentionCutoffTime }
+              }),
+            },
+          },
+        });
+
+        return {
+          id: conversation.id,
+          type: conversation.type,
+          name: conversation.name,
+          createdAt: conversation.createdAt,
+          updatedAt: conversation.updatedAt,
+          members: conversation.members,
+          lastMessage: conversation.messages[0] || null,
+          unreadCount,
+          unreadMentionCount,
+        };
+      })
+    );
+
+    return conversationsWithUnread;
+  }),
+
+  create: protectedProcedure
+    .input(
+      z.object({
+        type: z.enum(['DM', 'GROUP']),
+        name: z.string().optional(),
+        memberIds: z.array(z.string()),
+      })
+    )
+    .mutation(async ({ input, ctx }) => {
+      const userId = ctx.user!.id;
+      const { type, name, memberIds } = input;
+
+      // Validate input
+      if (type === 'GROUP' && !name) {
+        throw new TRPCError({
+          code: 'BAD_REQUEST',
+          message: 'Group conversations must have a name',
+        });
+      }
+
+      if (type === 'DM' && memberIds.length !== 1) {
+        throw new TRPCError({
+          code: 'BAD_REQUEST',
+          message: 'DM conversations must have exactly one other member',
+        });
+      }
+
+      // For DMs, check if conversation already exists
+      if (type === 'DM') {
+        const existingDM = await prisma.conversation.findFirst({
+          where: {
+            type: 'DM',
+            members: {
+              every: {
+                userId: {
+                  in: [userId, memberIds[0]],
+                },
+              },
+            },
+            AND: {
+              members: {
+                some: {
+                  userId,
+                },
+              },
+            },
+          },
+          include: {
+            members: {
+              include: {
+                user: {
+                  select: {
+                    id: true,
+                    username: true,
+                    profile: {
+                      select: {
+                        displayName: true,
+                        profilePicture: true,
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        });
+
+        if (existingDM) {
+          return existingDM;
+        }
+      }
+
+      // Verify all members exist
+      const members = await prisma.user.findMany({
+        where: {
+          username: {
+            in: memberIds,
+          },
+        },
+        select: {
+          id: true,
+          username: true,
+        },
+      });
+
+      if (members.length !== memberIds.length) {
+        throw new TRPCError({
+          code: 'BAD_REQUEST',
+          message: 'One or more members not found',
+        });
+      }
+
+      // Create conversation with members
+      const conversation = await prisma.conversation.create({
+        data: {
+          type,
+          name,
+          members: {
+            create: [
+              {
+                userId,
+                role: type === 'GROUP' ? 'ADMIN' : 'MEMBER',
+              },
+              ...memberIds.map((memberId) => ({
+                userId: members.find((member) => member.username === memberId)!.id,
+                role: 'MEMBER' as const,
+              })),
+            ],
+          },
+        },
+        include: {
+          members: {
+            include: {
+              user: {
+                select: {
+                  id: true,
+                  username: true,
+                  profile: {
+                    select: {
+                      displayName: true,
+                      profilePicture: true,
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      });
+
+      return conversation;
+    }),
+
+  get: protectedProcedure
+    .input(z.object({ conversationId: z.string() }))
+    .query(async ({ input, ctx }) => {
+      const userId = ctx.user!.id;
+      const { conversationId } = input;
+
+      const conversation = await prisma.conversation.findFirst({
+        where: {
+          id: conversationId,
+          members: {
+            some: {
+              userId,
+            },
+          },
+        },
+        include: {
+          members: {
+            include: {
+              user: {
+                select: {
+                  id: true,
+                  username: true,
+                  profile: {
+                    select: {
+                      displayName: true,
+                      profilePicture: true,
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      });
+
+      if (!conversation) {
+        throw new TRPCError({
+          code: 'NOT_FOUND',
+          message: 'Conversation not found or access denied',
+        });
+      }
+
+      return conversation;
+    }),
+});