🐛 notifications and some error messages

Author: kalashshah

graphql/notification.graphql

@@ -2,15 +2,23 @@ enum NotificationType {
   FOLLOWING
 }
 
+type UserAvatar {
+  id: ID!
+  name: String!
+  profilePicture: String
+}
+
 type Notification {
   id: ID!
   description: String!
   createdAt: DateTime!
   seenAt: DateTime
   seenStatus: Boolean!
-  user: User
+  User: UserAvatar
   userId: ID
   notificationType: NotificationType!
+  otherUserId: ID
+  OtherUser: UserAvatar
 }
 
 input SeeNotificationInput {

prisma/schema.prisma

@@ -26,6 +26,7 @@ model User {
   followedBy             User[]         @relation("FollowingUser", fields: [followedByIds], references: [id])
   followedByIds          String[]       @db.ObjectId
   notifications          Notification[]
+  othersNotifications    Notification[] @relation("NotificationOtherUser")
 }
 
 model Token {
@@ -55,4 +56,6 @@ model Notification {
   User             User?            @relation(fields: [userId], references: [id])
   userId           String?          @db.ObjectId
   notificationType NotificationType
+  otherUserId      String?          @db.ObjectId
+  OtherUser        User?            @relation("NotificationOtherUser", fields: [otherUserId], references: [id])
 }

src/graphql.types.ts

@@ -293,15 +293,23 @@ export class GithubGraphsOutput {
     statsGraph: GithubStatistics;
 }
 
+export class UserAvatar {
+    id: string;
+    name: string;
+    profilePicture?: Nullable<string>;
+}
+
 export class Notification {
     id: string;
     description: string;
     createdAt: DateTime;
     seenAt?: Nullable<DateTime>;
     seenStatus: boolean;
-    user?: Nullable<User>;
+    User?: Nullable<UserAvatar>;
     userId?: Nullable<string>;
     notificationType: NotificationType;
+    otherUserId?: Nullable<string>;
+    OtherUser?: Nullable<UserAvatar>;
 }
 
 export class NotificationOutput {

src/notification/notification.resolver.ts

@@ -1,4 +1,5 @@
 import { Mutation, Resolver, Context, Args, Query } from '@nestjs/graphql';
+import { getToken } from 'src/constants/decode';
 import { SeeNotificationInput, SeeNotificationsInput } from 'src/graphql.types';
 import { NotificationService } from './notification.service';
 
@@ -11,10 +12,7 @@ export class NotificationResolver {
     @Args('input') input: SeeNotificationInput,
     @Context() context,
   ) {
-    const token = context?.req?.headers?.authorization.split(' ')[1];
-    if (!token) {
-      throw new Error('Invalid request, token not found');
-    }
+    const token = getToken(context);
     await this.notificationService.seeNotification(input.notificationId, token);
     return 'Notification seen';
   }
@@ -24,10 +22,7 @@ export class NotificationResolver {
     @Args('input') input: SeeNotificationsInput,
     @Context() context,
   ) {
-    const token = context?.req?.headers?.authorization.split(' ')[1];
-    if (!token) {
-      throw new Error('Invalid request, token not found');
-    }
+    const token = getToken(context);
     await this.notificationService.seeNotifications(
       input.notificationIds,
       token,
@@ -37,11 +32,9 @@ export class NotificationResolver {
 
   @Query('notifications')
   async notifications(@Context() context) {
-    const token = context?.req?.headers?.authorization.split(' ')[1];
-    if (!token) {
-      throw new Error('Invalid request, token not found');
-    }
+    const token = getToken(context);
     const notifications = await this.notificationService.notifications(token);
+    console.log(notifications);
     return notifications;
   }
 }

src/notification/notification.service.ts

@@ -1,100 +1,172 @@
 import { Injectable } from '@nestjs/common';
+import { NotificationType } from 'src/graphql.types';
 import { PrismaService } from 'prisma/prisma.service';
 import { decode } from 'src/constants/decode';
+import { NotificationOutput } from 'src/graphql.types';
+import { HttpException, HttpStatus } from '@nestjs/common';
 
 @Injectable()
 export class NotificationService {
   constructor(private prisma: PrismaService) {}
 
   async sendNotification(
-    userId: string,
+    toUser: string,
     description: string,
-    type: 'FOLLOWING',
-  ) {
-    await this.prisma.user.update({
-      where: { id: userId },
-      data: {
-        notifications: {
-          create: {
-            description,
-            notificationType: type,
+    type: NotificationType,
+    fromUser?: string,
+  ): Promise<void> {
+    try {
+      await this.prisma.notification.deleteMany({
+        where: {
+          userId: toUser,
+          notificationType: type,
+          otherUserId: fromUser,
+        },
+      });
+    } catch {
+      throw new HttpException(
+        'Error occurred while deleting previous notifications',
+        HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
+    try {
+      await this.prisma.notification.create({
+        data: {
+          description,
+          notificationType: type,
+          User: {
+            connect: {
+              id: toUser,
+            },
+          },
+          OtherUser: {
+            connect: {
+              id: fromUser,
+            },
           },
         },
-      },
-    });
+      });
+    } catch {
+      throw new HttpException(
+        'Error occurred while sending notification',
+        HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
   }
 
   async seeNotification(notificationId: string, token: string) {
     await decode(token, this.prisma);
-    const notification = await this.prisma.notification.update({
-      where: {
-        id: notificationId,
-      },
-      data: {
-        seenStatus: true,
-        seenAt: new Date(),
-      },
-    });
-    return notification;
+    try {
+      const notification = await this.prisma.notification.update({
+        where: {
+          id: notificationId,
+        },
+        data: {
+          seenStatus: true,
+          seenAt: new Date(),
+        },
+      });
+      return notification;
+    } catch {
+      throw new HttpException(
+        'Error occurred while marking notification as seen',
+        HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
   }
 
   async seeNotifications(notificationIds: string[], token: string) {
     await decode(token, this.prisma);
-    const notifications = await this.prisma.notification.updateMany({
-      where: {
-        id: {
-          in: notificationIds,
+    try {
+      const notifications = await this.prisma.notification.updateMany({
+        where: {
+          id: {
+            in: notificationIds,
+          },
+        },
+        data: {
+          seenStatus: true,
+          seenAt: new Date(),
         },
-      },
-      data: {
-        seenStatus: true,
-        seenAt: new Date(),
-      },
-    });
-    return notifications;
+      });
+      return notifications;
+    } catch {
+      throw new HttpException(
+        'Error occurred while marking notifications as seen',
+        HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
   }
 
-  async notifications(token: string) {
+  async notifications(token: string): Promise<NotificationOutput> {
     const user = await decode(token, this.prisma);
-    const notifs = await this.prisma.user.findUnique({
-      where: {
-        id: user.id,
-      },
-      select: {
-        notifications: {
-          orderBy: {
-            createdAt: 'desc',
-          },
+    this.deleteSeenPreviousNotifications();
+    try {
+      const notifs = await this.prisma.user.findUnique({
+        where: {
+          id: user.id,
         },
-      },
-    });
-    const unseenNotifs = await this.prisma.user.count({
-      where: {
-        id: user.id,
-        notifications: {
-          some: {
-            seenStatus: false,
+        select: {
+          notifications: {
+            orderBy: {
+              createdAt: 'desc',
+            },
+            select: {
+              id: true,
+              description: true,
+              notificationType: true,
+              seenStatus: true,
+              createdAt: true,
+              OtherUser: {
+                select: {
+                  id: true,
+                  name: true,
+                  profilePicture: true,
+                },
+              },
+              User: {
+                select: {
+                  id: true,
+                  name: true,
+                  profilePicture: true,
+                },
+              },
+            },
           },
         },
-      },
-    });
-    return {
-      notifications: notifs?.notifications,
-      unseenNotifications: unseenNotifs,
-    };
+      });
+      let unseenNotifications = 0;
+      for (const notif of notifs?.notifications) {
+        if (notif.seenStatus === false) unseenNotifications++;
+      }
+      return {
+        unseenNotifications: unseenNotifications,
+        notifications:
+          notifs?.notifications as NotificationOutput['notifications'],
+      };
+    } catch {
+      throw new HttpException(
+        'Error occurred while fetching notifications',
+        HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
   }
 
-  /**
-   * Delete all notifications that were seen 48 hours ago
-   */
   async deleteSeenPreviousNotifications() {
-    await this.prisma.notification.deleteMany({
-      where: {
-        seenStatus: true,
-        seenAt: {
-          lt: new Date(new Date().getTime() - 48 * 60 * 60 * 1000),
+    try {
+      await this.prisma.notification.deleteMany({
+        where: {
+          seenStatus: true,
+          seenAt: {
+            lt: new Date(new Date().getTime() - 24 * 60 * 60 * 1000),
+          },
         },
-      },
-    });
+      });
+    } catch (err) {
+      throw new HttpException(
+        'Error occurred while deleting previous notifications',
+        HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+    }
   }
 }