@beiguancyc/parse-server 9.9.0-ruixiang.1

package/lib/StatusHandler.js

@@ -0,0 +1,329 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.flatten = flatten;
+exports.jobStatusHandler = jobStatusHandler;
+exports.pushStatusHandler = pushStatusHandler;
+var _cryptoUtils = require("./cryptoUtils");
+var _Utils = _interopRequireDefault(require("./Utils"));
+var _KeyPromiseQueue = require("./KeyPromiseQueue");
+var _logger = require("./logger");
+var _rest = _interopRequireDefault(require("./rest"));
+var _Auth = _interopRequireDefault(require("./Auth"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const PUSH_STATUS_COLLECTION = '_PushStatus';
+const JOB_STATUS_COLLECTION = '_JobStatus';
+const pushPromiseQueue = new _KeyPromiseQueue.KeyPromiseQueue();
+const jobPromiseQueue = new _KeyPromiseQueue.KeyPromiseQueue();
+const incrementOp = function (object = {}, key, amount = 1) {
+  if (!object[key]) {
+    object[key] = {
+      __op: 'Increment',
+      amount: amount
+    };
+  } else {
+    object[key].amount += amount;
+  }
+  return object[key];
+};
+function flatten(array) {
+  var flattened = [];
+  for (var i = 0; i < array.length; i++) {
+    if (Array.isArray(array[i])) {
+      flattened = flattened.concat(flatten(array[i]));
+    } else {
+      flattened.push(array[i]);
+    }
+  }
+  return flattened;
+}
+function statusHandler(className, database) {
+  function create(object) {
+    return database.create(className, object).then(() => {
+      return Promise.resolve(object);
+    });
+  }
+  function update(where, object) {
+    return jobPromiseQueue.enqueue(where.objectId, () => database.update(className, where, object));
+  }
+  return Object.freeze({
+    create,
+    update
+  });
+}
+function restStatusHandler(className, config) {
+  const auth = _Auth.default.master(config);
+  function create(object) {
+    return _rest.default.create(config, auth, className, object).then(({
+      response
+    }) => {
+      return {
+        ...object,
+        ...response
+      };
+    });
+  }
+  function update(where, object) {
+    return pushPromiseQueue.enqueue(where.objectId, () => _rest.default.update(config, auth, className, {
+      objectId: where.objectId
+    }, object).then(({
+      response
+    }) => {
+      return {
+        ...object,
+        ...response
+      };
+    }));
+  }
+  return Object.freeze({
+    create,
+    update
+  });
+}
+function jobStatusHandler(config) {
+  let jobStatus;
+  const objectId = (0, _cryptoUtils.newObjectId)(config.objectIdSize);
+  const database = config.database;
+  const handler = statusHandler(JOB_STATUS_COLLECTION, database);
+  const setRunning = function (jobName) {
+    const now = new Date();
+    jobStatus = {
+      objectId,
+      jobName,
+      status: 'running',
+      source: 'api',
+      createdAt: now,
+      // lockdown!
+      ACL: {}
+    };
+    return handler.create(jobStatus);
+  };
+  const setMessage = function (message) {
+    if (!message || typeof message !== 'string') {
+      return Promise.resolve();
+    }
+    return handler.update({
+      objectId
+    }, {
+      message
+    });
+  };
+  const setSucceeded = function (message) {
+    return setFinalStatus('succeeded', message);
+  };
+  const setFailed = function (message) {
+    return setFinalStatus('failed', message);
+  };
+  const setFinalStatus = function (status, message = undefined) {
+    const finishedAt = new Date();
+    const update = {
+      status,
+      finishedAt
+    };
+    if (message && typeof message === 'string') {
+      update.message = message;
+    }
+    if (_Utils.default.isNativeError(message) && typeof message.message === 'string') {
+      update.message = message.message;
+    }
+    return handler.update({
+      objectId
+    }, update);
+  };
+  return Object.freeze({
+    setRunning,
+    setSucceeded,
+    setMessage,
+    setFailed
+  });
+}
+function pushStatusHandler(config, existingObjectId) {
+  let pushStatus;
+  const database = config.database;
+  const handler = restStatusHandler(PUSH_STATUS_COLLECTION, config);
+  let objectId = existingObjectId;
+  const setInitial = function (body = {}, where, options = {
+    source: 'rest'
+  }) {
+    const now = new Date();
+    let pushTime = now.toISOString();
+    let status = 'pending';
+    if (Object.prototype.hasOwnProperty.call(body, 'push_time')) {
+      if (config.hasPushScheduledSupport) {
+        pushTime = body.push_time;
+        status = 'scheduled';
+      } else {
+        _logger.logger.warn('Trying to schedule a push while server is not configured.');
+        _logger.logger.warn('Push will be sent immediately');
+      }
+    }
+    const data = body.data || {};
+    const payloadString = JSON.stringify(data);
+    let pushHash;
+    if (typeof data.alert === 'string') {
+      pushHash = (0, _cryptoUtils.md5Hash)(data.alert);
+    } else if (typeof data.alert === 'object') {
+      pushHash = (0, _cryptoUtils.md5Hash)(JSON.stringify(data.alert));
+    } else {
+      pushHash = 'd41d8cd98f00b204e9800998ecf8427e';
+    }
+    const object = {
+      pushTime,
+      query: JSON.stringify(where),
+      payload: payloadString,
+      source: options.source,
+      title: options.title,
+      expiry: body.expiration_time,
+      expiration_interval: body.expiration_interval,
+      status: status,
+      numSent: 0,
+      pushHash,
+      // lockdown!
+      ACL: {}
+    };
+    return handler.create(object).then(result => {
+      objectId = result.objectId;
+      pushStatus = {
+        objectId
+      };
+      return Promise.resolve(pushStatus);
+    });
+  };
+  const setRunning = function (batches) {
+    _logger.logger.verbose(`_PushStatus ${objectId}: sending push to installations with %d batches`, batches);
+    return handler.update({
+      status: 'pending',
+      objectId: objectId
+    }, {
+      status: 'running',
+      count: batches
+    });
+  };
+  const trackSent = function (results, UTCOffset, cleanupInstallations = process.env.PARSE_SERVER_CLEANUP_INVALID_INSTALLATIONS) {
+    const update = {
+      numSent: 0,
+      numFailed: 0
+    };
+    const devicesToRemove = [];
+    if (Array.isArray(results)) {
+      results = flatten(results);
+      results.reduce((memo, result) => {
+        // Cannot handle that
+        if (!result || !result.device || !result.device.deviceType) {
+          return memo;
+        }
+        const deviceType = result.device.deviceType;
+        const key = result.transmitted ? `sentPerType.${deviceType}` : `failedPerType.${deviceType}`;
+        memo[key] = incrementOp(memo, key);
+        if (typeof UTCOffset !== 'undefined') {
+          const offsetKey = result.transmitted ? `sentPerUTCOffset.${UTCOffset}` : `failedPerUTCOffset.${UTCOffset}`;
+          memo[offsetKey] = incrementOp(memo, offsetKey);
+        }
+        if (result.transmitted) {
+          memo.numSent++;
+        } else {
+          if (result && result.response && result.response.error && result.device && result.device.deviceToken) {
+            const token = result.device.deviceToken;
+            const error = result.response.error;
+            // GCM / FCM HTTP v1 API errors; see:
+            // https://firebase.google.com/docs/reference/fcm/rest/v1/ErrorCode
+            if (error === 'NotRegistered' || error === 'InvalidRegistration') {
+              devicesToRemove.push(token);
+            }
+            // FCM API v2 errors; see:
+            // https://firebase.google.com/docs/cloud-messaging/manage-tokens
+            // https://github.com/firebase/functions-samples/blob/703c0359eacf07a551751d1319d34f912a2cd828/Node/fcm-notifications/functions/index.js#L89-L93C16
+            if (error?.code === 'messaging/registration-token-not-registered' || error?.code === 'messaging/invalid-registration-token' || error?.code === 'messaging/invalid-argument' && error?.message === 'The registration token is not a valid FCM registration token') {
+              devicesToRemove.push(token);
+            }
+            // APNS errors; see:
+            // https://developer.apple.com/documentation/usernotifications/handling-notification-responses-from-apns
+            if (error === 'Unregistered' || error === 'BadDeviceToken') {
+              devicesToRemove.push(token);
+            }
+          }
+          memo.numFailed++;
+        }
+        return memo;
+      }, update);
+    }
+    _logger.logger.verbose(`_PushStatus ${objectId}: sent push! %d success, %d failures`, update.numSent, update.numFailed);
+    _logger.logger.verbose(`_PushStatus ${objectId}: needs cleanup`, {
+      devicesToRemove
+    });
+    ['numSent', 'numFailed'].forEach(key => {
+      if (update[key] > 0) {
+        update[key] = {
+          __op: 'Increment',
+          amount: update[key]
+        };
+      } else {
+        delete update[key];
+      }
+    });
+    if (devicesToRemove.length > 0 && cleanupInstallations) {
+      _logger.logger.info(`Removing device tokens on ${devicesToRemove.length} _Installations`);
+      database.update('_Installation', {
+        deviceToken: {
+          $in: devicesToRemove
+        }
+      }, {
+        deviceToken: {
+          __op: 'Delete'
+        }
+      }, {
+        acl: undefined,
+        many: true
+      });
+    }
+    incrementOp(update, 'count', -1);
+    update.status = 'running';
+    return handler.update({
+      objectId
+    }, update).then(res => {
+      if (res && res.count === 0) {
+        return this.complete();
+      }
+    });
+  };
+  const complete = function () {
+    return handler.update({
+      objectId
+    }, {
+      status: 'succeeded',
+      count: {
+        __op: 'Delete'
+      }
+    });
+  };
+  const fail = function (err) {
+    if (typeof err === 'string') {
+      err = {
+        message: err
+      };
+    }
+    const update = {
+      errorMessage: err,
+      status: 'failed'
+    };
+    return handler.update({
+      objectId
+    }, update);
+  };
+  const rval = {
+    setInitial,
+    setRunning,
+    trackSent,
+    complete,
+    fail
+  };
+
+  // define objectId to be dynamic
+  Object.defineProperty(rval, 'objectId', {
+    get: () => objectId
+  });
+  return Object.freeze(rval);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_cryptoUtils","require","_Utils","_interopRequireDefault","_KeyPromiseQueue","_logger","_rest","_Auth","e","__esModule","default","PUSH_STATUS_COLLECTION","JOB_STATUS_COLLECTION","pushPromiseQueue","KeyPromiseQueue","jobPromiseQueue","incrementOp","object","key","amount","__op","flatten","array","flattened","i","length","Array","isArray","concat","push","statusHandler","className","database","create","then","Promise","resolve","update","where","enqueue","objectId","Object","freeze","restStatusHandler","config","auth","Auth","master","rest","response","jobStatusHandler","jobStatus","newObjectId","objectIdSize","handler","setRunning","jobName","now","Date","status","source","createdAt","ACL","setMessage","message","setSucceeded","setFinalStatus","setFailed","undefined","finishedAt","Utils","isNativeError","pushStatusHandler","existingObjectId","pushStatus","setInitial","body","options","pushTime","toISOString","prototype","hasOwnProperty","call","hasPushScheduledSupport","push_time","logger","warn","data","payloadString","JSON","stringify","pushHash","alert","md5Hash","query","payload","title","expiry","expiration_time","expiration_interval","numSent","result","batches","verbose","count","trackSent","results","UTCOffset","cleanupInstallations","process","env","PARSE_SERVER_CLEANUP_INVALID_INSTALLATIONS","numFailed","devicesToRemove","reduce","memo","device","deviceType","transmitted","offsetKey","error","deviceToken","token","code","forEach","info","$in","acl","many","res","complete","fail","err","errorMessage","rval","defineProperty","get"],"sources":["../src/StatusHandler.js"],"sourcesContent":["import { md5Hash, newObjectId } from './cryptoUtils';\nimport Utils from './Utils';\nimport { KeyPromiseQueue } from './KeyPromiseQueue';\nimport { logger } from './logger';\nimport rest from './rest';\nimport Auth from './Auth';\n\nconst PUSH_STATUS_COLLECTION = '_PushStatus';\nconst JOB_STATUS_COLLECTION = '_JobStatus';\n\nconst pushPromiseQueue = new KeyPromiseQueue();\nconst jobPromiseQueue = new KeyPromiseQueue();\n\nconst incrementOp = function (object = {}, key, amount = 1) {\n  if (!object[key]) {\n    object[key] = { __op: 'Increment', amount: amount };\n  } else {\n    object[key].amount += amount;\n  }\n  return object[key];\n};\n\nexport function flatten(array) {\n  var flattened = [];\n  for (var i = 0; i < array.length; i++) {\n    if (Array.isArray(array[i])) {\n      flattened = flattened.concat(flatten(array[i]));\n    } else {\n      flattened.push(array[i]);\n    }\n  }\n  return flattened;\n}\n\nfunction statusHandler(className, database) {\n  function create(object) {\n    return database.create(className, object).then(() => {\n      return Promise.resolve(object);\n    });\n  }\n\n  function update(where, object) {\n    return jobPromiseQueue.enqueue(where.objectId, () => database.update(className, where, object));\n  }\n\n  return Object.freeze({\n    create,\n    update,\n  });\n}\n\nfunction restStatusHandler(className, config) {\n  const auth = Auth.master(config);\n  function create(object) {\n    return rest.create(config, auth, className, object).then(({ response }) => {\n      return { ...object, ...response };\n    });\n  }\n\n  function update(where, object) {\n    return pushPromiseQueue.enqueue(where.objectId, () =>\n      rest\n        .update(config, auth, className, { objectId: where.objectId }, object)\n        .then(({ response }) => {\n          return { ...object, ...response };\n        })\n    );\n  }\n\n  return Object.freeze({\n    create,\n    update,\n  });\n}\n\nexport function jobStatusHandler(config) {\n  let jobStatus;\n  const objectId = newObjectId(config.objectIdSize);\n  const database = config.database;\n  const handler = statusHandler(JOB_STATUS_COLLECTION, database);\n  const setRunning = function (jobName) {\n    const now = new Date();\n    jobStatus = {\n      objectId,\n      jobName,\n      status: 'running',\n      source: 'api',\n      createdAt: now,\n      // lockdown!\n      ACL: {},\n    };\n\n    return handler.create(jobStatus);\n  };\n\n  const setMessage = function (message) {\n    if (!message || typeof message !== 'string') {\n      return Promise.resolve();\n    }\n    return handler.update({ objectId }, { message });\n  };\n\n  const setSucceeded = function (message) {\n    return setFinalStatus('succeeded', message);\n  };\n\n  const setFailed = function (message) {\n    return setFinalStatus('failed', message);\n  };\n\n  const setFinalStatus = function (status, message = undefined) {\n    const finishedAt = new Date();\n    const update = { status, finishedAt };\n    if (message && typeof message === 'string') {\n      update.message = message;\n    }\n    if (Utils.isNativeError(message) && typeof message.message === 'string') {\n      update.message = message.message;\n    }\n    return handler.update({ objectId }, update);\n  };\n\n  return Object.freeze({\n    setRunning,\n    setSucceeded,\n    setMessage,\n    setFailed,\n  });\n}\n\nexport function pushStatusHandler(config, existingObjectId) {\n  let pushStatus;\n  const database = config.database;\n  const handler = restStatusHandler(PUSH_STATUS_COLLECTION, config);\n  let objectId = existingObjectId;\n  const setInitial = function (body = {}, where, options = { source: 'rest' }) {\n    const now = new Date();\n    let pushTime = now.toISOString();\n    let status = 'pending';\n    if (Object.prototype.hasOwnProperty.call(body, 'push_time')) {\n      if (config.hasPushScheduledSupport) {\n        pushTime = body.push_time;\n        status = 'scheduled';\n      } else {\n        logger.warn('Trying to schedule a push while server is not configured.');\n        logger.warn('Push will be sent immediately');\n      }\n    }\n\n    const data = body.data || {};\n    const payloadString = JSON.stringify(data);\n    let pushHash;\n    if (typeof data.alert === 'string') {\n      pushHash = md5Hash(data.alert);\n    } else if (typeof data.alert === 'object') {\n      pushHash = md5Hash(JSON.stringify(data.alert));\n    } else {\n      pushHash = 'd41d8cd98f00b204e9800998ecf8427e';\n    }\n    const object = {\n      pushTime,\n      query: JSON.stringify(where),\n      payload: payloadString,\n      source: options.source,\n      title: options.title,\n      expiry: body.expiration_time,\n      expiration_interval: body.expiration_interval,\n      status: status,\n      numSent: 0,\n      pushHash,\n      // lockdown!\n      ACL: {},\n    };\n    return handler.create(object).then(result => {\n      objectId = result.objectId;\n      pushStatus = {\n        objectId,\n      };\n      return Promise.resolve(pushStatus);\n    });\n  };\n\n  const setRunning = function (batches) {\n    logger.verbose(\n      `_PushStatus ${objectId}: sending push to installations with %d batches`,\n      batches\n    );\n    return handler.update(\n      {\n        status: 'pending',\n        objectId: objectId,\n      },\n      {\n        status: 'running',\n        count: batches,\n      }\n    );\n  };\n\n  const trackSent = function (\n    results,\n    UTCOffset,\n    cleanupInstallations = process.env.PARSE_SERVER_CLEANUP_INVALID_INSTALLATIONS\n  ) {\n    const update = {\n      numSent: 0,\n      numFailed: 0,\n    };\n    const devicesToRemove = [];\n    if (Array.isArray(results)) {\n      results = flatten(results);\n      results.reduce((memo, result) => {\n        // Cannot handle that\n        if (!result || !result.device || !result.device.deviceType) {\n          return memo;\n        }\n        const deviceType = result.device.deviceType;\n        const key = result.transmitted\n          ? `sentPerType.${deviceType}`\n          : `failedPerType.${deviceType}`;\n        memo[key] = incrementOp(memo, key);\n        if (typeof UTCOffset !== 'undefined') {\n          const offsetKey = result.transmitted\n            ? `sentPerUTCOffset.${UTCOffset}`\n            : `failedPerUTCOffset.${UTCOffset}`;\n          memo[offsetKey] = incrementOp(memo, offsetKey);\n        }\n        if (result.transmitted) {\n          memo.numSent++;\n        } else {\n          if (\n            result &&\n            result.response &&\n            result.response.error &&\n            result.device &&\n            result.device.deviceToken\n          ) {\n            const token = result.device.deviceToken;\n            const error = result.response.error;\n            // GCM / FCM HTTP v1 API errors; see:\n            // https://firebase.google.com/docs/reference/fcm/rest/v1/ErrorCode\n            if (error === 'NotRegistered' || error === 'InvalidRegistration') {\n              devicesToRemove.push(token);\n            }\n            // FCM API v2 errors; see:\n            // https://firebase.google.com/docs/cloud-messaging/manage-tokens\n            // https://github.com/firebase/functions-samples/blob/703c0359eacf07a551751d1319d34f912a2cd828/Node/fcm-notifications/functions/index.js#L89-L93C16\n            if (\n              error?.code === 'messaging/registration-token-not-registered' ||\n              error?.code === 'messaging/invalid-registration-token' ||\n              (error?.code === 'messaging/invalid-argument' && error?.message === 'The registration token is not a valid FCM registration token')\n            ) {\n              devicesToRemove.push(token);\n            }\n            // APNS errors; see:\n            // https://developer.apple.com/documentation/usernotifications/handling-notification-responses-from-apns\n            if (error === 'Unregistered' || error === 'BadDeviceToken') {\n              devicesToRemove.push(token);\n            }\n          }\n          memo.numFailed++;\n        }\n        return memo;\n      }, update);\n    }\n\n    logger.verbose(\n      `_PushStatus ${objectId}: sent push! %d success, %d failures`,\n      update.numSent,\n      update.numFailed\n    );\n    logger.verbose(`_PushStatus ${objectId}: needs cleanup`, {\n      devicesToRemove,\n    });\n    ['numSent', 'numFailed'].forEach(key => {\n      if (update[key] > 0) {\n        update[key] = {\n          __op: 'Increment',\n          amount: update[key],\n        };\n      } else {\n        delete update[key];\n      }\n    });\n\n    if (devicesToRemove.length > 0 && cleanupInstallations) {\n      logger.info(`Removing device tokens on ${devicesToRemove.length} _Installations`);\n      database.update(\n        '_Installation',\n        { deviceToken: { $in: devicesToRemove } },\n        { deviceToken: { __op: 'Delete' } },\n        {\n          acl: undefined,\n          many: true,\n        }\n      );\n    }\n    incrementOp(update, 'count', -1);\n    update.status = 'running';\n\n    return handler.update({ objectId }, update).then(res => {\n      if (res && res.count === 0) {\n        return this.complete();\n      }\n    });\n  };\n\n  const complete = function () {\n    return handler.update(\n      { objectId },\n      {\n        status: 'succeeded',\n        count: { __op: 'Delete' },\n      }\n    );\n  };\n\n  const fail = function (err) {\n    if (typeof err === 'string') {\n      err = { message: err };\n    }\n    const update = {\n      errorMessage: err,\n      status: 'failed',\n    };\n    return handler.update({ objectId }, update);\n  };\n\n  const rval = {\n    setInitial,\n    setRunning,\n    trackSent,\n    complete,\n    fail,\n  };\n\n  // define objectId to be dynamic\n  Object.defineProperty(rval, 'objectId', {\n    get: () => objectId,\n  });\n\n  return Object.freeze(rval);\n}\n"],"mappings":"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","ignoreList":[]}

package/lib/TestUtils.js

@@ -0,0 +1,87 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Connections = void 0;
+exports.destroyAllDataPermanently = destroyAllDataPermanently;
+exports.getConnectionsCount = getConnectionsCount;
+exports.resolvingPromise = resolvingPromise;
+exports.sleep = sleep;
+var _cache = _interopRequireDefault(require("./cache"));
+var _SchemaCache = _interopRequireDefault(require("./Adapters/Cache/SchemaCache"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Destroys all data in the database
+ * @param {boolean} fast set to true if it's ok to just drop objects and not indexes.
+ */
+function destroyAllDataPermanently(fast) {
+  if (!process.env.TESTING) {
+    throw 'Only supported in test environment';
+  }
+  return Promise.all(Object.keys(_cache.default.cache).map(appId => {
+    const app = _cache.default.get(appId);
+    const deletePromises = [];
+    if (app.cacheAdapter && app.cacheAdapter.clear) {
+      deletePromises.push(app.cacheAdapter.clear());
+    }
+    if (app.databaseController) {
+      deletePromises.push(app.databaseController.deleteEverything(fast));
+    } else if (app.databaseAdapter) {
+      _SchemaCache.default.clear();
+      deletePromises.push(app.databaseAdapter.deleteAllClasses(fast));
+    }
+    return Promise.all(deletePromises);
+  }));
+}
+function resolvingPromise() {
+  let res;
+  let rej;
+  const promise = new Promise((resolve, reject) => {
+    res = resolve;
+    rej = reject;
+  });
+  promise.resolve = res;
+  promise.reject = rej;
+  return promise;
+}
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+function getConnectionsCount(server) {
+  return new Promise((resolve, reject) => {
+    server.getConnections((err, count) => {
+      /* istanbul ignore next */
+      if (err) {
+        reject(err);
+      } else {
+        resolve(count);
+      }
+    });
+  });
+}
+;
+class Connections {
+  constructor() {
+    this.sockets = new Set();
+  }
+  track(server) {
+    server.on('connection', socket => {
+      this.sockets.add(socket);
+      socket.on('close', () => {
+        this.sockets.delete(socket);
+      });
+    });
+  }
+  destroyAll() {
+    for (const socket of this.sockets.values()) {
+      socket.destroy();
+    }
+    this.sockets.clear();
+  }
+  count() {
+    return this.sockets.size;
+  }
+}
+exports.Connections = Connections;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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