@studious-lms/server 1.1.11 → 1.1.12

package/dist/routers/labChat.js

@@ -0,0 +1,500 @@
+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 labChatRouter = createTRPCRouter({
+    create: protectedProcedure
+        .input(z.object({
+        classId: z.string(),
+        title: z.string().min(1).max(200),
+        context: z.string(), // JSON string for LLM context
+    }))
+        .mutation(async ({ input, ctx }) => {
+        const userId = ctx.user.id;
+        const { classId, title, context } = input;
+        // Verify user is a teacher in the class
+        const classWithTeachers = await prisma.class.findFirst({
+            where: {
+                id: classId,
+                teachers: {
+                    some: {
+                        id: userId,
+                    },
+                },
+            },
+            include: {
+                students: {
+                    select: {
+                        id: true,
+                        username: true,
+                        profile: {
+                            select: {
+                                displayName: true,
+                                profilePicture: true,
+                            },
+                        },
+                    },
+                },
+                teachers: {
+                    select: {
+                        id: true,
+                        username: true,
+                        profile: {
+                            select: {
+                                displayName: true,
+                                profilePicture: true,
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        if (!classWithTeachers) {
+            throw new TRPCError({
+                code: 'FORBIDDEN',
+                message: 'Not a teacher in this class',
+            });
+        }
+        // Validate context is valid JSON
+        try {
+            JSON.parse(context);
+        }
+        catch (error) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: 'Context must be valid JSON',
+            });
+        }
+        // Create lab chat with associated conversation
+        const result = await prisma.$transaction(async (tx) => {
+            // Create conversation for the lab chat
+            const conversation = await tx.conversation.create({
+                data: {
+                    type: 'GROUP',
+                    name: `Lab: ${title}`,
+                    displayInChat: false, // Lab chats don't show in regular chat list
+                },
+            });
+            // Add all class members to the conversation
+            const allMembers = [
+                ...classWithTeachers.teachers.map(t => ({ userId: t.id, role: 'ADMIN' })),
+                ...classWithTeachers.students.map(s => ({ userId: s.id, role: 'MEMBER' })),
+            ];
+            await tx.conversationMember.createMany({
+                data: allMembers.map(member => ({
+                    userId: member.userId,
+                    conversationId: conversation.id,
+                    role: member.role,
+                })),
+            });
+            // Create the lab chat
+            const labChat = await tx.labChat.create({
+                data: {
+                    title,
+                    context,
+                    classId,
+                    conversationId: conversation.id,
+                    createdById: userId,
+                },
+                include: {
+                    conversation: {
+                        include: {
+                            members: {
+                                include: {
+                                    user: {
+                                        select: {
+                                            id: true,
+                                            username: true,
+                                            profile: {
+                                                select: {
+                                                    displayName: true,
+                                                    profilePicture: true,
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    createdBy: {
+                        select: {
+                            id: true,
+                            username: true,
+                            profile: {
+                                select: {
+                                    displayName: true,
+                                },
+                            },
+                        },
+                    },
+                    class: {
+                        select: {
+                            id: true,
+                            name: true,
+                            subject: true,
+                            section: true,
+                        },
+                    },
+                },
+            });
+            return labChat;
+        });
+        // Broadcast lab chat creation to class members
+        try {
+            await pusher.trigger(`class-${classId}`, 'lab-chat-created', {
+                id: result.id,
+                title: result.title,
+                classId: result.classId,
+                conversationId: result.conversationId,
+                createdBy: result.createdBy,
+                createdAt: result.createdAt,
+            });
+        }
+        catch (error) {
+            console.error('Failed to broadcast lab chat creation:', error);
+            // Don't fail the request if Pusher fails
+        }
+        return result;
+    }),
+    get: protectedProcedure
+        .input(z.object({ labChatId: z.string() }))
+        .query(async ({ input, ctx }) => {
+        const userId = ctx.user.id;
+        const { labChatId } = input;
+        const labChat = await prisma.labChat.findFirst({
+            where: {
+                id: labChatId,
+                conversation: {
+                    members: {
+                        some: {
+                            userId,
+                        },
+                    },
+                },
+            },
+            include: {
+                conversation: {
+                    include: {
+                        members: {
+                            include: {
+                                user: {
+                                    select: {
+                                        id: true,
+                                        username: true,
+                                        profile: {
+                                            select: {
+                                                displayName: true,
+                                                profilePicture: true,
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+                createdBy: {
+                    select: {
+                        id: true,
+                        username: true,
+                        profile: {
+                            select: {
+                                displayName: true,
+                            },
+                        },
+                    },
+                },
+                class: {
+                    select: {
+                        id: true,
+                        name: true,
+                        subject: true,
+                        section: true,
+                    },
+                },
+            },
+        });
+        if (!labChat) {
+            throw new TRPCError({
+                code: 'NOT_FOUND',
+                message: 'Lab chat not found or access denied',
+            });
+        }
+        return labChat;
+    }),
+    list: protectedProcedure
+        .input(z.object({ classId: z.string() }))
+        .query(async ({ input, ctx }) => {
+        const userId = ctx.user.id;
+        const { classId } = input;
+        // Verify user is a member of the class
+        const classMembership = await prisma.class.findFirst({
+            where: {
+                id: classId,
+                OR: [
+                    {
+                        students: {
+                            some: {
+                                id: userId,
+                            },
+                        },
+                    },
+                    {
+                        teachers: {
+                            some: {
+                                id: userId,
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        if (!classMembership) {
+            throw new TRPCError({
+                code: 'FORBIDDEN',
+                message: 'Not a member of this class',
+            });
+        }
+        const labChats = await prisma.labChat.findMany({
+            where: {
+                classId,
+            },
+            include: {
+                createdBy: {
+                    select: {
+                        id: true,
+                        username: true,
+                        profile: {
+                            select: {
+                                displayName: true,
+                            },
+                        },
+                    },
+                },
+                conversation: {
+                    include: {
+                        messages: {
+                            orderBy: {
+                                createdAt: 'desc',
+                            },
+                            take: 1,
+                            include: {
+                                sender: {
+                                    select: {
+                                        id: true,
+                                        username: true,
+                                        profile: {
+                                            select: {
+                                                displayName: true,
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                        _count: {
+                            select: {
+                                messages: true,
+                            },
+                        },
+                    },
+                },
+            },
+            orderBy: {
+                createdAt: 'desc',
+            },
+        });
+        return labChats.map((labChat) => ({
+            id: labChat.id,
+            title: labChat.title,
+            classId: labChat.classId,
+            conversationId: labChat.conversationId,
+            createdBy: labChat.createdBy,
+            createdAt: labChat.createdAt,
+            updatedAt: labChat.updatedAt,
+            lastMessage: labChat.conversation.messages[0] || null,
+            messageCount: labChat.conversation._count.messages,
+        }));
+    }),
+    postToLabChat: protectedProcedure
+        .input(z.object({
+        labChatId: 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 { labChatId, content, mentionedUserIds = [] } = input;
+        // Get lab chat and verify user is a member
+        const labChat = await prisma.labChat.findFirst({
+            where: {
+                id: labChatId,
+                conversation: {
+                    members: {
+                        some: {
+                            userId,
+                        },
+                    },
+                },
+            },
+            include: {
+                conversation: {
+                    select: {
+                        id: true,
+                    },
+                },
+            },
+        });
+        if (!labChat) {
+            throw new TRPCError({
+                code: 'FORBIDDEN',
+                message: 'Lab chat not found or access denied',
+            });
+        }
+        // Verify mentioned users are members of the conversation
+        if (mentionedUserIds.length > 0) {
+            const mentionedMemberships = await prisma.conversationMember.findMany({
+                where: {
+                    conversationId: labChat.conversationId,
+                    userId: { in: mentionedUserIds },
+                },
+            });
+            if (mentionedMemberships.length !== mentionedUserIds.length) {
+                throw new TRPCError({
+                    code: 'BAD_REQUEST',
+                    message: 'Some mentioned users are not members of this lab chat',
+                });
+            }
+        }
+        // Create message and mentions
+        const result = await prisma.$transaction(async (tx) => {
+            const message = await tx.message.create({
+                data: {
+                    content,
+                    senderId: userId,
+                    conversationId: labChat.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 lab chat timestamp
+            await tx.labChat.update({
+                where: { id: labChatId },
+                data: { updatedAt: new Date() },
+            });
+            return message;
+        });
+        // Broadcast to Pusher channel (using conversation ID)
+        try {
+            await pusher.trigger(`conversation-${labChat.conversationId}`, 'new-message', {
+                id: result.id,
+                content: result.content,
+                senderId: result.senderId,
+                conversationId: result.conversationId,
+                createdAt: result.createdAt,
+                sender: result.sender,
+                mentionedUserIds,
+                labChatId, // Include lab chat ID for frontend context
+            });
+        }
+        catch (error) {
+            console.error('Failed to broadcast lab chat 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,
+            labChatId,
+        };
+    }),
+    delete: protectedProcedure
+        .input(z.object({ labChatId: z.string() }))
+        .mutation(async ({ input, ctx }) => {
+        const userId = ctx.user.id;
+        const { labChatId } = input;
+        // Verify user is the creator of the lab chat
+        const labChat = await prisma.labChat.findFirst({
+            where: {
+                id: labChatId,
+                createdById: userId,
+            },
+        });
+        if (!labChat) {
+            throw new TRPCError({
+                code: 'FORBIDDEN',
+                message: 'Lab chat not found or not the creator',
+            });
+        }
+        // Delete lab chat and associated conversation
+        await prisma.$transaction(async (tx) => {
+            // Delete mentions first
+            await tx.mention.deleteMany({
+                where: {
+                    message: {
+                        conversationId: labChat.conversationId,
+                    },
+                },
+            });
+            // Delete messages
+            await tx.message.deleteMany({
+                where: {
+                    conversationId: labChat.conversationId,
+                },
+            });
+            // Delete conversation members
+            await tx.conversationMember.deleteMany({
+                where: {
+                    conversationId: labChat.conversationId,
+                },
+            });
+            // Delete lab chat
+            await tx.labChat.delete({
+                where: { id: labChatId },
+            });
+            // Delete conversation
+            await tx.conversation.delete({
+                where: { id: labChat.conversationId },
+            });
+        });
+        // Broadcast lab chat deletion
+        try {
+            await pusher.trigger(`class-${labChat.classId}`, 'lab-chat-deleted', {
+                labChatId,
+                classId: labChat.classId,
+            });
+        }
+        catch (error) {
+            console.error('Failed to broadcast lab chat deletion:', error);
+            // Don't fail the request if Pusher fails
+        }
+        return { success: true };
+    }),
+});

package/package.json

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

package/prisma/migrations/20250925072732_add_lab_chat_system/migration.sql

@@ -0,0 +1,25 @@
+-- CreateTable
+CREATE TABLE "LabChat" (
+    "id" TEXT NOT NULL,
+    "title" TEXT NOT NULL,
+    "context" TEXT NOT NULL,
+    "classId" TEXT NOT NULL,
+    "conversationId" TEXT NOT NULL,
+    "createdById" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "LabChat_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "LabChat_conversationId_key" ON "LabChat"("conversationId");
+
+-- AddForeignKey
+ALTER TABLE "LabChat" ADD CONSTRAINT "LabChat_classId_fkey" FOREIGN KEY ("classId") REFERENCES "Class"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "LabChat" ADD CONSTRAINT "LabChat_conversationId_fkey" FOREIGN KEY ("conversationId") REFERENCES "Conversation"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "LabChat" ADD CONSTRAINT "LabChat_createdById_fkey" FOREIGN KEY ("createdById") REFERENCES "User"("id") ON DELETE NO ACTION ON UPDATE CASCADE;

package/prisma/schema.prisma

@@ -80,6 +80,7 @@ model User {
   conversationMemberships ConversationMember[]
   sentMessages Message[] @relation("SentMessages")
   mentions Mention[] @relation("UserMentions")
+  createdLabChats LabChat[] @relation("CreatedLabChats")
 
 }
 
@@ -118,6 +119,7 @@ model Class {
   gradingBoundaries GradingBoundary[] @relation("ClassToGradingBoundary")
   draftFiles File[] @relation("ClassDraftFiles")
   classFiles Folder? @relation("ClassFiles")
+  labChats LabChat[] @relation("ClassLabChats")
 
   school    School? @relation(fields: [schoolId], references: [id])
   schoolId  String?
@@ -334,6 +336,22 @@ model Conversation {
   
   members ConversationMember[]
   messages Message[]
+  labChat LabChat?
+}
+
+model LabChat {
+  id String @id @default(uuid())
+  title String
+  context String // JSON string for LLM context
+  classId String
+  conversationId String @unique
+  createdById String // Teacher who created the lab
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+  
+  class Class @relation("ClassLabChats", fields: [classId], references: [id], onDelete: Cascade)
+  conversation Conversation @relation(fields: [conversationId], references: [id], onDelete: Cascade)
+  createdBy User @relation("CreatedLabChats", fields: [createdById], references: [id], onDelete: NoAction)
 }
 
 model ConversationMember {

package/src/routers/_app.ts

@@ -15,6 +15,7 @@ import { folderRouter } from "./folder.js";
 import { notificationRouter } from "./notifications.js";
 import { conversationRouter } from "./conversation.js";
 import { messageRouter } from "./message.js";
+import { labChatRouter } from "./labChat.js";
 
 export const appRouter = createTRPCRouter({
   class: classRouter,
@@ -31,6 +32,7 @@ export const appRouter = createTRPCRouter({
   notification: notificationRouter,
   conversation: conversationRouter,
   message: messageRouter,
+  labChat: labChatRouter,
 }); 
 
 // Export type router type definition