@parse/push-adapter 6.2.0 → 6.4.0

package/src/EXPO.js

@@ -0,0 +1,107 @@
+"use strict";
+
+import Parse from 'parse';
+import log from 'npmlog';
+import { Expo } from 'expo-server-sdk';
+
+const LOG_PREFIX = 'parse-server-push-adapter EXPO';
+
+function expoResultToParseResponse(result) {
+    if (result.status === 'ok') {
+      return result;
+    } else  {
+      // ParseServer looks for "error", and supports ceratin codes like 'NotRegistered' for
+      // cleanup. Expo returns slighyly different ones so changing to match what is expected
+      // This can be taken out if the responsibility gets moved to the adapter itself.
+      const error = result.message === 'DeviceNotRegistered' ?
+        'NotRegistered' : result.message;
+      return {
+        error,
+        ...result
+      }
+    }
+}
+
+export class EXPO {
+  expo = undefined;
+  /**
+   * Create a new EXPO push adapter. Based on Web Adapter.
+   *
+   * @param {Object} args https://github.com/expo/expo-server-sdk-node / https://docs.expo.dev/push-notifications/sending-notifications/
+   */
+  constructor(args) {
+    if (typeof args !== 'object') {
+      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED, 'EXPO Push Configuration is invalid');
+    }
+
+    this.expo = new Expo(args)
+    this.options = args;
+  }
+
+  /**
+   * Send Expo push notification request.
+   *
+   * @param {Object} data The data we need to send, the format is the same with api request body
+   * @param {Array} devices An array of devices
+   * @returns {Object} A promise which is resolved immediately
+   */
+  async send(data, devices) {
+    const coreData = data && data.data;
+
+    if (!coreData || !devices || !Array.isArray(devices)) {
+      log.warn(LOG_PREFIX, 'invalid push payload');
+      return;
+    }
+    const devicesMap = devices.reduce((memo, device) => {
+      memo[device.deviceToken] = device;
+      return memo;
+    }, {});
+    const deviceTokens = Object.keys(devicesMap);
+
+    const resolvers = [];
+    const promises = deviceTokens.map(() => new Promise(resolve => resolvers.push(resolve)));
+    let length = deviceTokens.length;
+
+    log.verbose(LOG_PREFIX, `sending to ${length} ${length > 1 ? 'devices' : 'device'}`);
+
+    const response = await this.sendNotifications(coreData, deviceTokens);
+
+    log.verbose(LOG_PREFIX, `EXPO Response: %d sent`, response.length);
+
+    deviceTokens.forEach((token, index) => {
+      const resolve = resolvers[index];
+      const result = response[index];
+      const device = devicesMap[token];
+      const resolution = {
+        transmitted: result.status === 'ok',
+        device: {
+          ...device,
+          pushType: 'expo'
+        },
+        response: expoResultToParseResponse(result),
+      };
+      resolve(resolution);
+    });
+    return Promise.all(promises);
+  }
+
+  /**
+   * Send multiple Expo push notification request.
+   *
+   * @param {Object} payload The data we need to send, the format is the same with api request body
+   * @param {Array} deviceTokens An array of devicesTokens
+   * @param {Object} options The options for the request
+   * @returns {Object} A promise which is resolved immediately
+   */
+  async sendNotifications({alert, body, ...payload}, deviceTokens) {
+    const messages = deviceTokens.map((token) => ({
+      to: token,
+      body: body || alert,
+      ...payload
+    }));
+
+    return await this.expo.sendPushNotificationsAsync(messages);
+  }
+}
+
+export default EXPO;

package/{lib → src}/FCM.js

