@things-factory/notification 8.0.0-beta.9 → 8.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/notification",
-  "version": "8.0.0-beta.9",
+  "version": "8.0.2",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -28,17 +28,17 @@
   },
   "dependencies": {
     "@material/web": "^2.0.0",
-    "@operato/layout": "^8.0.0-beta",
-    "@things-factory/auth-base": "^8.0.0-beta.9",
-    "@things-factory/codelingua": "^8.0.0-beta.9",
-    "@things-factory/i18n-base": "^8.0.0-beta.9",
-    "@things-factory/organization": "^8.0.0-beta.9",
-    "@things-factory/setting-base": "^8.0.0-beta.9",
-    "@things-factory/shell": "^8.0.0-beta.9",
+    "@operato/layout": "^8.0.0",
+    "@things-factory/auth-base": "^8.0.2",
+    "@things-factory/codelingua": "^8.0.2",
+    "@things-factory/i18n-base": "^8.0.2",
+    "@things-factory/organization": "^8.0.2",
+    "@things-factory/setting-base": "^8.0.2",
+    "@things-factory/shell": "^8.0.2",
     "clipboard": "^2.0.6",
     "firebase": "^9.14.0",
     "firebase-admin": "^11.3.0",
     "google": "^2.1.0"
   },
-  "gitHead": "86b1dfa26292926a2d5447fdc23bfa5a9e983245"
+  "gitHead": "39d60f56e142561233ddf6d47b539c637971357c"
 }

package/server/controllers/fcm.ts

@@ -0,0 +1,214 @@
+import fetch from 'node-fetch'
+
+import { config, logger } from '@things-factory/env'
+
+import { initializeApp, cert } from 'firebase-admin/app'
+import { getMessaging } from 'firebase-admin/messaging'
+
+const notificationConfig = config.get('notification') || {}
+const { fcm, vapidKey } = notificationConfig
+const { serviceAccount, appConfig, serverKey } = fcm || {}
+const { publicKey } = vapidKey || {}
+
+var messaging
+
+if (serviceAccount) {
+  try {
+    const app = initializeApp({
+      credential: cert(serviceAccount)
+    })
+
+    messaging = getMessaging(app)
+  } catch (err) {
+    logger.error('incorrect notification configuration')
+    logger.error(err)
+  }
+}
+
+export function getConfig() {
+  return messaging
+    ? {
+        appConfig,
+        vapidPublicKey: publicKey
+      }
+    : {}
+}
+
+/**
+ * sendNotification
+ *
+ * @param receiver user.id who will receive notification
+ * @param message message object to be sent
+ */
+export async function sendNotification({ receivers, message }) {
+  if (!messaging) {
+    return
+  }
+
+  notify({
+    receivers,
+    ...message
+  })
+}
+
+export async function register(user, { subscription }) {
+  if (!messaging || !subscription || !user) {
+    return false
+  }
+
+  try {
+    var notification_key = await getDeviceGroup(user.id)
+
+    if (!notification_key) {
+      await postDeviceGroup({
+        operation: 'create',
+        notification_key_name: user.id,
+        registration_ids: [subscription]
+      })
+    } else {
+      await postDeviceGroup({
+        operation: 'add',
+        notification_key_name: user.id,
+        notification_key,
+        registration_ids: [subscription]
+      })
+    }
+
+    return true
+  } catch (err) {
+    return
+  }
+}
+
+export async function unregister(user, { subscription }) {
+  if (!messaging || !subscription || !user) {
+    return false
+  }
+
+  try {
+    var notification_key = await getDeviceGroup(user.id)
+
+    if (notification_key) {
+      await postDeviceGroup({
+        operation: 'remove',
+        notification_key_name: user.id,
+        notification_key,
+        registration_ids: [subscription]
+      })
+    }
+
+    return true
+  } catch (err) {
+    return
+  }
+}
+
+export async function notify({ receivers, privileges, tokens, topic, title, body, data, image, actions }) {
+  if (!messaging) {
+    return
+  }
+
+  // Caution: non-string attributes are not allowed in FCM payload validation
+  var notification = {
+    title: title || '',
+    body: body || '',
+    image: image || ''
+  }
+
+  if (tokens && tokens instanceof Array && tokens.length > 0) {
+    if (tokens.length > 1) {
+      const response = await messaging.sendMulticast({
+        notification,
+        data,
+        tokens
+      })
+
+      if (response.failureCount > 0) {
+        const failedTokens = []
+        response.responses.forEach((resp, idx) => {
+          if (!resp.success) {
+            failedTokens.push(tokens[idx])
+          }
+        })
+        logger.error('List of tokens that caused failures: ' + failedTokens)
+      }
+    } else {
+      const token = tokens[0]
+
+      try {
+        const response = await messaging.send({
+          notification,
+          data,
+          token
+        })
+        logger.log('Successfully sent message:', response)
+      } catch (err) {
+        logger.error('Error sending message:', err)
+      }
+    }
+  }
+
+  if (topic) {
+    try {
+      const response = await messaging.send({
+        notification,
+        data,
+        topic
+      })
+      logger.log('Successfully sent message:', response)
+    } catch (err) {
+      logger.error('Error sending message:', err)
+    }
+  }
+
+  if (receivers && receivers instanceof Array) {
+    for (let receiver of receivers) {
+      const notification_key = await getDeviceGroup(receiver)
+
+      if (notification_key) {
+        await messaging.sendToDeviceGroup(notification_key, {
+          notification,
+          data
+        })
+      }
+    }
+  }
+}
+
+async function postDeviceGroup(body) {
+  var response = await fetch('https://fcm.googleapis.com/fcm/notification', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `key=${serverKey}`,
+      project_id: appConfig.messagingSenderId
+    },
+    body: JSON.stringify(body)
+  })
+
+  if (response.ok) {
+    const { notification_key } = await response.json()
+    return notification_key
+  } else {
+    console.error('postDeviceGroup-notok', response.status, await response.text())
+  }
+}
+
+async function getDeviceGroup(notificationKeyName) {
+  const response = await fetch(
+    `https://fcm.googleapis.com/fcm/notification?notification_key_name=${notificationKeyName}`,
+    {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `key=${serverKey}`,
+        project_id: appConfig.messagingSenderId
+      }
+    }
+  )
+
+  if (response.ok) {
+    const { notification_key } = await response.json()
+    return notification_key
+  }
+}

