@studious-lms/server 1.2.53 → 1.3.0

package/dist/routers/labChat.js

@@ -1,591 +1,40 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="933db03e-fc38-599b-93a4-890502ba8281")}catch(e){}}();
-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';
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="0306881b-6822-54b3-a1a1-dd8712a108e9")}catch(e){}}();
+import { z } from "zod";
+import { createTRPCRouter, protectedProcedure } from "../trpc.js";
+import { createLabChat, getLabChat, listLabChats, postToLabChat, deleteLabChat, } from "../services/labChat.js";
 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
+        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'
-            }));
-            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(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 (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;
-        // 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 };
-    }),
+        .mutation(({ ctx, input }) => deleteLabChat(ctx.user.id, input.labChatId)),
 });
 //# sourceMappingURL=labChat.js.map
-//# debugId=933db03e-fc38-599b-93a4-890502ba8281
+//# debugId=0306881b-6822-54b3-a1a1-dd8712a108e9