@parse/push-adapter 6.2.0 → 6.3.0

package/{lib → src}/GCM.js

@@ -1,38 +1,20 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-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 = GCM;
-
-var _parse = require('parse');
-
-var _parse2 = _interopRequireDefault(_parse);
-
-var _npmlog = require('npmlog');
-
-var _npmlog2 = _interopRequireDefault(_npmlog);
-
-var _nodeGcm = require('@parse/node-gcm');
-
-var _nodeGcm2 = _interopRequireDefault(_nodeGcm);
-
-var _PushAdapterUtils = require('./PushAdapterUtils');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-var LOG_PREFIX = 'parse-server-push-adapter GCM';
-var GCMTimeToLiveMax = 4 * 7 * 24 * 60 * 60; // GCM allows a max of 4 weeks
-var GCMRegistrationTokensMax = 1000;
-
-function GCM(args) {
-  if ((typeof args === 'undefined' ? 'undefined' : _typeof(args)) !== 'object' || !args.apiKey) {
-    throw new _parse2.default.Error(_parse2.default.Error.PUSH_MISCONFIGURED, 'GCM Configuration is invalid');
+import Parse from 'parse';
+import log from 'npmlog';
+import gcm from '@parse/node-gcm';
+import { randomString } from './PushAdapterUtils.js';
+
+const LOG_PREFIX = 'parse-server-push-adapter GCM';
+const GCMTimeToLiveMax = 4 * 7 * 24 * 60 * 60; // GCM allows a max of 4 weeks
+const GCMRegistrationTokensMax = 1000;
+
+export default function GCM(args) {
+  if (typeof args !== 'object' || !args.apiKey) {
+    throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,
+                          'GCM Configuration is invalid');
   }
-  this.sender = new _nodeGcm2.default.Sender(args.apiKey, args.requestOptions);
+  this.sender = new gcm.Sender(args.apiKey, args.requestOptions);
 }
 
 GCM.GCMRegistrationTokensMax = GCMRegistrationTokensMax;
@@ -43,30 +25,28 @@ GCM.GCMRegistrationTokensMax = GCMRegistrationTokensMax;
  * @param {Array} devices A array of devices
  * @returns {Object} A promise which is resolved after we get results from gcm
  */
-GCM.prototype.send = function (data, devices) {
-  var _this = this;
-
+GCM.prototype.send = function(data, devices) {
   if (!data || !devices || !Array.isArray(devices)) {
-    _npmlog2.default.warn(LOG_PREFIX, 'invalid push payload');
+    log.warn(LOG_PREFIX, 'invalid push payload');
     return;
   }
-  var pushId = (0, _PushAdapterUtils.randomString)(10);
+  let pushId = randomString(10);
   // Make a new array
-  devices = devices.slice(0);
-  var timestamp = Date.now();
+  devices=devices.slice(0);
+  let timestamp = Date.now();
   // For android, we can only have 1000 recepients per send, so we need to slice devices to
   // chunk if necessary
-  var slices = sliceDevices(devices, GCM.GCMRegistrationTokensMax);
+  let slices = sliceDevices(devices, GCM.GCMRegistrationTokensMax);
   if (slices.length > 1) {
-    _npmlog2.default.verbose(LOG_PREFIX, 'the number of devices exceeds ' + GCMRegistrationTokensMax);
+    log.verbose(LOG_PREFIX, `the number of devices exceeds ${GCMRegistrationTokensMax}`);
     // Make 1 send per slice
-    var _promises = slices.reduce(function (memo, slice) {
-      var promise = _this.send(data, slice, timestamp);
+    let promises = slices.reduce((memo, slice) => {
+      let promise = this.send(data, slice, timestamp);
       memo.push(promise);
       return memo;
-    }, []);
-    return Promise.all(_promises).then(function (results) {
-      var allResults = results.reduce(function (memo, result) {
+    }, [])
+    return Promise.all(promises).then((results) => {
+      let allResults = results.reduce((memo, result) => {
         return memo.concat(result);
       }, []);
       return Promise.resolve(allResults);
@@ -75,7 +55,7 @@ GCM.prototype.send = function (data, devices) {
   // get the devices back...
   devices = slices[0];
 
-  var expirationTime = void 0;
+  let expirationTime;
   // We handle the expiration_time convertion in push.js, so expiration_time is a valid date
   // in Unix epoch time in milliseconds here
   if (data['expiration_time']) {
@@ -83,28 +63,24 @@ GCM.prototype.send = function (data, devices) {
   }
   // Generate gcm payload
   // PushId is not a formal field of GCM, but Parse Android SDK uses this field to deduplicate push notifications
-  var gcmPayload = generateGCMPayload(data, pushId, timestamp, expirationTime);
+  let gcmPayload = generateGCMPayload(data, pushId, timestamp, expirationTime);
   // Make and send gcm request
-  var message = new _nodeGcm2.default.Message(gcmPayload);
+  let message = new gcm.Message(gcmPayload);
 
   // Build a device map
-  var devicesMap = devices.reduce(function (memo, device) {
+  let devicesMap = devices.reduce((memo, device) => {
     memo[device.deviceToken] = device;
     return memo;
   }, {});
 
-  var deviceTokens = Object.keys(devicesMap);
+  let deviceTokens = Object.keys(devicesMap);
 
-  var resolvers = [];
-  var promises = deviceTokens.map(function () {
-    return new Promise(function (resolve) {
-      return resolvers.push(resolve);
-    });
-  });
-  var registrationTokens = deviceTokens;
-  var length = registrationTokens.length;
-  _npmlog2.default.verbose(LOG_PREFIX, 'sending to ' + length + ' ' + (length > 1 ? 'devices' : 'device'));
-  this.sender.send(message, { registrationTokens: registrationTokens }, 5, function (error, response) {
+  const resolvers = [];
+  const promises = deviceTokens.map(() => new Promise(resolve => resolvers.push(resolve)));
+  let registrationTokens = deviceTokens;
+  let length = registrationTokens.length;
+  log.verbose(LOG_PREFIX, `sending to ${length} ${length > 1 ? 'devices' : 'device'}`);
+  this.sender.send(message, { registrationTokens: registrationTokens }, 5, (error, response) => {
     // example response:
     /*
     {  "multicast_id":7680139367771848000,
@@ -117,24 +93,20 @@ GCM.prototype.send = function (data, devices) {
         {"error":"InvalidRegistration"}] }
     */
     if (error) {
-      _npmlog2.default.error(LOG_PREFIX, 'send errored: %s', JSON.stringify(error, null, 4));
+      log.error(LOG_PREFIX, `send errored: %s`, JSON.stringify(error, null, 4));
     } else {
-      _npmlog2.default.verbose(LOG_PREFIX, 'GCM Response: %s', JSON.stringify(response, null, 4));
+      log.verbose(LOG_PREFIX, `GCM Response: %s`, JSON.stringify(response, null, 4));
     }
-
-    var _ref = response || {},
-        results = _ref.results,
-        multicast_id = _ref.multicast_id;
-
-    registrationTokens.forEach(function (token, index) {
-      var resolve = resolvers[index];
-      var result = results ? results[index] : undefined;
-      var device = devicesMap[token];
+    let { results, multicast_id } = response || {};
+    registrationTokens.forEach((token, index) => {
+      let resolve = resolvers[index];
+      let result = results ? results[index] : undefined;
+      let device = devicesMap[token];
       device.deviceType = 'android';
-      var resolution = {
-        device: device,
-        multicast_id: multicast_id,
-        response: error || result
+      let resolution = {
+        device,
+        multicast_id,
+        response: error || result,
       };
       if (!result || result.error) {
         resolution.transmitted = false;
@@ -145,7 +117,7 @@ GCM.prototype.send = function (data, devices) {
     });
   });
   return Promise.all(promises);
-};
+}
 
 /**
  * Generate the gcm payload from the data we get from api request.
@@ -156,24 +128,24 @@ GCM.prototype.send = function (data, devices) {
  * @returns {Object} A promise which is resolved after we get results from gcm
  */
 function generateGCMPayload(requestData, pushId, timeStamp, expirationTime) {
-  var payload = {
+  let payload = {
     priority: 'high'
   };
   payload.data = {
     data: requestData.data,
     push_id: pushId,
     time: new Date(timeStamp).toISOString()
-  };
-  var optionalKeys = ['contentAvailable', 'notification'];
-  optionalKeys.forEach(function (key) {
+  }
+  const optionalKeys = ['contentAvailable', 'notification'];
+  optionalKeys.forEach((key) => {
     if (requestData.hasOwnProperty(key)) {
       payload[key] = requestData[key];
     }
   });
 
   if (expirationTime) {
-    // The timeStamp and expiration is in milliseconds but gcm requires second
-    var timeToLive = Math.floor((expirationTime - timeStamp) / 1000);
+   // The timeStamp and expiration is in milliseconds but gcm requires second
+    let timeToLive = Math.floor((expirationTime - timeStamp) / 1000);
     if (timeToLive < 0) {
       timeToLive = 0;
     }
@@ -192,7 +164,7 @@ function generateGCMPayload(requestData, pushId, timeStamp, expirationTime) {
  * @returns {Array} An array which contaisn several arries of devices with fixed chunk size
  */
 function sliceDevices(devices, chunkSize) {
-  var chunkDevices = [];
+  let chunkDevices = [];
   while (devices.length > 0) {
     chunkDevices.push(devices.splice(0, chunkSize));
   }
@@ -204,4 +176,4 @@ GCM.generateGCMPayload = generateGCMPayload;
 /* istanbul ignore else */
 if (process.env.TESTING) {
   GCM.sliceDevices = sliceDevices;
-}
+}

package/src/ParsePushAdapter.js

@@ -0,0 +1,96 @@
+'use strict';
+import Parse from 'parse';
+import log from 'npmlog';
+import APNS from './APNS.js';
+import GCM from './GCM.js';
+import FCM from './FCM.js';
+import WEB from './WEB.js';
+import EXPO from './EXPO.js';
+import { classifyInstallations } from './PushAdapterUtils.js';
+
+const LOG_PREFIX = 'parse-server-push-adapter';
+
+export default class ParsePushAdapter {
+
+  supportsPushTracking = true;
+
+  constructor(pushConfig = {}) {
+    this.validPushTypes = ['ios', 'osx', 'tvos', 'android', 'fcm', 'web', 'expo'];
+    this.senderMap = {};
+    // used in PushController for Dashboard Features
+    this.feature = {
+      immediatePush: true
+    };
+    let pushTypes = Object.keys(pushConfig);
+
+    for (let pushType of pushTypes) {
+      // adapter may be passed as part of the parse-server initialization
+      if (this.validPushTypes.indexOf(pushType) < 0 && pushType != 'adapter') {
+        throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED,
+                             'Push to ' + pushType + ' is not supported');
+      }
+      switch (pushType) {
+        case 'ios':
+        case 'tvos':
+        case 'osx':
+          if (pushConfig[pushType].hasOwnProperty('firebaseServiceAccount')) {
+            this.senderMap[pushType] = new FCM(pushConfig[pushType], 'apple');
+          } else {
+            this.senderMap[pushType] = new APNS(pushConfig[pushType]);
+          }
+          break;
+        case 'web':
+          this.senderMap[pushType] = new WEB(pushConfig[pushType]);
+          break;
+        case 'expo':
+          this.senderMap[pushType] = new EXPO(pushConfig[pushType]);
+          break;
+        case 'android':
+        case 'fcm':
+          if (pushConfig[pushType].hasOwnProperty('firebaseServiceAccount')) {
+            this.senderMap[pushType] = new FCM(pushConfig[pushType], 'android');
+          } else {
+            this.senderMap[pushType] = new GCM(pushConfig[pushType]);
+          }
+          break;
+      }
+    }
+  }
+
+  getValidPushTypes() {
+    return this.validPushTypes;
+  }
+
+  static classifyInstallations(installations, validTypes) {
+    return classifyInstallations(installations, validTypes)
+  }
+
+  send(data, installations) {
+    let deviceMap = classifyInstallations(installations, this.validPushTypes);
+    let sendPromises = [];
+    for (let pushType in deviceMap) {
+      let sender = this.senderMap[pushType];
+      let devices = deviceMap[pushType];
+
+      if(Array.isArray(devices) && devices.length > 0) {
+        if (!sender) {
+          log.verbose(LOG_PREFIX, `Can not find sender for push type ${pushType}, ${data}`)
+          let results = devices.map((device) => {
+            return Promise.resolve({
+              device,
+              transmitted: false,
+              response: {'error': `Can not find sender for push type ${pushType}, ${data}`}
+            })
+          });
+          sendPromises.push(Promise.all(results));
+        } else {
+          sendPromises.push(sender.send(data, devices));
+        }
+      }
+    }
+    return Promise.all(sendPromises).then((promises) => {
+      // flatten all
+      return [].concat.apply([], promises);
+    })
+  }
+}

package/src/PushAdapterUtils.js

@@ -0,0 +1,45 @@
+import { randomBytes } from 'crypto';
+
+/**g
+   * Classify the device token of installations based on its device type.
+   * @param {Object} installations An array of installations
+   * @param {Array} validPushTypes An array of valid push types(string)
+   * @returns {Object} A map whose key is device type and value is an array of device
+   */
+export function classifyInstallations(installations, validPushTypes) {
+  // Init deviceTokenMap, create a empty array for each valid pushType
+  let deviceMap = {};
+  for (let validPushType of validPushTypes) {
+    deviceMap[validPushType] = [];
+  }
+  for (let installation of installations) {
+    // No deviceToken, ignore
+    if (!installation.deviceToken) {
+      continue;
+    }
+    let devices = deviceMap[installation.pushType] || deviceMap[installation.deviceType] || null;
+    if (Array.isArray(devices)) {
+      devices.push({
+        deviceToken: installation.deviceToken,
+        deviceType: installation.deviceType,
+        appIdentifier: installation.appIdentifier
+      });
+    }
+  }
+  return deviceMap;
+}
+
+export function randomString(size) {
+  if (size === 0) {
+    throw new Error('Zero-length randomString is useless.');
+  }
+  let chars = ('ABCDEFGHIJKLMNOPQRSTUVWXYZ' +
+               'abcdefghijklmnopqrstuvwxyz' +
+               '0123456789');
+  let objectId = '';
+  let bytes = randomBytes(size);
+  for (let i = 0; i < bytes.length; ++i) {
+    objectId += chars[bytes.readUInt8(i) % chars.length];
+  }
+  return objectId;
+}

package/src/WEB.js

@@ -0,0 +1,106 @@
+"use strict";
+
+import Parse from 'parse';
+import log from 'npmlog';
+import webpush from 'web-push';
+
+const LOG_PREFIX = 'parse-server-push-adapter WEB';
+
+export class WEB {
+  /**
+   * Create a new WEB push adapter.
+   * 
+   * @param {Object} args https://github.com/web-push-libs/web-push#api-reference
+   */
+  constructor(args) {
+    if (typeof args !== 'object' || !args.vapidDetails) {
+      throw new Parse.Error(Parse.Error.PUSH_MISCONFIGURED, 'WEB Push Configuration is invalid');
+    }
+    this.options = args;
+  }
+
+  /**
+   * Send web 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 WEB.sendNotifications(coreData, deviceTokens, this.options);
+    const { results, sent, failed } = response;
+    if (sent) {
+      log.verbose(LOG_PREFIX, `WEB Response: %d out of %d sent successfully`, sent, results.length);
+    }
+    if (failed) {
+      log.error(LOG_PREFIX, `send errored: %d out of %d failed with error %s`, failed, results.length, 'push subscription has unsubscribed or expired.');
+    }
+    deviceTokens.forEach((token, index) => {
+      const resolve = resolvers[index];
+      const { result, error } = results[index];
+      const device = devicesMap[token];
+      device.deviceType = 'web';
+      const resolution = {
+        device,
+        response: error || result,
+        transmitted: !error,
+      };
+      resolve(resolution);
+    });
+    return Promise.all(promises);
+  }
+
+  /**
+   * Send multiple web 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
+   */
+  static async sendNotifications(payload, deviceTokens, options) {
+    const promises = deviceTokens.map((deviceToken) => {
+      if (typeof deviceToken === 'string') {
+        deviceToken = JSON.parse(deviceToken);
+      }
+      if (typeof payload === 'object') {
+        payload = JSON.stringify(payload);
+      }
+      return webpush.sendNotification(deviceToken, payload, options);
+    });
+    const allResults = await Promise.allSettled(promises);
+    const response = {
+      sent: 0,
+      failed: 0,
+      results: [],
+    };
+    allResults.forEach((result) => {
+      if (result.status === 'fulfilled') {
+        response.sent += 1;
+        response.results.push({ result: result.value.statusCode });
+      } else {
+        response.failed += 1;
+        response.results.push({ error: result.reason.body });
+      }
+    });
+    return response;
+  }
+}
+
+export default WEB;

package/src/index.js

@@ -0,0 +1,20 @@
+"use strict";
+// ParsePushAdapter is the default implementation of
+// PushAdapter, it uses GCM for android push, APNS for ios push.
+// WEB for web push.
+import log from 'npmlog';
+
+/* istanbul ignore if */
+if (process.env.VERBOSE || process.env.VERBOSE_PARSE_SERVER_PUSH_ADAPTER) {
+  log.level = 'verbose';
+}
+
+import ParsePushAdapter from './ParsePushAdapter.js';
+import GCM from './GCM.js';
+import APNS from './APNS.js';
+import WEB from './WEB.js';
+import EXPO from './EXPO.js';
+import * as utils from './PushAdapterUtils.js';
+
+export default ParsePushAdapter;
+export { ParsePushAdapter, APNS, GCM, WEB, EXPO, utils };