@studious-lms/server 1.1.7 → 1.1.9

package/dist/routers/message.js

@@ -0,0 +1,325 @@
+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,
+        };
+    }),
+    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
+        const unreadMentionCount = await prisma.mention.count({
+            where: {
+                userId,
+                message: {
+                    conversationId,
+                    senderId: { not: userId },
+                    ...(membership.lastViewedMentionAt && {
+                        createdAt: { gt: membership.lastViewedMentionAt }
+                    }),
+                },
+            },
+        });
+        return {
+            unreadCount,
+            unreadMentionCount
+        };
+    }),
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@studious-lms/server",
-  "version": "1.1.7",
+  "version": "1.1.9",
   "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";

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/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,
               },
             },
           },
@@ -547,6 +548,18 @@ export const classRouter = createTRPCRouter({
               title: true,
               maxGrade: true,
               weight: true,
+              markSchemeId: true,
+              markScheme: {
+                select: {
+                  structured: true,
+                }
+              },
+              gradingBoundaryId: true,
+              gradingBoundary: {
+                select: {
+                  structured: true,
+                }
+              },
             }
           },
         }