feat: notificationSettings (#2954)

Author: AmarTrebinjac

__tests__/__snapshots__/users.ts.snap

@@ -50,7 +50,6 @@ Object {
   "infoConfirmed": false,
   "language": null,
   "name": "Ido",
-  "notificationEmail": true,
   "permalink": "http://localhost:5002/aaa1",
   "timezone": "Europe/London",
   "twitter": null,

__tests__/boot.ts

@@ -129,14 +129,9 @@ const LOGGED_IN_BODY = {
     timezone: DEFAULT_TIMEZONE,
     reputation: 10,
     portfolio: null,
-    notificationEmail: true,
     acceptedMarketing: false,
     company: null,
     experienceLevel: null,
-    followNotifications: true,
-    followingEmail: true,
-    awardEmail: true,
-    awardNotifications: true,
     isTeamMember: false,
     bluesky: null,
     roadmap: null,

__tests__/common/mailing.ts

@@ -9,11 +9,8 @@ import {
   UserPersonalizedDigestType,
 } from '../../src/entity';
 import { usersFixture } from '../fixture/user';
-import {
-  CioUnsubscribeTopic,
-  syncSubscription,
-  updateFlagsStatement,
-} from '../../src/common';
+import { syncSubscription, updateFlagsStatement } from '../../src/common';
+import { CioUnsubscribeTopic } from '../../src/cio';
 
 let con: DataSource;
 

__tests__/notifications.ts

@@ -20,6 +20,7 @@ import {
   NotificationPreference,
   NotificationAttachmentType,
 } from '../src/entity';
+import type { UserNotificationFlags } from '../src/entity/user/User';
 import { DataSource } from 'typeorm';
 import createOrGetConnection from '../src/db';
 import { usersFixture } from './fixture/user';
@@ -33,6 +34,8 @@ import {
   NotificationPreferenceType,
   NotificationType,
   saveNotificationPreference,
+  streamNotificationUsers,
+  NotificationChannel,
 } from '../src/notifications/common';
 import { postsFixture, sharedPostsFixture } from './fixture/post';
 import { sourcesFixture } from './fixture/source';
@@ -1227,3 +1230,238 @@ describe('mutation subscribeNotificationPreference', () => {
     );
   });
 });
