@studious-lms/server 1.1.9 → 1.1.11

package/dist/routers/message.d.ts

@@ -76,6 +76,40 @@ export declare const messageRouter: import("@trpc/server").TRPCBuiltRouter<{
         };
         meta: object;
     }>;
+    update: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            content: string;
+            messageId: string;
+            mentionedUserIds?: string[] | undefined;
+        };
+        output: {
+            id: string;
+            content: string;
+            senderId: string;
+            conversationId: string;
+            createdAt: Date;
+            sender: {
+                id: string;
+                username: string;
+                profile: {
+                    displayName: string | null;
+                    profilePicture: string | null;
+                } | null;
+            };
+            mentionedUserIds: string[];
+        };
+        meta: object;
+    }>;
+    delete: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            messageId: string;
+        };
+        output: {
+            success: boolean;
+            messageId: string;
+        };
+        meta: object;
+    }>;
     markAsRead: import("@trpc/server").TRPCMutationProcedure<{
         input: {
             conversationId: string;

package/dist/routers/message.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"message.d.ts","sourceRoot":"","sources":["../../src/routers/message.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsWxB,CAAC"}
+{"version":3,"file":"message.d.ts","sourceRoot":"","sources":["../../src/routers/message.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6kBxB,CAAC"}

package/dist/routers/message.js

@@ -192,6 +192,207 @@ export const messageRouter = createTRPCRouter({
             mentionedUserIds,
         };
     }),
+    update: protectedProcedure
+        .input(z.object({
+        messageId: z.string(),
+        content: z.string().min(1).max(4000),
+        mentionedUserIds: z.array(z.string()).optional(),
+    }))
+        .mutation(async ({ input, ctx }) => {
+        const userId = ctx.user.id;
+        const { messageId, content, mentionedUserIds = [] } = input;
+        // Get the existing message and verify user is the sender
+        const existingMessage = await prisma.message.findUnique({
+            where: { id: messageId },
+            include: {
+                sender: {
+                    select: {
+                        id: true,
+                        username: true,
+                        profile: {
+                            select: {
+                                displayName: true,
+                                profilePicture: true,
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        if (!existingMessage) {
+            throw new TRPCError({
+                code: 'NOT_FOUND',
+                message: 'Message not found',
+            });
+        }
+        if (existingMessage.senderId !== userId) {
+            throw new TRPCError({
+                code: 'FORBIDDEN',
+                message: 'Not the sender of this message',
+            });
+        }
+        // Verify user is still a member of the conversation
+        const membership = await prisma.conversationMember.findFirst({
+            where: {
+                conversationId: existingMessage.conversationId,
+                userId,
+            },
+        });
+        if (!membership) {
+            throw new TRPCError({
+                code: 'FORBIDDEN',
+                message: 'Not a member of this conversation',
+            });
+        }
+        // Verify mentioned users are members of the conversation
+        if (mentionedUserIds.length > 0) {
+            const mentionedMemberships = await prisma.conversationMember.findMany({
+                where: {
+                    conversationId: existingMessage.conversationId,
+                    userId: { in: mentionedUserIds },
+                },
+            });
+            if (mentionedMemberships.length !== mentionedUserIds.length) {
+                throw new TRPCError({
+                    code: 'BAD_REQUEST',
+                    message: 'Some mentioned users are not members of this conversation',
+                });
+            }
+        }
+        // Update message and mentions in transaction
+        const updatedMessage = await prisma.$transaction(async (tx) => {
+            // Update the message content
+            const message = await tx.message.update({
+                where: { id: messageId },
+                data: { content },
+                include: {
+                    sender: {
+                        select: {
+                            id: true,
+                            username: true,
+                            profile: {
+                                select: {
+                                    displayName: true,
+                                    profilePicture: true,
+                                },
+                            },
+                        },
+                    },
+                },
+            });
+            // Delete existing mentions
+            await tx.mention.deleteMany({
+                where: { messageId },
+            });
+            // Create new mentions if any
+            if (mentionedUserIds.length > 0) {
+                await tx.mention.createMany({
+                    data: mentionedUserIds.map((mentionedUserId) => ({
+                        messageId,
+                        userId: mentionedUserId,
+                    })),
+                });
+            }
+            return message;
+        });
+        // Broadcast message update to Pusher
+        try {
+            await pusher.trigger(`conversation-${existingMessage.conversationId}`, 'message-updated', {
+                id: updatedMessage.id,
+                content: updatedMessage.content,
+                senderId: updatedMessage.senderId,
+                conversationId: updatedMessage.conversationId,
+                createdAt: updatedMessage.createdAt,
+                sender: updatedMessage.sender,
+                mentionedUserIds,
+            });
+        }
+        catch (error) {
+            console.error('Failed to broadcast message update:', error);
+            // Don't fail the request if Pusher fails
+        }
+        return {
+            id: updatedMessage.id,
+            content: updatedMessage.content,
+            senderId: updatedMessage.senderId,
+            conversationId: updatedMessage.conversationId,
+            createdAt: updatedMessage.createdAt,
+            sender: updatedMessage.sender,
+            mentionedUserIds,
+        };
+    }),
+    delete: protectedProcedure
+        .input(z.object({
+        messageId: z.string(),
+    }))
+        .mutation(async ({ input, ctx }) => {
+        const userId = ctx.user.id;
+        const { messageId } = input;
+        // Get the message and verify user is the sender
+        const existingMessage = await prisma.message.findUnique({
+            where: { id: messageId },
+            include: {
+                sender: {
+                    select: {
+                        id: true,
+                        username: true,
+                    },
+                },
+            },
+        });
+        if (!existingMessage) {
+            throw new TRPCError({
+                code: 'NOT_FOUND',
+                message: 'Message not found',
+            });
+        }
+        if (existingMessage.senderId !== userId) {
+            throw new TRPCError({
+                code: 'FORBIDDEN',
+                message: 'Not the sender of this message',
+            });
+        }
+        // Verify user is still a member of the conversation
+        const membership = await prisma.conversationMember.findFirst({
+            where: {
+                conversationId: existingMessage.conversationId,
+                userId,
+            },
+        });
+        if (!membership) {
+            throw new TRPCError({
+                code: 'FORBIDDEN',
+                message: 'Not a member of this conversation',
+            });
+        }
+        // Delete message and all related mentions in transaction
+        await prisma.$transaction(async (tx) => {
+            // Delete mentions first (due to foreign key constraint)
+            await tx.mention.deleteMany({
+                where: { messageId },
+            });
+            // Delete the message
+            await tx.message.delete({
+                where: { id: messageId },
+            });
+        });
+        // Broadcast message deletion to Pusher
+        try {
+            await pusher.trigger(`conversation-${existingMessage.conversationId}`, 'message-deleted', {
+                messageId,
+                conversationId: existingMessage.conversationId,
+                senderId: existingMessage.senderId,
+            });
+        }
+        catch (error) {
+            console.error('Failed to broadcast message deletion:', error);
+            // Don't fail the request if Pusher fails
+        }
+        return {
+            success: true,
+            messageId,
+        };
+    }),
     markAsRead: protectedProcedure
         .input(z.object({
         conversationId: z.string(),
@@ -305,14 +506,19 @@ export const messageRouter = createTRPCRouter({
             },
         });
         // Count unread mentions
+        // Use the later of lastViewedAt or lastViewedMentionAt
+        // This means if user viewed conversation after mention, mention is considered read
+        const mentionCutoffTime = membership.lastViewedMentionAt && membership.lastViewedAt
+            ? (membership.lastViewedMentionAt > membership.lastViewedAt ? membership.lastViewedMentionAt : membership.lastViewedAt)
+            : (membership.lastViewedMentionAt || membership.lastViewedAt);
         const unreadMentionCount = await prisma.mention.count({
             where: {
                 userId,
                 message: {
                     conversationId,
                     senderId: { not: userId },
-                    ...(membership.lastViewedMentionAt && {
-                        createdAt: { gt: membership.lastViewedMentionAt }
+                    ...(mentionCutoffTime && {
+                        createdAt: { gt: mentionCutoffTime }
                     }),
                 },
             },

package/dist/routers/user.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../src/routers/user.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA2DxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqMrB,CAAC"}
+{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../src/routers/user.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA2DxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuMrB,CAAC"}

package/dist/routers/user.js

@@ -2,7 +2,6 @@ import { z } from "zod";
 import { createTRPCRouter, protectedProcedure } from "../trpc.js";
 import { TRPCError } from "@trpc/server";
 import { prisma } from "../lib/prisma.js";
-import { getSignedUrl } from "../lib/googleCloudStorage.js";
 import { logger } from "../utils/logger.js";
 // Helper function to convert file path to backend proxy URL
 function getFileUrl(filePath) {
@@ -203,13 +202,15 @@ export const userRouter = createTRPCRouter({
             const fileExtension = input.fileName.split('.').pop();
             const uniqueFilename = `${ctx.user.id}-${Date.now()}.${fileExtension}`;
             const filePath = `users/${ctx.user.id}/profile/${uniqueFilename}`;
-            // Generate signed URL for direct upload (write permission)
-            const uploadUrl = await getSignedUrl(filePath, 'write', input.fileType);
+            // Generate backend proxy upload URL instead of direct GCS signed URL
+            const backendUrl = process.env.BACKEND_URL || 'http://localhost:3001';
+            const uploadUrl = `${backendUrl}/api/upload/${encodeURIComponent(filePath)}`;
             logger.info('Generated upload URL', {
                 userId: ctx.user.id,
                 filePath,
                 fileName: uniqueFilename,
-                fileType: input.fileType
+                fileType: input.fileType,
+                uploadUrl
             });
             return {
                 uploadUrl,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@studious-lms/server",
-  "version": "1.1.9",
+  "version": "1.1.11",
   "description": "Backend server for Studious application",
   "main": "dist/exportType.js",
   "types": "dist/exportType.d.ts",

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/routers/assignment.ts

@@ -1093,6 +1093,13 @@ export const assignmentRouter = createTRPCRouter({
             select: {
               id: true,
               username: true,
+              profile: {
+                select: {
+                  displayName: true,
+                  profilePicture: true,
+                  profilePictureThumbnail: true,
+                },
+              },
             },
           },
           assignment: {
@@ -1195,6 +1202,13 @@ export const assignmentRouter = createTRPCRouter({
               select: {
                 id: true,
                 username: true,
+                profile: {
+                  select: {
+                    displayName: true,
+                    profilePicture: true,
+                    profilePictureThumbnail: true,
+                  },
+                },
               },
             },
             assignment: {
@@ -1311,6 +1325,13 @@ export const assignmentRouter = createTRPCRouter({
             select: {
               id: true,
               username: true,
+              profile: {
+                select: {
+                  displayName: true,
+                  profilePicture: true,
+                  profilePictureThumbnail: true,
+                },
+              },
             },
           },
           assignment: {

package/src/routers/attendance.ts

@@ -49,6 +49,17 @@ export const attendanceRouter = createTRPCRouter({
           students: {
             select: {
               id: true,
+              username: true,
+              profile: {
+                select: {
+                  displayName: true,
+                  profilePicture: true,
+                  profilePictureThumbnail: true,
+                  bio: true,
+                  location: true,
+                  website: true,
+                },
+              },
             },
           },
         },
@@ -117,18 +128,39 @@ export const attendanceRouter = createTRPCRouter({
             select: {
               id: true,
               username: true,
+              profile: {
+                select: {
+                  displayName: true,
+                  profilePicture: true,
+                  profilePictureThumbnail: true,
+                },
+              },
             },
           },
           late: {
             select: {
               id: true,
               username: true,
+              profile: {
+                select: {
+                  displayName: true,
+                  profilePicture: true,
+                  profilePictureThumbnail: true,
+                },
+              },
             },
           },
           absent: {
             select: {
               id: true,
               username: true,
+              profile: {
+                select: {
+                  displayName: true,
+                  profilePicture: true,
+                  profilePictureThumbnail: true,
+                },
+              },
             },
           },
         },

package/src/routers/class.ts

@@ -104,6 +104,13 @@ export const classRouter = createTRPCRouter({
             select: {
               id: true,
               username: true,
+              profile: {
+                select: {
+                  displayName: true,
+                  profilePicture: true,
+                  profilePictureThumbnail: true,
+                },
+              },
             },
           },
           announcements: {
@@ -118,6 +125,13 @@ export const classRouter = createTRPCRouter({
                 select: {
                   id: true,
                   username: true,
+                  profile: {
+                    select: {
+                      displayName: true,
+                      profilePicture: true,
+                      profilePictureThumbnail: true,
+                    },
+                  },
                 },
               },
             },

package/src/routers/conversation.ts

@@ -76,14 +76,20 @@ export const conversationRouter = createTRPCRouter({
         });
 
         // 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 },
-              ...(lastViewedMentionAt && {
-                createdAt: { gt: lastViewedMentionAt }
+              ...(mentionCutoffTime && {
+                createdAt: { gt: mentionCutoffTime }
               }),
             },
           },
@@ -181,12 +187,13 @@ export const conversationRouter = createTRPCRouter({
       // Verify all members exist
       const members = await prisma.user.findMany({
         where: {
-          id: {
+          username: {
             in: memberIds,
           },
         },
         select: {
           id: true,
+          username: true,
         },
       });
 
@@ -209,7 +216,7 @@ export const conversationRouter = createTRPCRouter({
                 role: type === 'GROUP' ? 'ADMIN' : 'MEMBER',
               },
               ...memberIds.map((memberId) => ({
-                userId: memberId,
+                userId: members.find((member) => member.username === memberId)!.id,
                 role: 'MEMBER' as const,
               })),
             ],