package/server/controllers/index.ts

@@ -0,0 +1 @@
+export * from './fcm'

package/server/index.ts

@@ -0,0 +1,5 @@
+export * from './service'
+export * from './middlewares'
+export * from './controllers'
+
+import './routes'

package/server/middlewares/index.ts

@@ -0,0 +1,5 @@
+import { notificationMiddleware } from './notification-middleware'
+
+export function initMiddlewares(app) {
+  app.use(notificationMiddleware)
+}

package/server/middlewares/notification-middleware.ts

@@ -0,0 +1,73 @@
+import { pubsub } from '@things-factory/shell'
+import { logger } from '@things-factory/env'
+
+import { notify } from '../controllers/fcm'
+
+const debug = require('debug')('things-factory:notification:notification-middleware')
+
+function notifier(context) {
+  return async function ({
+    receivers,
+    privileges,
+    tokens,
+    topic,
+    type,
+    subject = 'info',
+    title,
+    body,
+    image,
+    url,
+    actions,
+    timestamp = Date.now(),
+    mode = 'background'
+  }) {
+    const { domain, user } = context.state
+
+    try {
+      if (mode === 'background') {
+        /* for send webpush notification message */
+
+        await notify({
+          receivers,
+          privileges,
+          tokens,
+          topic,
+          title,
+          body,
+          data: {
+            type,
+            url,
+            timestamp: String(timestamp)
+          },
+          image,
+          actions
+        })
+      } else {
+        /* for send publish notification to clients */
+        // TODO CONFIRM data format
+        await pubsub.publish('notification', {
+          notification: {
+            domain,
+            subject,
+            type,
+            title,
+            body,
+            image,
+            url,
+            timestamp
+          }
+        })
+      }
+    } catch (err) {
+      logger.error(err)
+    }
+  }
+}
+
+export async function notificationMiddleware(context: any, next: any) {
+  if (!context.state.notify) {
+    context.state.notify = notifier(context)
+  }
+
+  await next()
+}

package/server/routers/notification-router.ts

@@ -0,0 +1,67 @@
+import Router from 'koa-router'
+import { ILike } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { getRepository } from '@things-factory/shell'
+
+import { getConfig, register, unregister } from '../controllers/fcm'
+
+const debug = require('debug')('things-factory:notification:notification-router')
+
+export const notificationRouter = new Router({
+  prefix: '/notification'
+})
+
+notificationRouter.get('/config', async (context, next) => {
+  const config = getConfig()
+
+  context.type = 'application/json'
+  context.body = config
+})
+
+notificationRouter.post('/register', async (context, next) => {
+  const { user } = context.state
+  const { body } = context.request
+  context.body = await register(user, body)
+  context.status = 200
+})
+
+notificationRouter.post('/unregister', async (context, next) => {
+  const { user } = context.state
+  const { body } = context.request
+  context.body = await unregister(user, body)
+  context.status = 200
+})
+
+notificationRouter.post('/notify', async (context, next) => {
+  const { user, domain, notify } = context.state
+  const repository = getRepository(User)
+
+  var { receivers, ...options } = context.request.body
+
+  debug('post:/notify', receivers, receivers.split(','), options)
+
+  // TODO filter only users having current domain privilege
+  receivers = (
+    await Promise.all(
+      receivers
+        .split(',')
+        .map(email => email.trim())
+        .map(async email => {
+          var receiver: User = await repository.findOneBy({ email: ILike(email) })
+          return receiver && receiver.id
+        })
+    )
+  ).filter(receiver => !!receiver)
+
+  debug('post:/notify', receivers, user.id)
+
+  await notify({
+    receivers: receivers.length > 0 ? receivers : [user.id],
+    ...options
+  })
+
+  context.body = {
+    success: true
+  }
+})