+
+describe('streamNotificationUsers', () => {
+  const setupNotificationAndUsers = async (
+    users: {
+      id: string;
+      name: string;
+      email: string;
+      notificationFlags?: UserNotificationFlags;
+    }[],
+  ) => {
+    await con.getRepository(User).save(users);
+
+    const notif = await con.getRepository(NotificationV2).save({
+      ...notificationV2Fixture,
+      type: NotificationType.ArticleNewComment,
+    });
+
+    const userNotifications = users.map((user) => ({
+      userId: user.id,
+      notificationId: notif.id,
+      public: true,
+      createdAt: notificationV2Fixture.createdAt,
+    }));
+
+    await con.getRepository(UserNotification).insert(userNotifications);
+
+    return notif.id;
+  };
+
+  const streamToArray = async (
+    stream: NodeJS.ReadableStream,
+  ): Promise<{ userId: string }[]> => {
+    const results: { userId: string }[] = [];
+    return new Promise((res) => {
+      stream.on('data', (data: { userId: string }) => {
+        results.push({ userId: data.userId });
+      });
+      stream.on('end', () => res(results));
+    });
+  };
+
+  it('should return users for inApp channel when no preferences set', async () => {
+    const users = [
+      { id: 'user1', name: 'User 1', email: '[email protected]' },
+      { id: 'user2', name: 'User 2', email: '[email protected]' },
+    ];
+
+    const notifId = await setupNotificationAndUsers(users);
+    const stream = await streamNotificationUsers(
+      con,
+      notifId,
+      NotificationChannel.InApp,
+    );
+    const results = await streamToArray(stream);
+
+    expect(results).toHaveLength(2);
+    expect(results.map((r) => r.userId).sort()).toEqual(['user1', 'user2']);
+  });
+
+  it('should return users for email channel when no preferences set', async () => {
+    const users = [
+      { id: 'user3', name: 'User 3', email: '[email protected]' },
+      { id: 'user4', name: 'User 4', email: '[email protected]' },
+    ];
+
+    const notifId = await setupNotificationAndUsers(users);
+    const stream = await streamNotificationUsers(
+      con,
+      notifId,
+      NotificationChannel.Email,
+    );
+    const results = await streamToArray(stream);
+
+    expect(results).toHaveLength(2);
+    expect(results.map((r) => r.userId).sort()).toEqual(['user3', 'user4']);
+  });
+
+  it('should exclude users with global inApp mute preference', async () => {
+    const users = [
+      {
+        id: 'user5',
+        name: 'User 5',
+        email: '[email protected]',
+        notificationFlags: {
+          [NotificationType.ArticleNewComment]: {
+            inApp: NotificationPreferenceStatus.Muted,
+          },
+        },
+      },
+      {
+        id: 'user6',
+        name: 'User 6',
+        email: '[email protected]',
+        notificationFlags: {
+          [NotificationType.ArticleNewComment]: {
+            inApp: NotificationPreferenceStatus.Subscribed,
+          },
+        },
+      },
+    ];
+
+    const notifId = await setupNotificationAndUsers(users);
+    const stream = await streamNotificationUsers(
+      con,
+      notifId,
+      NotificationChannel.InApp,
+    );
+    const results = await streamToArray(stream);
+
+    expect(results).toHaveLength(1);
+    expect(results[0].userId).toBe('user6');
+  });
+
+  it('should exclude users with global email mute preference', async () => {
+    const users = [
+      {
+        id: 'user7',
+        name: 'User 7',
+        email: '[email protected]',
+        notificationFlags: {
+          [NotificationType.ArticleNewComment]: {
+            email: NotificationPreferenceStatus.Muted,
+          },
+        },
+      },
+      {
+        id: 'user8',
+        name: 'User 8',
+        email: '[email protected]',
+        notificationFlags: {
+          [NotificationType.ArticleNewComment]: {
+            email: NotificationPreferenceStatus.Subscribed,
+          },
+        },
+      },
+    ];
+
+    const notifId = await setupNotificationAndUsers(users);
+    const stream = await streamNotificationUsers(
+      con,
+      notifId,
+      NotificationChannel.Email,
+    );
+    const results = await streamToArray(stream);
+
+    expect(results).toHaveLength(1);
+    expect(results[0].userId).toBe('user8');
+  });
+
+  it('should not send notification to user with global inApp mute preference and email subscribed', async () => {
+    const users = [
+      {
+        id: 'user9',
+        name: 'User 9',
+        email: '[email protected]',
+        notificationFlags: {
+          [NotificationType.ArticleNewComment]: {
+            inApp: NotificationPreferenceStatus.Muted,
+            email: NotificationPreferenceStatus.Subscribed,
+          },
+        },
+      },
+    ];
+
+    const notifId = await setupNotificationAndUsers(users);
+
+    const inAppStream = await streamNotificationUsers(
+      con,
+      notifId,
+      NotificationChannel.InApp,
+    );
+    const inAppResults = await streamToArray(inAppStream);
+    expect(inAppResults).toHaveLength(0);
+
+    const emailStream = await streamNotificationUsers(
+      con,
+      notifId,
+      NotificationChannel.Email,
+    );
+    const emailResults = await streamToArray(emailStream);
+    expect(emailResults).toHaveLength(1);
+    expect(emailResults[0].userId).toBe('user9');
+  });
+
+  it('should exclude globally muted users even if they have entity-level subscriptions', async () => {
+    const users = [
+      {
+        id: 'user14',
+        name: 'User 14',
+        email: '[email protected]',
+        notificationFlags: {
+          [NotificationType.ArticleNewComment]: {
+            inApp: NotificationPreferenceStatus.Muted,
+          },
+        },
+      },
+    ];
+
+    await con.getRepository(User).save(users);
+    await saveFixtures(con, Source, sourcesFixture);
+    await saveFixtures(con, Post, postsFixture);
+
+    await con.getRepository(NotificationPreferencePost).save({
+      userId: 'user14',
+      postId: postsFixture[0].id,
+      referenceId: postsFixture[0].id,
+      notificationType: NotificationType.ArticleNewComment,
+      status: NotificationPreferenceStatus.Subscribed,
+      type: NotificationPreferenceType.Post,
+    });
+
+    const notif = await con.getRepository(NotificationV2).save({
+      ...notificationV2Fixture,
+      type: NotificationType.ArticleNewComment,
+    });
+
+    await con.getRepository(UserNotification).insert([
+      {
+        userId: 'user14',
+        notificationId: notif.id,
+        public: true,
+        createdAt: notificationV2Fixture.createdAt,
+      },
+    ]);
+
+    const stream = await streamNotificationUsers(
+      con,
+      notif.id,
+      NotificationChannel.InApp,
+    );
+    const results = await streamToArray(stream);
+
+    expect(results).toHaveLength(0);
+  });
+});