Merge PR: notifications & real-time post updates

Author: hussein-m-kandil

prisma/migrations/20260301051502_add_notifications/migration.sql

@@ -0,0 +1,31 @@
+-- CreateTable
+CREATE TABLE "notifications_receivers" (
+    "profile_id" UUID NOT NULL,
+    "notification_id" UUID NOT NULL,
+    "seen_at" TIMESTAMP(3)
+);
+
+-- CreateTable
+CREATE TABLE "notifications" (
+    "id" UUID NOT NULL DEFAULT gen_random_uuid(),
+    "profile_id" UUID,
+    "profile_name" TEXT NOT NULL,
+    "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "description" TEXT,
+    "header" TEXT NOT NULL,
+    "url" TEXT NOT NULL,
+
+    CONSTRAINT "notifications_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "notifications_receivers_profile_id_notification_id_key" ON "notifications_receivers"("profile_id", "notification_id");
+
+-- AddForeignKey
+ALTER TABLE "notifications_receivers" ADD CONSTRAINT "notifications_receivers_profile_id_fkey" FOREIGN KEY ("profile_id") REFERENCES "profiles"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "notifications_receivers" ADD CONSTRAINT "notifications_receivers_notification_id_fkey" FOREIGN KEY ("notification_id") REFERENCES "notifications"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "notifications" ADD CONSTRAINT "notifications_profile_id_fkey" FOREIGN KEY ("profile_id") REFERENCES "profiles"("id") ON DELETE SET NULL ON UPDATE CASCADE;

prisma/schema.prisma

@@ -29,17 +29,19 @@ model User {
 }
 
 model Profile {
-  id           String                 @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
-  user         User                   @relation(fields: [userId], references: [id], onDelete: Cascade)
-  userId       String                 @unique @map("user_id") @db.Uuid
-  lastSeen     DateTime               @updatedAt @map("last_seen")
-  visible      Boolean                @default(true)
-  tangible     Boolean                @default(true)
-  chats        ProfilesChats[]
-  managedChats ProfilesManagedChats[]
-  sentMessages Message[]
-  followers    Follows[]              @relation("profile")
-  following    Follows[]              @relation("follower")
+  id                     String                   @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
+  user                   User                     @relation(fields: [userId], references: [id], onDelete: Cascade)
+  userId                 String                   @unique @map("user_id") @db.Uuid
+  lastSeen               DateTime                 @updatedAt @map("last_seen")
+  visible                Boolean                  @default(true)
+  tangible               Boolean                  @default(true)
+  chats                  ProfilesChats[]
+  managedChats           ProfilesManagedChats[]
+  notifications          NotificationsReceivers[]
+  triggeredNotifications Notification[]
+  sentMessages           Message[]
+  followers              Follows[]                @relation("profile")
+  following              Follows[]                @relation("follower")
 
   @@map("profiles")
 }
@@ -55,6 +57,31 @@ model Follows {
   @@map("follows")
 }
 
+model NotificationsReceivers {
+  profile        Profile      @relation(fields: [profileId], references: [id], onDelete: Cascade)
+  profileId      String       @map("profile_id") @db.Uuid
+  notification   Notification @relation(fields: [notificationId], references: [id], onDelete: Cascade)
+  notificationId String       @map("notification_id") @db.Uuid
+  seenAt         DateTime?    @map("seen_at")
+
+  @@unique([profileId, notificationId])
+  @@map("notifications_receivers")
+}
+
+model Notification {
+  id          String                   @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
+  profile     Profile?                 @relation(fields: [profileId], references: [id], onDelete: SetNull)
+  profileId   String?                  @map("profile_id") @db.Uuid
+  profileName String                   @map("profile_name")
+  createdAt   DateTime                 @default(now()) @map("created_at")
+  receivers   NotificationsReceivers[]
+  description String?
+  header      String
+  url         String
+
+  @@map("notifications")
+}
+
 enum ManagerRole {
   MODERATOR
   OWNER

src/api/v1/index.ts

@@ -1,4 +1,5 @@
 import { profilesRouter, lastSeenUpdater } from './profiles';
+import { notificationsRouter } from './notifications';
 import { charactersRouter } from './characters';
 import { imagesRouter } from './images';
 import { statsRouter } from './stats';
@@ -20,3 +21,4 @@ apiRouter.use('/stats', statsRouter);
 apiRouter.use('/images', imagesRouter);
 apiRouter.use('/profiles', profilesRouter);
 apiRouter.use('/characters', charactersRouter);
+apiRouter.use('/notifications', notificationsRouter);

src/api/v1/notifications/index.ts

@@ -0,0 +1,2 @@
+export * from './notifications.router';
+export * from './notifications.service';

src/api/v1/notifications/notifications.router.ts

@@ -0,0 +1,31 @@
+import * as Validators from '@/middlewares/validators';
+import * as Service from './notifications.service';
+import * as Utils from '@/lib/utils';
+import { Router } from 'express';
+
+export const notificationsRouter = Router();
+
+notificationsRouter.get('/', Validators.authValidator, async (req, res) => {
+  const userId = Utils.getCurrentUserIdFromReq(req)!;
+  const filters = Utils.getBasePaginationFiltersFromReqQuery(req);
+  res.json(await Service.getUserNotifications(userId, filters));
+});
+
+notificationsRouter.get('/:id', Validators.authValidator, async (req, res) => {
+  const userId = Utils.getCurrentUserIdFromReq(req)!;
+  res.json(await Service.getUserNotificationById(req.params.id, userId));
+});
+
+notificationsRouter.patch('/seen', Validators.authValidator, async (req, res) => {
+  const userId = Utils.getCurrentUserIdFromReq(req)!;
+  await Service.markUserNotificationsAsSeen(userId);
+  res.status(204).end();
+});
+
+notificationsRouter.delete('/:id', Validators.authValidator, async (req, res) => {
+  const userId = Utils.getCurrentUserIdFromReq(req)!;
+  await Service.deleteUserNotificationById(req.params.id, userId);
+  res.status(204).end();
+});
+
+export default notificationsRouter;

src/api/v1/notifications/notifications.service.ts

@@ -0,0 +1,90 @@
+import * as Types from '@/types';
+import * as Utils from '@/lib/utils';
+import * as AppError from '@/lib/app-error';
+import { Notification, User } from '@/../prisma/client';
+import db from '@/lib/db';
+
+export const prepareNotification = async (
+  notificationPayload: Types.NotificationPayload,
+  userId: User['id'],
+): Promise<Types.PublicNotification> => {
+  const { receivers, profile, profileId, ...notification } = notificationPayload;
+  const seenAt = receivers.find((r) => r.profile.userId === userId)?.seenAt ?? null;
+  if (profile) {
+    const followedByCurrentUser = !!(await db.follows.findFirst({
+      where: { follower: { userId }, profile: { id: profileId ?? profile.id } },
+    }));
+    return { ...notification, seenAt, profileId, profile: { ...profile, followedByCurrentUser } };
+  }
+  return { ...notification, seenAt, profileId, profile };
+};
+
+export const getUserNotifications = async (
+  userId: User['id'],
+  filters: Types.BasePaginationFilters,
+) => {
+  const notifications = await Utils.handleDBKnownErrors(
+    db.notification.findMany({
+      where: { receivers: { some: { profile: { userId } } } },
+      include: {
+        profile: Utils.profileAggregation,
+        receivers: {
+          where: { profile: { userId } },
+          include: { profile: Utils.profileAggregation },
+        },
+      },
+      ...(filters.cursor ? { cursor: { id: filters.cursor }, skip: 1 } : {}),
+      orderBy: { createdAt: filters.sort ?? 'desc' },
+      take: filters.limit ?? 10,
+    }),
+  );
+  const preparedNotifications: Awaited<ReturnType<typeof prepareNotification>>[] = [];
+  for (const notification of notifications) {
+    preparedNotifications.push(await prepareNotification(notification, userId));
+  }
+  return preparedNotifications;
+};
+
+export const getUserNotificationById = async (id: Notification['id'], userId: User['id']) => {
+  let notification: Types.NotificationPayload | null = null;
+  try {
+    notification = await Utils.handleDBKnownErrors(
+      db.notification.findUnique({
+        where: { id, receivers: { some: { profile: { userId } } } },
+        include: {
+          profile: Utils.profileAggregation,
+          receivers: {
+            where: { profile: { userId } },
+            include: { profile: Utils.profileAggregation },
+          },
+        },
+      }),
+    );
+  } catch (error) {
+    if (!(error instanceof AppError.AppInvalidIdError)) throw error;
+  }
+  if (!notification) throw new AppError.AppNotFoundError('Notification not found.');
+  return await prepareNotification(notification, userId);
+};
+
+export const markUserNotificationsAsSeen = async (userId: User['id']) => {
+  await Utils.handleDBKnownErrors(
+    db.notificationsReceivers.updateMany({
+      where: { profile: { userId }, seenAt: null },
+      data: { seenAt: new Date() },
+    }),
+  );
+};
+
+export const deleteUserNotificationById = async (id: Notification['id'], userId: User['id']) => {
+  try {
+    await Utils.handleDBKnownErrors(
+      db.notificationsReceivers.deleteMany({ where: { notificationId: id, profile: { userId } } }),
+    );
+  } catch (error) {
+    if (
+      !(error instanceof AppError.AppInvalidIdError || error instanceof AppError.AppNotFoundError)
+    )
+      throw error;
+  }
+};

src/api/v1/posts/posts.router.ts

@@ -6,6 +6,7 @@ import * as Storage from '@/lib/storage';
 import * as Service from './posts.service';
 import * as Middlewares from '@/middlewares';
 import { Router, Request, Response } from 'express';
+import io from '@/lib/io';
 
 export const postsRouter = Router();
 
@@ -143,26 +144,43 @@ postsRouter.post(
     } else {
       createdPost = await Service.createPost(postData, user);
     }
-    res.status(201).json(createdPost);
+    res
+      .status(201)
+      .json(createdPost)
+      .on('finish', () => {
+        io.except(createdPost.author.profile?.id ?? []).emit('post:created', createdPost.id);
+      });
   },
 );
 
 postsRouter.post('/:id/upvote', Middlewares.authValidator, async (req, res) => {
   const user = req.user as Types.PublicUser;
   const upvotedPost = await Service.upvotePost(req.params.id, user.id);
-  res.json(upvotedPost);
+  res.json(upvotedPost).on('finish', () => {
+    io.except(user.profile?.id ?? []).emit('post:upvoted', upvotedPost.id);
+    if (upvotedPost.author.profile) {
+      io.to(upvotedPost.author.profile.id).emit('notifications:updated');
+    }
+  });
 });
 
 postsRouter.post('/:id/downvote', Middlewares.authValidator, async (req, res) => {
   const user = req.user as Types.PublicUser;
   const downvotedPost = await Service.downvotePost(req.params.id, user.id);
-  res.json(downvotedPost);
+  res.json(downvotedPost).on('finish', () => {
+    io.except(user.profile?.id ?? []).emit('post:downvoted', downvotedPost.id);
+    if (downvotedPost.author.profile) {
+      io.to(downvotedPost.author.profile.id).emit('notifications:updated');
+    }
+  });
 });
 
 postsRouter.post('/:id/unvote', Middlewares.authValidator, async (req, res) => {
   const user = req.user as Types.PublicUser;
   const unvotedPost = await Service.unvotePost(req.params.id, user.id);
-  res.json(unvotedPost);
+  res.json(unvotedPost).on('finish', () => {
+    io.except(user.profile?.id ?? []).emit('post:unvoted', unvotedPost.id);
+  });
 });
 
 postsRouter.post(
@@ -171,12 +189,22 @@ postsRouter.post(
   async (req: Request<{ id: string }, unknown, { content: string }>, res) => {
     const user = req.user as Types.PublicUser;
     const commentData = Schema.commentSchema.parse(req.body);
-    const newComment = await Service.findPostByIdAndCreateComment(
+    const { createdComment, post } = await Service.findPostByIdAndCreateComment(
       req.params.id,
       user.id,
       commentData,
     );
-    res.status(200).json(newComment);
+    res
+      .status(200)
+      .json(createdComment)
+      .on('finish', () => {
+        if (post.author.profile) {
+          io.to(post.author.profile.id).emit('notifications:updated');
+        }
+        const { postId } = createdComment;
+        const commentProfileId = createdComment.author.profile?.id;
+        io.except(commentProfileId ?? []).emit('post:comment:created', postId, createdComment.id);
+      });
   },
 );
 
@@ -207,7 +235,9 @@ postsRouter.put(
     } else {
       updatedPost = await Service.updatePost(post, user, postData, imagedata);
     }
-    res.json(updatedPost);
+    res.json(updatedPost).on('finish', () => {
+      io.except(updatedPost.author.profile?.id ?? []).emit('post:updated', updatedPost.id);
+    });
   },
 );
 