package/server/routes.ts

@@ -0,0 +1,11 @@
+import { notificationRouter } from './routers/notification-router'
+
+process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRouter) => {})
+
+process.on('bootstrap-module-global-private-route' as any, (app, globalPrivateRouter) => {})
+
+process.on('bootstrap-module-domain-public-route' as any, (app, domainPublicRouter) => {})
+
+process.on('bootstrap-module-domain-private-route' as any, (app, domainPrivateRouter) => {
+  domainPrivateRouter.use('', notificationRouter.routes(), notificationRouter.allowedMethods())
+})

package/server/service/index.ts

@@ -0,0 +1,42 @@
+/* EXPORT ENTITY TYPES */
+export * from './notification-rule/notification-rule'
+export * from './notification/notification'
+
+/* IMPORT ENTITIES AND RESOLVERS */
+import {
+  entities as NotificationRuleEntities,
+  resolvers as NotificationRuleResolvers,
+  subscribers as NotificationRuleSubscribers
+} from './notification-rule'
+import {
+  entities as NotificationEntities,
+  typeDefs as NotificationTypeDefs,
+  resolvers as NotificationResolvers,
+  directives as NotificationDirectives
+} from './notification'
+
+export const entities = [
+  /* ENTITIES */
+  ...NotificationRuleEntities,
+  ...NotificationEntities
+]
+
+export const subscribers = [
+  /* SUBSCRIBERS */
+  ...NotificationRuleSubscribers
+]
+
+export const schema = {
+  typeDefs: {
+    ...NotificationTypeDefs
+  },
+  resolverClasses: [
+    /* RESOLVER CLASSES */
+    ...NotificationRuleResolvers,
+    ...NotificationResolvers,
+    ...NotificationResolvers
+  ],
+  directives: {
+    ...NotificationDirectives
+  }
+}

package/server/service/notification/directive-notification.ts

@@ -0,0 +1,71 @@
+import { defaultFieldResolver, GraphQLSchema } from 'graphql'
+import gql from 'graphql-tag'
+
+import { getDirective, MapperKind, mapSchema } from '@graphql-tools/utils'
+
+const debug = require('debug')('things-factory:notification:directive-notification')
+
+const DIRECTIVE = 'notification'
+
+export const notificationDirectiveTypeDefs = gql`
+  directive @notification(
+    receivers: String
+    topic: String
+    subject: String # info
+    title: String
+    body: String
+    image: String
+    url: String
+    # timestamp = String(Date.now())
+    mode: String # background
+  ) on FIELD_DEFINITION
+`
+export const directiveNotification = (schema: GraphQLSchema) =>
+  mapSchema(schema, {
+    [MapperKind.OBJECT_FIELD]: (fieldConfig, fieldName, typeName, schema) => {
+      const notificationDirective = getDirective(schema, fieldConfig, DIRECTIVE)?.[0]
+      if (notificationDirective) {
+        const { resolve = defaultFieldResolver, args } = fieldConfig
+
+        if (!args) {
+          throw new Error(`Unexpected Error. args should be defined in @notification directive for field ${fieldName}.`)
+        }
+
+        const {
+          receivers,
+          topic,
+          subject = 'info',
+          title,
+          body,
+          image,
+          url,
+          mode = 'background'
+        } = notificationDirective
+        const timestamp = Date.now()
+
+        fieldConfig.resolve = async function (source, args, context, info) {
+          const result = await resolve.call(this, source, args, context, info)
+
+          const { domain, user, notify } = context.state
+
+          if (!notify) {
+            debug('notify not set')
+          } else {
+            try {
+              await notify({
+                receivers: [user.id],
+                notificationDirective,
+                timestamp: new Date()
+              })
+            } catch (err) {
+              debug(err)
+            }
+          }
+
+          return result
+        }
+
+        return fieldConfig
+      }
+    }
+  })

package/server/service/notification/index.ts

@@ -0,0 +1,14 @@
+import { Notification } from './notification'
+import { NotificationQuery } from './notification-query'
+import { NotificationMutation } from './notification-mutation'
+import { NotificationSubscription } from './notification-subscription'
+import { notificationDirectiveTypeDefs, directiveNotification } from './directive-notification'
+
+export const typeDefs = {
+  notificationDirectiveTypeDefs
+}
+export const entities = [Notification]
+export const resolvers = [NotificationQuery, NotificationMutation, NotificationSubscription]
+export const directives = {
+  notification: directiveNotification
+}