feat: mobile in-app push notification

Author: fredshema

package-lock.json

@@ -69,6 +69,7 @@
     "date-fns": "^2.29.2",
     "dotenv": "^16.0.1",
     "ejs": "^3.1.8",
+    "expo-server-sdk": "^3.11.0",
     "express": "^4.18.1",
     "faker": "^6.6.6",
     "generate-password": "^1.7.0",

package.json

@@ -93,6 +93,10 @@ const userSchema = new Schema(
       type: Boolean,
       default: true,
     },
+    pushNotificationTokens: {
+      type: [String],
+      default: [],
+    },
   },
 
   {

src/models/user.ts

@@ -3,6 +3,7 @@ import { Octokit } from '@octokit/rest'
 import bcrypt from 'bcryptjs'
 import { GraphQLError } from 'graphql'
 // import * as jwt from 'jsonwebtoken'
+import Expo from 'expo-server-sdk'
 import { JwtPayload, verify } from 'jsonwebtoken'
 import mongoose, { Error } from 'mongoose'
 import generateRandomPassword from '../helpers/generateRandomPassword'
@@ -35,7 +36,6 @@ import organizationRejectedTemplate from '../utils/templates/organizationRejecte
 import registrationRequest from '../utils/templates/registrationRequestTemplate'
 import { EmailPattern } from '../utils/validation.utils'
 import { Context } from './../context'
-import { UserInputError } from 'apollo-server'
 const octokit = new Octokit({ auth: `${process.env.Org_Repo_Access}` })
 
 const SECRET = (process.env.SECRET as string) || 'mysq_unique_secret'
@@ -824,19 +824,28 @@ const resolvers: any = {
           })
 
           // Create the organization with 'pending' status