@@ -218,8 +248,20 @@ postsRouter.put(
   async (req, res) => {
     const user = req.user as Types.PublicUser;
     const commentData = Schema.commentSchema.parse(req.body);
-    const updatedComment = await Service.findCommentAndUpdate(req.params.cId, user.id, commentData);
-    res.json(updatedComment);
+    const { updatedComment, post } = await Service.findCommentAndUpdate(
+      req.params.pId,
+      req.params.cId,
+      user.id,
+      commentData,
+    );
+    res.json(updatedComment).on('finish', () => {
+      if (post.author.profile) {
+        io.to(post.author.profile.id).emit('notifications:updated');
+      }
+      const { postId } = updatedComment;
+      const commentProfileId = updatedComment.author.profile?.id;
+      io.except(commentProfileId ?? []).emit('post:comment:updated', postId, updatedComment.id);
+    });
   },
 );
 
@@ -230,9 +272,15 @@ postsRouter.delete(
     async (req, res) => await getPostAuthorIdAndInjectPostInResLocals(req, res),
   ),
   async (req, res: Response<unknown, { post: Service._PostFullData }>) => {
+    const deletedPost = res.locals.post;
     const userId = Utils.getCurrentUserIdFromReq(req);
-    await Service.deletePost(res.locals.post, userId);
-    res.status(204).end();
+    await Service.deletePost(deletedPost, userId);
+    res
+      .status(204)
+      .end()
+      .on('finish', () => {
+        io.except(deletedPost.author.profile?.id ?? []).emit('post:deleted', deletedPost.id);
+      });
   },
 );
 
@@ -246,8 +294,15 @@ postsRouter.delete(
     return postAuthorId === userId ? postAuthorId : await getCommentAuthorId(req);
   }),
   async (req, res) => {
-    const userId = Utils.getCurrentUserIdFromReq(req);
-    await Service.findCommentAndDelete(req.params.cId, userId);
-    res.status(204).end();
+    const user = req.user as Types.PublicUser;
+    await Service.findCommentAndDelete(req.params.cId, user.id);
+    res
+      .status(204)
+      .end()
+      .on('finish', () => {
+        const postId = req.params.pId;
+        const commentId = req.params.cId;
+        io.except(user.profile?.id ?? []).emit('post:comment:deleted', postId, commentId);
+      });
   },
 );