@@ -1,48 +1,37 @@
 'use strict';
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
-
-var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
-
-exports.default = FCM;
-
-var _parse = require('parse');
-
-var _parse2 = _interopRequireDefault(_parse);
-
-var _npmlog = require('npmlog');
-
-var _npmlog2 = _interopRequireDefault(_npmlog);
-
-var _app = require('firebase-admin/app');
-
-var _messaging = require('firebase-admin/messaging');
-
-var _PushAdapterUtils = require('./PushAdapterUtils');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-var LOG_PREFIX = 'parse-server-push-adapter FCM';
-var FCMRegistrationTokensMax = 500;
-var FCMTimeToLiveMax = 4 * 7 * 24 * 60 * 60; // FCM allows a max of 4 weeks
-var apnsIntegerDataKeys = ['badge', 'content-available', 'mutable-content', 'priority', 'expiration_time'];
-
-function FCM(args, pushType) {
-  if ((typeof args === 'undefined' ? 'undefined' : _typeof(args)) !== 'object' || !args.firebaseServiceAccount) {
-    throw new _parse2.default.Error(_parse2.default.Error.PUSH_MISCONFIGURED, 'FCM Configuration is invalid');
+import Parse from 'parse';
+import log from 'npmlog';
+import { initializeApp, cert, getApps, getApp } from 'firebase-admin/app';
+import { getMessaging } from 'firebase-admin/messaging';
+import { randomString } from './PushAdapterUtils.js';
+
+const LOG_PREFIX = 'parse-server-push-adapter FCM';
+const FCMRegistrationTokensMax = 500;
+const FCMTimeToLiveMax = 4 * 7 * 24 * 60 * 60; // FCM allows a max of 4 weeks
+const apnsIntegerDataKeys = [
+  'badge',
+  'content-available',
+  'mutable-content',
+  'priority',
+  'expiration_time',
+];
+
+export default function FCM(args, pushType) {
+  if (typeof args !== 'object' || !args.firebaseServiceAccount) {
+    throw new Parse.Error(
+      Parse.Error.PUSH_MISCONFIGURED,
+      'FCM Configuration is invalid',
+    );
   }
 
-  var app = void 0;
-  if ((0, _app.getApps)().length === 0) {
-    app = (0, _app.initializeApp)({ credential: (0, _app.cert)(args.firebaseServiceAccount) });
+  let app;
+  if (getApps().length === 0) {
+    app = initializeApp({ credential: cert(args.firebaseServiceAccount) });
   } else {
-    app = (0, _app.getApp)();
+    app = getApp();
   }
-  this.sender = (0, _messaging.getMessaging)(app);
+  this.sender = getMessaging(app);
   this.pushType = pushType; // Push type is only used to remain backwards compatible with APNS and GCM
 }
 
@@ -56,84 +45,111 @@ FCM.FCMRegistrationTokensMax = FCMRegistrationTokensMax;
  */
 
 FCM.prototype.send = function (data, devices) {
-  var _this = this;
-
   if (!data || !devices || !Array.isArray(devices)) {
-    _npmlog2.default.warn(LOG_PREFIX, 'invalid push payload');
+    log.warn(LOG_PREFIX, 'invalid push payload');
     return;
   }
 
   // We can only have 500 recepients per send, so we need to slice devices to
   // chunk if necessary
-  var slices = sliceDevices(devices, FCM.FCMRegistrationTokensMax);
+  const slices = sliceDevices(devices, FCM.FCMRegistrationTokensMax);
 
-  var sendToDeviceSlice = function sendToDeviceSlice(deviceSlice, pushType) {
-    var pushId = (0, _PushAdapterUtils.randomString)(10);
-    var timestamp = Date.now();
+  const sendToDeviceSlice = (deviceSlice, pushType) => {
+    const pushId = randomString(10);
+    const timestamp = Date.now();
 
     // Build a device map
-    var devicesMap = deviceSlice.reduce(function (memo, device) {
+    const devicesMap = deviceSlice.reduce((memo, device) => {
       memo[device.deviceToken] = device;
       return memo;
     }, {});
 
-    var deviceTokens = Object.keys(devicesMap);
-
-    var fcmPayload = generateFCMPayload(data, pushId, timestamp, deviceTokens, pushType);
-    var length = deviceTokens.length;
-    _npmlog2.default.info(LOG_PREFIX, 'sending push to ' + length + ' devices');
-
-    return _this.sender.sendEachForMulticast(fcmPayload.data).then(function (response) {
-      var promises = [];
-      var failedTokens = [];
-      var successfulTokens = [];
-
-      response.responses.forEach(function (resp, idx) {
-        if (resp.success) {
-          successfulTokens.push(deviceTokens[idx]);
-          promises.push(createSuccessfulPromise(deviceTokens[idx], devicesMap[deviceTokens[idx]].deviceType));
-        } else {
-          failedTokens.push(deviceTokens[idx]);
-          promises.push(createErrorPromise(deviceTokens[idx], devicesMap[deviceTokens[idx]].deviceType, resp.error));
-          _npmlog2.default.error(LOG_PREFIX, 'failed to send to ' + deviceTokens[idx] + ' with error: ' + JSON.stringify(resp.error));
+    const deviceTokens = Object.keys(devicesMap);
+
+    const fcmPayload = generateFCMPayload(
+      data,
+      pushId,
+      timestamp,
+      deviceTokens,
+      pushType,
+    );
+    const length = deviceTokens.length;
+    log.info(LOG_PREFIX, `sending push to ${length} devices`);
+
+    return this.sender
+      .sendEachForMulticast(fcmPayload.data)
+      .then((response) => {
+        const promises = [];
+        const failedTokens = [];
+        const successfulTokens = [];
+
+        response.responses.forEach((resp, idx) => {
+          if (resp.success) {
+            successfulTokens.push(deviceTokens[idx]);
+            promises.push(
+              createSuccessfulPromise(
+                deviceTokens[idx],
+                devicesMap[deviceTokens[idx]].deviceType,
+              ),
+            );
+          } else {
+            failedTokens.push(deviceTokens[idx]);
+            promises.push(
+              createErrorPromise(
+                deviceTokens[idx],
+                devicesMap[deviceTokens[idx]].deviceType,
+                resp.error,
+              ),
+            );
+            log.error(
+              LOG_PREFIX,
+              `failed to send to ${deviceTokens[idx]} with error: ${JSON.stringify(resp.error)}`,
+            );
+          }
+        });
+
+        if (failedTokens.length) {
+          log.error(
+            LOG_PREFIX,
+            `tokens with failed pushes: ${JSON.stringify(failedTokens)}`,
+          );
         }
-      });
 
-      if (failedTokens.length) {
-        _npmlog2.default.error(LOG_PREFIX, 'tokens with failed pushes: ' + JSON.stringify(failedTokens));
-      }
-
-      if (successfulTokens.length) {
-        _npmlog2.default.verbose(LOG_PREFIX, 'tokens with successful pushes: ' + JSON.stringify(successfulTokens));
-      }
+        if (successfulTokens.length) {
+          log.verbose(
+            LOG_PREFIX,
+            `tokens with successful pushes: ${JSON.stringify(successfulTokens)}`,
+          );
+        }
 
-      return Promise.all(promises);
-    });
+        return Promise.all(promises);
+      });
   };
 
-  var allPromises = Promise.all(slices.map(function (slice) {
-    return sendToDeviceSlice(slice, _this.pushType);
-  })).catch(function (err) {
-    _npmlog2.default.error(LOG_PREFIX, 'error sending push: ' + err);
+  const allPromises = Promise.all(
+    slices.map((slice) => sendToDeviceSlice(slice, this.pushType)),
+  ).catch((err) => {
+    log.error(LOG_PREFIX, `error sending push: ${err}`);
   });
 
   return allPromises;
 };
 
 function _APNSToFCMPayload(requestData) {
-  var coreData = requestData;
+  let coreData = requestData;
 
   if (requestData.hasOwnProperty('data')) {
     coreData = requestData.data;
   }
 
-  var expirationTime = requestData['expiration_time'] || coreData['expiration_time'];
-  var collapseId = requestData['collapse_id'] || coreData['collapse_id'];
-  var pushType = requestData['push_type'] || coreData['push_type'];
-  var priority = requestData['priority'] || coreData['priority'];
+  let expirationTime =
+    requestData['expiration_time'] || coreData['expiration_time'];
+  let collapseId = requestData['collapse_id'] || coreData['collapse_id'];
+  let pushType = requestData['push_type'] || coreData['push_type'];
+  let priority = requestData['priority'] || coreData['priority'];
 
-  var apnsPayload = { apns: { payload: { aps: {} } } };
-  var headers = {};
+  let apnsPayload = { apns: { payload: { aps: {} } } };
+  let headers = {};
 
   // Set to alert by default if not set explicitly
   headers['apns-push-type'] = 'alert';
@@ -156,13 +172,13 @@ function _APNSToFCMPayload(requestData) {
     apnsPayload.apns.headers = headers;
   }
 
-  for (var key in coreData) {
+  for (let key in coreData) {
     switch (key) {
       case 'aps':
         apnsPayload['apns']['payload']['aps'] = coreData.aps;
         break;
       case 'alert':
-        if (_typeof(coreData.alert) == 'object') {
+        if (typeof coreData.alert == 'object') {
           // When we receive a dictionary, use as is to remain
           // compatible with how the APNS.js + node-apn work
           apnsPayload['apns']['payload']['aps']['alert'] = coreData.alert;
@@ -188,16 +204,20 @@ function _APNSToFCMPayload(requestData) {
         apnsPayload['apns']['payload']['aps']['sound'] = coreData.sound;
         break;
       case 'content-available':
-        apnsPayload['apns']['payload']['aps']['content-available'] = coreData['content-available'];
+        apnsPayload['apns']['payload']['aps']['content-available'] =
+          coreData['content-available'];
         break;
       case 'mutable-content':
-        apnsPayload['apns']['payload']['aps']['mutable-content'] = coreData['mutable-content'];
+        apnsPayload['apns']['payload']['aps']['mutable-content'] =
+          coreData['mutable-content'];
         break;
       case 'targetContentIdentifier':
-        apnsPayload['apns']['payload']['aps']['target-content-id'] = coreData.targetContentIdentifier;
+        apnsPayload['apns']['payload']['aps']['target-content-id'] =
+          coreData.targetContentIdentifier;
         break;
       case 'interruptionLevel':
-        apnsPayload['apns']['payload']['aps']['interruption-level'] = coreData.interruptionLevel;
+        apnsPayload['apns']['payload']['aps']['interruption-level'] =
+          coreData.interruptionLevel;
         break;
       case 'category':
         apnsPayload['apns']['payload']['aps']['category'] = coreData.category;
@@ -205,8 +225,7 @@ function _APNSToFCMPayload(requestData) {
       case 'threadId':
         apnsPayload['apns']['payload']['aps']['thread-id'] = coreData.threadId;
         break;
-      case 'expiration_time':
-        // Exclude header-related fields as these are set above
+      case 'expiration_time': // Exclude header-related fields as these are set above
         break;
       case 'collapse_id':
         break;
@@ -224,10 +243,10 @@ function _APNSToFCMPayload(requestData) {
 
 function _GCMToFCMPayload(requestData, pushId, timeStamp) {
 
-  var androidPayload = {
+  const androidPayload = {
     android: {
-      priority: 'high'
-    }
+      priority: 'high',
+    },
   };
 
   if (requestData.hasOwnProperty('notification')) {
@@ -236,44 +255,22 @@ function _GCMToFCMPayload(requestData, pushId, timeStamp) {
 
   if (requestData.hasOwnProperty('data')) {
     // FCM gives an error on send if we have apns keys that should have integer values
-    var _iteratorNormalCompletion = true;
-    var _didIteratorError = false;
-    var _iteratorError = undefined;
-
-    try {
-      for (var _iterator = apnsIntegerDataKeys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-        var key = _step.value;
-
-        if (requestData.data.hasOwnProperty(key)) {
-          delete requestData.data[key];
-        }
-      }
-    } catch (err) {
-      _didIteratorError = true;
-      _iteratorError = err;
-    } finally {
-      try {
-        if (!_iteratorNormalCompletion && _iterator.return) {
-          _iterator.return();
-        }
-      } finally {
-        if (_didIteratorError) {
-          throw _iteratorError;
-        }
+    for (const key of apnsIntegerDataKeys) {
+      if (requestData.data.hasOwnProperty(key)) {
+        delete requestData.data[key]
       }
     }
-
     androidPayload.android.data = {
       push_id: pushId,
       time: new Date(timeStamp).toISOString(),
-      data: JSON.stringify(requestData.data)
-    };
+      data: JSON.stringify(requestData.data),
+    }
   }
 
   if (requestData['expiration_time']) {
-    var expirationTime = requestData['expiration_time'];
+    const expirationTime = requestData['expiration_time'];
     // Convert to seconds
-    var timeToLive = Math.floor((expirationTime - timeStamp) / 1000);
+    let timeToLive = Math.floor((expirationTime - timeStamp) / 1000);
     if (timeToLive < 0) {
       timeToLive = 0;
     }
@@ -307,7 +304,10 @@ function payloadConverter(requestData, pushType, pushId, timeStamp) {
   } else if (pushType === 'android') {
     return _GCMToFCMPayload(requestData, pushId, timeStamp);
   } else {
-    throw new _parse2.default.Error(_parse2.default.Error.PUSH_MISCONFIGURED, 'Unsupported push type, apple or android only.');
+    throw new Parse.Error(
+      Parse.Error.PUSH_MISCONFIGURED,
+      'Unsupported push type, apple or android only.',
+    );
   }
 }
 
@@ -320,17 +320,24 @@ function payloadConverter(requestData, pushType, pushId, timeStamp) {
  * @param {String} pushType Either apple or android
  * @returns {Object} A payload for FCM
  */
-function generateFCMPayload(requestData, pushId, timeStamp, deviceTokens, pushType) {
+function generateFCMPayload(
+  requestData,
+  pushId,
+  timeStamp,
+  deviceTokens,
+  pushType,
+) {
   delete requestData['where'];
 
-  var payloadToUse = {
+  const payloadToUse = {
     data: {}
   };
 
-  var fcmPayload = payloadConverter(requestData, pushType, pushId, timeStamp);
-  payloadToUse.data = _extends({}, fcmPayload, {
-    tokens: deviceTokens
-  });
+  const fcmPayload = payloadConverter(requestData, pushType, pushId, timeStamp);
+  payloadToUse.data = {
+    ...fcmPayload,
+    tokens: deviceTokens,
+  };
 
   return payloadToUse;
 }
@@ -342,7 +349,7 @@ function generateFCMPayload(requestData, pushId, timeStamp, deviceTokens, pushTy
  * @returns {Array} An array which contains several arrays of devices with fixed chunk size
  */
 function sliceDevices(devices, chunkSize) {
-  var chunkDevices = [];
+  const chunkDevices = [];
   while (devices.length > 0) {
     chunkDevices.push(devices.splice(0, chunkSize));
   }
@@ -361,9 +368,9 @@ function createErrorPromise(token, deviceType, errorMessage) {
     transmitted: false,
     device: {
       deviceToken: token,
-      deviceType: deviceType
+      deviceType: deviceType,
     },
-    response: { error: errorMessage }
+    response: { error: errorMessage },
   });
 }
 
@@ -378,8 +385,8 @@ function createSuccessfulPromise(token, deviceType) {
     transmitted: true,
     device: {
       deviceToken: token,
-      deviceType: deviceType
-    }
+      deviceType: deviceType,
+    },
   });
 }
 
@@ -388,4 +395,4 @@ FCM.generateFCMPayload = generateFCMPayload;
 /* istanbul ignore else */
 if (process.env.TESTING) {
   FCM.sliceDevices = sliceDevices;
-}
+}