@studious-lms/server 1.2.53 → 1.4.0

package/src/routers/conversation.ts

@@ -1,377 +1,68 @@
-import { z } from 'zod';
-import { createTRPCRouter, protectedProcedure } from '../trpc.js';
-import { prisma } from '../lib/prisma.js';
-import { TRPCError } from '@trpc/server';
+import { z } from "zod";
+import { createTRPCRouter, protectedProcedure } from "../trpc.js";
+import {
+  listConversations,
+  createConversationRecord,
+  getConversation,
+  addMemberToConversation,
+  removeMemberFromConversation,
+} from "../services/conversation.js";
 
 export const conversationRouter = createTRPCRouter({
-  list: protectedProcedure.query(async ({ ctx }) => {
-    const userId = ctx.user!.id;
-
-    const conversations = await prisma.conversation.findMany({
-      where: {
-        members: {
-          some: {
-            userId,
-          },
-        },
-      },
-      include: {
-        labChat: {
-          select: {
-            id: true,
-            title: true,
-          },
-        },
-        members: {
-          include: {
-            user: {
-              select: {
-                id: true,
-                username: true,
-                profile: {
-                  select: {
-                    displayName: true,
-                    profilePicture: true,
-                  },
-                },
-              },
-            },
-          },
-        },
-        messages: {
-          orderBy: {
-            createdAt: 'desc',
-          },
-          take: 1,
-          include: {
-            sender: {
-              select: {
-                id: true,
-                username: true,
-                profile: {
-                  select: {
-                    displayName: true,
-                  },
-                },
-              },
-            },
-          },
-        },
-      },
-      orderBy: {
-        updatedAt: 'desc',
-      },
-    });
-
-    // Calculate unread counts for each conversation
-    const conversationsWithUnread = await Promise.all(
-      conversations.map(async (conversation) => {
-        const userMembership = conversation.members.find(m => m.userId === userId);
-        const lastViewedAt = userMembership?.lastViewedAt;
-        const lastViewedMentionAt = userMembership?.lastViewedMentionAt;
-        
-        // Count regular unread messages
-        const unreadCount = await prisma.message.count({
-          where: {
-            conversationId: conversation.id,
-            senderId: { not: userId },
-            ...(lastViewedAt && {
-              createdAt: { gt: 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 = lastViewedMentionAt && lastViewedAt 
-          ? (lastViewedMentionAt > lastViewedAt ? lastViewedMentionAt : lastViewedAt)
-          : (lastViewedMentionAt || lastViewedAt);
-        
-        const unreadMentionCount = await prisma.mention.count({
-          where: {
-            userId,
-            message: {
-              conversationId: conversation.id,
-              senderId: { not: userId },
-              ...(mentionCutoffTime && {
-                createdAt: { gt: mentionCutoffTime }
-              }),
-            },
-          },
-        });
-
-        return {
-          id: conversation.id,
-          type: conversation.type,
-          name: conversation.name,
-          createdAt: conversation.createdAt,
-          updatedAt: conversation.updatedAt,
-          labChat: conversation.labChat,
-          members: conversation.members,
-          lastMessage: conversation.messages[0] || null,
-          unreadCount,
-          unreadMentionCount,
-        };
-      })
-    );
-
-    return conversationsWithUnread;
-  }),
+  list: protectedProcedure.query(({ ctx }) =>
+    listConversations(ctx.user!.id)
+  ),
 
   create: protectedProcedure
     .input(
       z.object({
-        type: z.enum(['DM', 'GROUP']),
+        type: z.enum(["DM", "GROUP"]),
         name: z.string().optional(),
         memberIds: z.array(z.string()),
       })
     )
-    .mutation(async ({ input, ctx }) => {
-      const userId = ctx.user!.id;
-      const { type, name, memberIds } = input;
-
-      // Validate input
-      if (type === 'GROUP' && !name) {
-        throw new TRPCError({
-          code: 'BAD_REQUEST',
-          message: 'Group conversations must have a name',
-        });
-      }
-
-      if (type === 'DM' && memberIds.length !== 1) {
-        throw new TRPCError({
-          code: 'BAD_REQUEST',
-          message: 'DM conversations must have exactly one other member',
-        });
-      }
-
-      // For DMs, check if conversation already exists
-      if (type === 'DM') {
-        // Get the target user's ID from their username
-        const targetUser = await prisma.user.findFirst({
-          where: { username: memberIds[0] },
-          select: { id: true, username: true },
-        });
-
-        if (!targetUser) {
-          throw new TRPCError({
-            code: 'BAD_REQUEST',
-            message: `User "${memberIds[0]}" not found`,
-          });
-        }
-
-        // Find all DM conversations where current user is a member
-        const existingDMs = await prisma.conversation.findMany({
-          where: {
-            type: 'DM',
-            members: {
-              some: {
-                userId,
-              },
-            },
-          },
-          include: {
-            members: {
-              select: {
-                userId: true,
-              },
-            },
-          },
-        });
-
-        // Check if any of these conversations has exactly 2 members (current user + target user)
-        const existingDM = existingDMs.find(conv => {
-          const memberUserIds = conv.members.map(m => m.userId);
-          return memberUserIds.length === 2 &&
-                 memberUserIds.includes(userId) &&
-                 memberUserIds.includes(targetUser.id);
-        });
-
-        if (existingDM) {
-          // Conversation already exists, throw error with friendly message
-          throw new TRPCError({
-            code: 'BAD_REQUEST',
-            message: `A conversation with ${targetUser.username} already exists`,
-          });
-        }
-      }
-
-      // Verify all members exist
-      const membersWithIds = await prisma.user.findMany({
-        where: {
-          id: {
-            in: memberIds,
-          },
-        },
-        select: {
-          id: true,
-          username: true,
-        },
-      });
-
-      const membersWithUsernames = await prisma.user.findMany({
-        where: {
-          username: {
-            in: memberIds,
-          },
-        },
-        select: {
-          id: true,
-          username: true,
-        },
-      });
-
-      const members = [...membersWithIds, ...membersWithUsernames];
-
-      if (members.length !== memberIds.length) {
-        throw new TRPCError({
-          code: 'BAD_REQUEST',
-          message: 'One or more members not found',
-        });
-      }
-
-      // Create conversation with members
-      const conversation = await prisma.conversation.create({
-        data: {
-          type,
-          name,
-          members: {
-            create: [
-              {
-                userId,
-                role: type === 'GROUP' ? 'ADMIN' : 'MEMBER',
-              },
-              ...members.map((member) => ({
-                userId: member.id,
-                role: 'MEMBER' as const,
-              })),
-            ],
-          },
-        },
-        include: {
-          members: {
-            include: {
-              user: {
-                select: {
-                  id: true,
-                  username: true,
-                  profile: {
-                    select: {
-                      displayName: true,
-                      profilePicture: true,
-                    },
-                  },
-                },
-              },
-            },
-          },
-        },
-      });
-
-      return conversation;
-    }),
+    .mutation(({ ctx, input }) =>
+      createConversationRecord(
+        ctx.user!.id,
+        input.type,
+        input.name,
+        input.memberIds
+      )
+    ),
 
   get: protectedProcedure
     .input(z.object({ conversationId: z.string() }))
-    .query(async ({ input, ctx }) => {
-      const userId = ctx.user!.id;
-      const { conversationId } = input;
-
-      const conversation = await prisma.conversation.findFirst({
-        where: {
-          id: conversationId,
-          members: {
-            some: {
-              userId,
-            },
-          },
-        },
-        include: {
-          members: {
-            include: {
-              user: {
-                select: {
-                  id: true,
-                  username: true,
-                  profile: {
-                    select: {
-                      displayName: true,
-                      profilePicture: true,
-                    },
-                  },
-                },
-              },
-            },
-          },
-        },
-      });
+    .query(({ ctx, input }) =>
+      getConversation(ctx.user!.id, input.conversationId)
+    ),
 
-      if (!conversation) {
-        throw new TRPCError({
-          code: 'NOT_FOUND',
-          message: 'Conversation not found or access denied',
-        });
-      }
-
-      return conversation;
-    }),
-    addMember: protectedProcedure
-    .input(z.object({ conversationId: z.string(), memberUsername: z.string() }))
-    .mutation(async ({ input, ctx }) => {
-      const userId = ctx.user!.id;
-      const { conversationId, memberUsername } = input;
-
-      const conversation = await prisma.conversation.findFirst({
-        where: { id: conversationId, members: { some: { userId } } },
-      });
-
-      if (!conversation) {
-        throw new TRPCError({
-          code: 'NOT_FOUND',
-          message: 'Conversation not found or access denied',
-        });
-      }
-
-      const member = await prisma.user.findFirst({
-        where: { username: memberUsername },
-      });
-
-      if (!member) {
-        throw new TRPCError({
-          code: 'NOT_FOUND',
-          message: 'Member not found',
-        });
-      }
-
-      await prisma.conversationMember.create({
-        data: { userId: member.id, conversationId, role: 'MEMBER' },
-      });
-
-      return conversation;
-    }),
+  addMember: protectedProcedure
+    .input(
+      z.object({
+        conversationId: z.string(),
+        memberUsername: z.string(),
+      })
+    )
+    .mutation(({ ctx, input }) =>
+      addMemberToConversation(
+        ctx.user!.id,
+        input.conversationId,
+        input.memberUsername
+      )
+    ),
 
   removeMember: protectedProcedure
-    .input(z.object({ conversationId: z.string(), memberId: z.string() }))
-    .mutation(async ({ input, ctx }) => {
-      const userId = ctx.user!.id;
-      const { conversationId, memberId } = input;
-
-      const conversation = await prisma.conversation.findFirst({
-        where: { id: conversationId, members: { some: { userId } } },
-      });
-
-      if (!conversation) {
-        throw new TRPCError({
-          code: 'NOT_FOUND',
-          message: 'Conversation not found or access denied',
-        });
-      }
-
-      await prisma.conversationMember.delete({
-        where: { userId_conversationId: { userId: memberId, conversationId } },
-      });
-
-      return conversation;
-    }),
+    .input(
+      z.object({
+        conversationId: z.string(),
+        memberId: z.string(),
+      })
+    )
+    .mutation(({ ctx, input }) =>
+      removeMemberFromConversation(
+        ctx.user!.id,
+        input.conversationId,
+        input.memberId
+      )
+    ),
 });