@studious-lms/server 1.1.8 → 1.1.10

package/dist/routers/message.js

@@ -0,0 +1,531 @@
+import { z } from 'zod';
+import { createTRPCRouter, protectedProcedure } from '../trpc.js';
+import { prisma } from '../lib/prisma.js';
+import { pusher } from '../lib/pusher.js';
+import { TRPCError } from '@trpc/server';
+export const messageRouter = createTRPCRouter({
+    list: protectedProcedure
+        .input(z.object({
+        conversationId: z.string(),
+        cursor: z.string().optional(),
+        limit: z.number().min(1).max(100).default(50),
+    }))
+        .query(async ({ input, ctx }) => {
+        const userId = ctx.user.id;
+        const { conversationId, cursor, limit } = input;
+        // Verify user is a member of the conversation
+        const membership = await prisma.conversationMember.findFirst({
+            where: {
+                conversationId,
+                userId,
+            },
+        });
+        if (!membership) {
+            throw new TRPCError({
+                code: 'FORBIDDEN',
+                message: 'Not a member of this conversation',
+            });
+        }
+        const messages = await prisma.message.findMany({
+            where: {
+                conversationId,
+                ...(cursor && {
+                    createdAt: {
+                        lt: new Date(cursor),
+                    },
+                }),
+            },
+            include: {
+                sender: {
+                    select: {
+                        id: true,
+                        username: true,
+                        profile: {
+                            select: {
+                                displayName: true,
+                                profilePicture: true,
+                            },
+                        },
+                    },
+                },
+                mentions: {
+                    include: {
+                        user: {
+                            select: {
+                                id: true,
+                                username: true,
+                                profile: {
+                                    select: {
+                                        displayName: true,
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+            orderBy: {
+                createdAt: 'desc',
+            },
+            take: limit + 1,
+        });
+        let nextCursor = undefined;
+        if (messages.length > limit) {
+            const nextItem = messages.pop();
+            nextCursor = nextItem.createdAt.toISOString();
+        }
+        return {
+            messages: messages.reverse().map((message) => ({
+                id: message.id,
+                content: message.content,
+                senderId: message.senderId,
+                conversationId: message.conversationId,
+                createdAt: message.createdAt,
+                sender: message.sender,
+                mentions: message.mentions.map((mention) => ({
+                    user: mention.user,
+                })),
+                mentionsMe: message.mentions.some((mention) => mention.userId === userId),
+            })),
+            nextCursor,
+        };
+    }),
+    send: protectedProcedure
+        .input(z.object({
+        conversationId: 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 { conversationId, content, mentionedUserIds = [] } = input;
+        // Verify user is a member of the conversation
+        const membership = await prisma.conversationMember.findFirst({
+            where: {
+                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,
+                    userId: { in: mentionedUserIds },
+                },
+            });
+            if (mentionedMemberships.length !== mentionedUserIds.length) {
+                throw new TRPCError({
+                    code: 'BAD_REQUEST',
+                    message: 'Some mentioned users are not members of this conversation',
+                });
+            }
+        }
+        // Create message, mentions, and update conversation timestamp
+        const result = await prisma.$transaction(async (tx) => {
+            const message = await tx.message.create({
+                data: {
+                    content,
+                    senderId: userId,
+                    conversationId,
+                },
+                include: {
+                    sender: {
+                        select: {
+                            id: true,
+                            username: true,
+                            profile: {
+                                select: {
+                                    displayName: true,
+                                    profilePicture: true,
+                                },
+                            },
+                        },
+                    },
+                },
+            });
+            // Create mentions
+            if (mentionedUserIds.length > 0) {
+                await tx.mention.createMany({
+                    data: mentionedUserIds.map((mentionedUserId) => ({
+                        messageId: message.id,
+                        userId: mentionedUserId,
+                    })),
+                });
+            }
+            // Update conversation timestamp
+            await tx.conversation.update({
+                where: { id: conversationId },
+                data: { updatedAt: new Date() },
+            });
+            return message;
+        });
+        // Broadcast to Pusher channel
+        try {
+            await pusher.trigger(`conversation-${conversationId}`, 'new-message', {
+                id: result.id,
+                content: result.content,
+                senderId: result.senderId,
+                conversationId: result.conversationId,
+                createdAt: result.createdAt,
+                sender: result.sender,
+                mentionedUserIds,
+            });
+        }
+        catch (error) {
+            console.error('Failed to broadcast message:', error);
+            // Don't fail the request if Pusher fails
+        }
+        return {
+            id: result.id,
+            content: result.content,
+            senderId: result.senderId,
+            conversationId: result.conversationId,
+            createdAt: result.createdAt,
+            sender: result.sender,
+            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(),
+    }))
+        .mutation(async ({ input, ctx }) => {
+        const userId = ctx.user.id;
+        const { conversationId } = input;
+        // Verify user is a member of the conversation and update lastViewedAt
+        const membership = await prisma.conversationMember.findFirst({
+            where: {
+                conversationId,
+                userId,
+            },
+        });
+        if (!membership) {
+            throw new TRPCError({
+                code: 'FORBIDDEN',
+                message: 'Not a member of this conversation',
+            });
+        }
+        // Update the user's lastViewedAt timestamp for this conversation
+        await prisma.conversationMember.update({
+            where: {
+                id: membership.id,
+            },
+            data: {
+                lastViewedAt: new Date(),
+            },
+        });
+        // Broadcast that user has viewed the conversation
+        try {
+            await pusher.trigger(`conversation-${conversationId}`, 'conversation-viewed', {
+                userId,
+                viewedAt: new Date(),
+            });
+        }
+        catch (error) {
+            console.error('Failed to broadcast conversation view:', error);
+            // Don't fail the request if Pusher fails
+        }
+        return { success: true };
+    }),
+    markMentionsAsRead: protectedProcedure
+        .input(z.object({
+        conversationId: z.string(),
+    }))
+        .mutation(async ({ input, ctx }) => {
+        const userId = ctx.user.id;
+        const { conversationId } = input;
+        // Verify user is a member of the conversation and update lastViewedMentionAt
+        const membership = await prisma.conversationMember.findFirst({
+            where: {
+                conversationId,
+                userId,
+            },
+        });
+        if (!membership) {
+            throw new TRPCError({
+                code: 'FORBIDDEN',
+                message: 'Not a member of this conversation',
+            });
+        }
+        // Update the user's lastViewedMentionAt timestamp for this conversation
+        await prisma.conversationMember.update({
+            where: {
+                id: membership.id,
+            },
+            data: {
+                lastViewedMentionAt: new Date(),
+            },
+        });
+        // Broadcast that user has viewed mentions
+        try {
+            await pusher.trigger(`conversation-${conversationId}`, 'mentions-viewed', {
+                userId,
+                viewedAt: new Date(),
+            });
+        }
+        catch (error) {
+            console.error('Failed to broadcast mentions view:', error);
+            // Don't fail the request if Pusher fails
+        }
+        return { success: true };
+    }),
+    getUnreadCount: protectedProcedure
+        .input(z.object({ conversationId: z.string() }))
+        .query(async ({ input, ctx }) => {
+        const userId = ctx.user.id;
+        const { conversationId } = input;
+        // Get user's membership with lastViewedAt and lastViewedMentionAt
+        const membership = await prisma.conversationMember.findFirst({
+            where: {
+                conversationId,
+                userId,
+            },
+        });
+        if (!membership) {
+            throw new TRPCError({
+                code: 'FORBIDDEN',
+                message: 'Not a member of this conversation',
+            });
+        }
+        // Count regular unread messages
+        const unreadCount = await prisma.message.count({
+            where: {
+                conversationId,
+                senderId: { not: userId },
+                ...(membership.lastViewedAt && {
+                    createdAt: { gt: membership.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 = 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 },
+                    ...(mentionCutoffTime && {
+                        createdAt: { gt: mentionCutoffTime }
+                    }),
+                },
+            },
+        });
+        return {
+            unreadCount,
+            unreadMentionCount
+        };
+    }),
+});

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.8",
+  "version": "1.1.10",
   "description": "Backend server for Studious application",
   "main": "dist/exportType.js",
   "types": "dist/exportType.d.ts",
@@ -31,6 +31,7 @@
     "express": "^4.18.3",
     "nodemailer": "^7.0.4",
     "prisma": "^6.7.0",
+    "pusher": "^5.2.0",
     "sharp": "^0.34.2",
     "socket.io": "^4.8.1",
     "superjson": "^2.2.2",

package/prisma/migrations/20250922165147_add_chat_models/migration.sql

@@ -0,0 +1,68 @@
+-- CreateEnum
+CREATE TYPE "ConversationType" AS ENUM ('DM', 'GROUP');
+
+-- CreateTable
+CREATE TABLE "Conversation" (
+    "id" TEXT NOT NULL,
+    "type" "ConversationType" NOT NULL,
+    "name" TEXT,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "Conversation_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "ConversationMember" (
+    "id" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "conversationId" TEXT NOT NULL,
+    "joinedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "ConversationMember_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "Message" (
+    "id" TEXT NOT NULL,
+    "content" TEXT NOT NULL,
+    "senderId" TEXT NOT NULL,
+    "conversationId" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "Message_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "MessageRead" (
+    "id" TEXT NOT NULL,
+    "messageId" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "readAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "MessageRead_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "ConversationMember_userId_conversationId_key" ON "ConversationMember"("userId", "conversationId");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "MessageRead_messageId_userId_key" ON "MessageRead"("messageId", "userId");
+
+-- AddForeignKey
+ALTER TABLE "ConversationMember" ADD CONSTRAINT "ConversationMember_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "ConversationMember" ADD CONSTRAINT "ConversationMember_conversationId_fkey" FOREIGN KEY ("conversationId") REFERENCES "Conversation"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "Message" ADD CONSTRAINT "Message_senderId_fkey" FOREIGN KEY ("senderId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "Message" ADD CONSTRAINT "Message_conversationId_fkey" FOREIGN KEY ("conversationId") REFERENCES "Conversation"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "MessageRead" ADD CONSTRAINT "MessageRead_messageId_fkey" FOREIGN KEY ("messageId") REFERENCES "Message"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "MessageRead" ADD CONSTRAINT "MessageRead_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;

package/prisma/migrations/20250922165314_add_chat_roles/migration.sql

@@ -0,0 +1,5 @@
+-- CreateEnum
+CREATE TYPE "ConversationRole" AS ENUM ('ADMIN', 'MEMBER');
+
+-- AlterTable
+ALTER TABLE "ConversationMember" ADD COLUMN     "role" "ConversationRole" NOT NULL DEFAULT 'MEMBER';

package/prisma/migrations/20250922171242_refactor_notification_system/migration.sql

@@ -0,0 +1,20 @@
+/*
+  Warnings:
+
+  - You are about to drop the `MessageRead` table. If the table is not empty, all the data it contains will be lost.
+
+*/
+-- DropForeignKey
+ALTER TABLE "MessageRead" DROP CONSTRAINT "MessageRead_messageId_fkey";
+
+-- DropForeignKey
+ALTER TABLE "MessageRead" DROP CONSTRAINT "MessageRead_userId_fkey";
+
+-- AlterTable
+ALTER TABLE "Conversation" ADD COLUMN     "displayInChat" BOOLEAN NOT NULL DEFAULT true;
+
+-- AlterTable
+ALTER TABLE "ConversationMember" ADD COLUMN     "lastViewedAt" TIMESTAMP(3);
+
+-- DropTable
+DROP TABLE "MessageRead";