-const {name:nm,admin:adm,description:desc}=await Organization.create({
+          const {
+            name: nm,
+            admin: adm,
+            description: desc,
+          } = await Organization.create({
             admin: newAdmin._id,
             name,
             description,
             status: 'pending',
           })
-          const newOrgToken=genericToken({nm,adm,desc,email})
+          const newOrgToken = genericToken({ nm, adm, desc, email })
 
           const superAdmin = await User.find({ role: RoleOfUser.SUPER_ADMIN })
           // Get the email content
-          const link = process.env.FRONTEND_LINK ?? ""
-          const content = registrationRequest(email, name, description,link,newOrgToken)
-         
+          const link = process.env.FRONTEND_LINK ?? ''
+          const content = registrationRequest(
+            email,
+            name,
+            description,
+            link,
+            newOrgToken
+          )
 
           // Send registration request email to super admin
           await sendEmail(
@@ -1162,10 +1171,56 @@ const {name:nm,admin:adm,description:desc}=await Organization.create({
       }
       user.pushNotifications = !user.pushNotifications
       await user.save()
-      const updatedPushNotifications = user.pushNotifications
       return 'updated successful'
     },
 
+    async addPushNotificationToken(
+      _: any,
+      { pushToken }: { pushToken: string },
+      context: Context
+    ) {
+      if (!Expo.isExpoPushToken(pushToken)) {
+        throw new Error('Invalid push notification')
+      }
+
+      const user: any = await User.findOne({ _id: context.userId })
+      if (!user) {
+        throw new Error('User not found')
+      }
+
+      if (!user.pushNotificationTokens.includes(pushToken)) {
+        user.pushNotificationTokens.push(pushToken)
+        await user.save()
+        return 'Notification token added successfully'
+      }
+
+      return 'Notification token already added'
+    },
+
+    async removePushNotificationToken(
+      _: any,
+      { pushToken }: { pushToken: string },
+      context: Context
+    ) {
+      if (!Expo.isExpoPushToken(pushToken)) {
+        throw new Error('Invalid push notification')
+      }
+
+      const user: any = await User.findOne({ _id: context.userId })
+      if (!user) {
+        throw new Error('User not found')
+      }
+
+      const index = user.pushNotificationTokens.indexOf(pushToken)
+      if (index !== -1) {
+        user.pushNotificationTokens.splice(index, 1)
+        await user.save()
+        return 'Notification token removed successfully'
+      }
+
+      return 'Notification token not found'
+    },
+
     async resetUserPassword(
       _: any,
       { password, confirmPassword, token }: any,

src/resolvers/userResolver.ts

@@ -81,6 +81,7 @@ const Schema = gql`
     emailNotifications: Boolean!
     status: StatusType
     ratings: [Rating]
+    pushNotificationTokens: [String]
   }
   input RegisterInput {
     email: String!
@@ -561,6 +562,8 @@ const Schema = gql`
   type Mutation {
     updatePushNotifications(id: ID!): String
     updateEmailNotifications(id: ID!): String
+    addPushNotificationToken(pushToken: String): String
+    removePushNotificationToken(pushToken: String): String
   }
   type Query {
     getUpdatedEmailNotifications(id: ID!): Boolean!

src/schema/index.ts

@@ -1,8 +1,27 @@
+import {
+  Expo,
+  ExpoPushErrorReceipt,
+  ExpoPushMessage,
+  ExpoPushReceipt,
+  ExpoPushTicket,
+} from 'expo-server-sdk'
 import mongoose from 'mongoose'
 import { Notification } from '../../models/notification.model'
-import { pubSubPublish } from '../../resolvers/notification.resolvers'
-import { User } from '../../models/user'
 import { Profile } from '../../models/profile.model'
+import { User } from '../../models/user'
+import { pubSubPublish } from '../../resolvers/notification.resolvers'
+
+export type NotificationData = {
+  redirectURI?: string
+  criteria: {
+    type: 'PUBLIC' | 'PERSONAL' | 'TEAM' | 'ORGANIZATION'
+    value: string
+  }
+}
+
+let expo = new Expo({
+  accessToken: process.env.EXPO_ACCESS_TOKEN,
+})
 
 export const pushNotification = async (
   receiver: mongoose.Types.ObjectId,
@@ -29,8 +48,113 @@ export const pushNotification = async (
     id: notification.id,
     sender: { profile: profile?.toObject() },
   }
-  const userExists = await User.findOne({ _id: receiver })
-  if (userExists && userExists.pushNotifications) {
+  const receivingUser = await User.findOne({ _id: receiver })
+  if (receivingUser && receivingUser.pushNotifications) {
     pubSubPublish(sanitizedNotification)
+
+    if (receivingUser.pushNotificationTokens.length > 0) {
+      const notificationData: NotificationData = {
+        redirectURI: `/dashboard/trainee${
+          notification.type ? '/' + notification.type : ''
+        }`,
+        criteria: { type: 'PERSONAL', value: receivingUser.id },
+      }
+
+      console.log('Sending push notifications')
+
+      sendPushNotifications(
+        receivingUser.pushNotificationTokens,
+        `${capitalizeString(notification.type)} notification`,
+        notification.message,
+        notificationData
+      )
+    }
+  }
+}
+
+const capitalizeString = (str?: string) => {
+  str = str || 'New'
+  return str.charAt(0).toUpperCase() + str.slice(1)
+}
+
+const sendPushNotifications = async (
+  pushTokens: string[],
+  title: string,
+  body: string,
+  data: NotificationData
+) => {
+  // Create the messages that you want to send to clients
+  let messages: ExpoPushMessage[] = []
+  for (let pushToken of pushTokens) {
+    // Each push token looks like ExponentPushToken[xxxxxxxxxxxxxxxxxxxxxx]
+    // Check that all your push tokens appear to be valid Expo push tokens
+    if (!Expo.isExpoPushToken(pushToken)) {
+      console.error(`Push token ${pushToken} is not a valid Expo push token`)
+      continue
+    }
+
+    messages.push({
+      to: pushToken,
+      title: title,
+      body: body,
+      data: data,
+    })
   }
+
+  // The Expo push notification service accepts batches of notifications so
+  // that you don't need to send 1000 requests to send 1000 notifications.
+  let chunks = expo.chunkPushNotifications(messages)
+  let tickets: ExpoPushTicket[] = []
+  ;(async () => {
+    for (let chunk of chunks) {
+      try {
+        let ticketChunk = await expo.sendPushNotificationsAsync(chunk)
+        console.log(ticketChunk)
+        tickets.push(...ticketChunk)
+      } catch (error) {
+        console.error(error)
+      }
+    }
+  })()
+
+  let receiptIds = []
+  for (let ticket of tickets) {
+    // NOTE: Not all tickets have IDs; for example, tickets for notifications
+    // that could not be enqueued will have error information and no receipt ID.
+    if (ticket.status === 'ok') {
+      receiptIds.push(ticket.id)
+    }
+
+    if (ticket.status === 'error' && ticket.details) {
+      console.error(ticket.details.error)
+    }
+  }
+
+  let receiptIdChunks = expo.chunkPushNotificationReceiptIds(receiptIds)
+  ;(async () => {
+    // Like sending notifications, there are different strategies you could use
+    // to retrieve batches of receipts from the Expo service.
+    for (let chunk of receiptIdChunks) {
+      try {
+        let receipts = await expo.getPushNotificationReceiptsAsync(chunk)
+        console.log(receipts)
+
+        // The receipts specify whether Apple or Google successfully received the
+        // notification and information about an error, if one occurred.
+        for (let receiptId in receipts) {
+          let { status, details }: ExpoPushReceipt | ExpoPushErrorReceipt =
+            receipts[receiptId]
+          if (status === 'ok') {
+            continue
+          } else if (status === 'error') {
+            console.error(
+              `There was an error sending a notification: ${details}`
+            )
+          }
+        }
+      } catch (error) {
+        console.error(error)
+      }
+    }
+  })()
 }