@studious-lms/server 1.2.53 → 1.4.0

package/src/routers/labChat.ts

@@ -1,10 +1,13 @@
-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';
-import { isAIUser } from '../utils/aiUser.js';
-import { generateAndSendLabIntroduction, generateAndSendLabResponse } from '../server/pipelines/aiLabChat.js';
+import { z } from "zod";
+import { createTRPCRouter, protectedProcedure } from "../trpc.js";
+import {
+  createLabChat,
+  getLabChat,
+  listLabChats,
+  postToLabChat,
+  deleteLabChat,
+  rerunLastResponse,
+} from "../services/labChat.js";
 
 export const labChatRouter = createTRPCRouter({
   create: protectedProcedure
@@ -12,419 +15,24 @@ export const labChatRouter = createTRPCRouter({
       z.object({
         classId: z.string(),
         title: z.string().min(1).max(200),
-        context: z.string(), // JSON string for LLM context
+        context: z.string(),
       })
     )
-    .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 only teachers to the conversation (this is for course material creation)
-        const teacherMembers = classWithTeachers.teachers.map(t => ({ 
-          userId: t.id, 
-          role: 'ADMIN' as const 
-        }));
-
-        await tx.conversationMember.createMany({
-          data: teacherMembers.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;
-      });
-
-      // Generate AI introduction message in parallel (don't await - fire and forget)
-      generateAndSendLabIntroduction(result.id, result.conversationId, context, classWithTeachers.subject || 'Lab');
-      // 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;
-    }),
+    .mutation(({ ctx, input }) =>
+      createLabChat(ctx.user!.id, {
+        classId: input.classId,
+        title: input.title,
+        context: input.context,
+      })
+    ),
 
   get: protectedProcedure
     .input(z.object({ labChatId: z.string() }))
-    .query(async ({ input, ctx }) => {
-      const userId = ctx.user!.id;
-      const { labChatId } = input;
-
-      // First, try to find the lab chat if user is already a member
-      let 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 not found, check if user is a teacher in the class
-      if (!labChat) {
-        const labChatForTeacher = await prisma.labChat.findFirst({
-          where: {
-            id: labChatId,
-            class: {
-              teachers: {
-                some: {
-                  id: userId,
-                },
-              },
-            },
-          },
-          include: {
-            conversation: {
-              select: {
-                id: true,
-              },
-            },
-          },
-        });
-
-        if (labChatForTeacher) {
-          // Add teacher to conversation
-          await prisma.conversationMember.create({
-            data: {
-              userId,
-              conversationId: labChatForTeacher.conversation.id,
-              role: 'ADMIN',
-            },
-          });
-
-          // Now fetch the full lab chat with the user as a member
-          labChat = await prisma.labChat.findFirst({
-            where: {
-              id: labChatId,
-            },
-            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;
-    }),
+    .query(({ ctx, input }) => getLabChat(ctx.user!.id, input.labChatId)),
 
   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,
-      }));
-    }),
+    .query(({ ctx, input }) => listLabChats(ctx.user!.id, input.classId)),
 
   postToLabChat: protectedProcedure
     .input(
@@ -434,200 +42,23 @@ export const labChatRouter = createTRPCRouter({
         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 (same format as regular chat)
-      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,
-        });
-      } catch (error) {
-        console.error('Failed to broadcast lab chat message:', error);
-        // Don't fail the request if Pusher fails
-      }
-
-        // Generate AI response in parallel (don't await - fire and forget)
-        if (!isAIUser(userId)) {
-          // Run AI response generation in background
-          generateAndSendLabResponse(labChatId, content, labChat.conversationId)
-        }
-
-      return {
-        id: result.id,
-        content: result.content,
-        senderId: result.senderId,
-        conversationId: result.conversationId,
-        createdAt: result.createdAt,
-        sender: result.sender,
-        mentionedUserIds,
-      };
-    }),
+    .mutation(({ ctx, input }) =>
+      postToLabChat(ctx.user!.id, {
+        labChatId: input.labChatId,
+        content: input.content,
+        mentionedUserIds: input.mentionedUserIds,
+      })
+    ),
 
   delete: protectedProcedure
     .input(z.object({ labChatId: z.string() }))
-    .mutation(async ({ input, ctx }) => {
-      const userId = ctx.user!.id;
-      const { labChatId } = input;
+    .mutation(({ ctx, input }) =>
+      deleteLabChat(ctx.user!.id, input.labChatId)
+    ),
 
-      // 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 };
-    }),
+  rerunLastResponse: protectedProcedure
+    .input(z.object({ labChatId: z.string() }))
+    .mutation(({ ctx, input }) =>
+      rerunLastResponse(ctx.user!.id, input.labChatId)
+    ),
 });
-