feat: add endpoint to remove a guest from an event and enhance guest group deletion process

Author: akshit1003

src/routes/guestRoutes.ts

@@ -11,7 +11,8 @@ import {
   removeUserFromGroup,
   getMyGuestGroups,
   getAvailableGuestGroupsForEvent,
-  removeGuestGroupFromEvent
+  removeGuestGroupFromEvent,
+  removeGuestFromEvent
 } from '../services/guestService';
 import { verifyIdToken } from '../middleware/verifyIdToken';
 
@@ -405,4 +406,38 @@ router.delete('/:eventId/groups/:groupId/members', verifyIdToken, async (req: Re
   }
 });
 
+// Remove a specific guest from an event
+router.delete('/:eventId/guests/:guestId', verifyIdToken, async (req: Request, res: Response): Promise<void> => {
+  try {
+    const { eventId, guestId } = req.params;
+    const userId = req.userId;
+
+    if (!userId) {
+      res.status(401).json({ message: 'Unauthorized' });
+      return;
+    }
+
+    const isAuthorized = await isEventHostOrCoHost(userId, eventId);
+    if (!isAuthorized) {
+      res.status(403).json({ message: 'Only event hosts and co-hosts can remove guests from events' });
+      return;
+    }
+
+    const result = await removeGuestFromEvent(guestId, eventId);
+
+    if (!result.success) {
+      res.status(400).json({ message: result.error });
+      return;
+    }
+
+    res.status(200).json({
+      message: result.message,
+      removedGuest: result.removedGuest
+    });
+  } catch (error) {
+    console.error('Remove guest from event error:', error);
+    res.status(500).json({ message: 'Internal Server Error' });
+  }
+});
+
 export default router;

src/services/guestService.ts

@@ -289,22 +289,35 @@ export const deleteGuestGroup = async (groupId: string) => {
       };
     }
 
-    // Check if group has active guests/RSVPs
-    if (guestGroup.guests.length > 0) {
-      return {
-        success: false,
-        error: 'Cannot delete guest group with existing guests. Remove all guests first or transfer them to another group.'
-      };
-    }
+    // Delete the guest group and all related records in a transaction
+    await prisma.$transaction(async (tx) => {
+      // Delete all messages related to guests in this group
+      const guestIds = guestGroup.guests.map(g => g.id);
+      if (guestIds.length > 0) {
+        await tx.message.deleteMany({
+          where: { guest_id: { in: guestIds } }
+        });
+      }
+
+      // Delete all guests in this group
+      await tx.guest.deleteMany({
+        where: { group_id: groupId }
+      });
+
+      // Delete all invites associated with this group
+      await tx.invite.deleteMany({
+        where: { group_id: groupId }
+      });
 
-    // Delete the guest group (cascade will handle relations)
-    await prisma.guestGroup.delete({
-      where: { id: groupId }
+      // Delete the guest group (cascade will handle GuestGroupUsers, InviteLinks, and EventGuestGroup)
+      await tx.guestGroup.delete({
+        where: { id: groupId }
+      });
     });
 
     return {
       success: true,
-      message: 'Guest group deleted successfully'
+      message: 'Guest group and all associated members and guests deleted successfully'
     };
   } catch (error: unknown) {
     return {
@@ -1163,4 +1176,72 @@ export const getEventRsvpsWithUnlinked = async (eventId: string, userId: string)
       error: error instanceof Error ? error.message : 'Failed to get event RSVPs'
     };
   }
-};
+};
+
+// New function to remove a guest from an event
+export const removeGuestFromEvent = async (guestId: string, eventId: string) => {
+  try {
+    // Check if guest exists and belongs to the specified event
+    const guest = await prisma.guest.findUnique({
+      where: { id: guestId },
+      include: {
+        user: {
+          select: {
+            id: true,
+            name: true,
+            mobile_number: true
+          }
+        },
+        group: {
+          select: {
+            id: true,
+            name: true
+          }
+        }
+      }
+    });
+
+    if (!guest) {
+      return {
+        success: false,
+        error: 'Guest not found'
+      };
+    }
+
+    if (guest.event_id !== eventId) {
+      return {
+        success: false,
+        error: 'Guest does not belong to this event'
+      };
+    }
+
+    // Delete the guest and related messages in a transaction
+    await prisma.$transaction(async (tx) => {
+      // Delete all messages from this guest
+      await tx.message.deleteMany({
+        where: { guest_id: guestId }
+      });
+
+      // Delete the guest record
+      await tx.guest.delete({
+        where: { id: guestId }
+      });
+    });
+
+    return {
+      success: true,
+      message: 'Guest removed from event successfully',
+      removedGuest: {
+        id: guest.id,
+        name: guest.name || guest.user?.name,
+        phone: guest.phone_no || guest.user?.mobile_number,
+        groupName: guest.group?.name
+      }
+    };
+  } catch (error: unknown) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to remove guest from event'
+    };
+  }
+};