parse-server 9.9.0-alpha.2 → 9.9.0-alpha.3

package/lib/InstallationDedup.js

@@ -0,0 +1,178 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyDuplicateDeviceTokenMerge = applyDuplicateDeviceTokenMerge;
+exports.default = void 0;
+exports.removeConflictingDeviceToken = removeConflictingDeviceToken;
+var _node = _interopRequireDefault(require("parse/node"));
+var _logger = _interopRequireDefault(require("./logger"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const CLASS_NAME = '_Installation';
+function logResult(action, count, err) {
+  if (err && err.code === _node.default.Error.OBJECT_NOT_FOUND) {
+    _logger.default.verbose(`Installation dedup ${action} matched no rows; nothing to do.`);
+    return;
+  }
+  if (err && err.code === _node.default.Error.OPERATION_FORBIDDEN) {
+    _logger.default.warn(`Installation dedup ${action} skipped: caller has no permission to ${action} the conflicting row(s). The conflicting row remains.`);
+    return;
+  }
+  if (err) {
+    _logger.default.error(`Installation dedup ${action} failed: ${err.message || err}`);
+    return;
+  }
+  _logger.default.verbose(`Installation dedup ${action} applied to ${count == null ? 'matching' : count} conflicting row(s).`);
+}
+async function performAction({
+  database,
+  query,
+  action,
+  fieldToClear,
+  runOptions,
+  many,
+  validSchemaController
+}) {
+  if (action === 'delete') {
+    return database.destroy(CLASS_NAME, query, runOptions, validSchemaController);
+  }
+  if (action === 'update') {
+    return database.update(CLASS_NAME, query, {
+      [fieldToClear]: {
+        __op: 'Delete'
+      }
+    }, {
+      ...runOptions,
+      many
+    }, false, false, validSchemaController);
+  }
+  throw new Error(`Unknown installation dedup action: ${action}`);
+}
+
+/**
+ * Removes or updates `_Installation` rows that hold a `deviceToken` matching the query,
+ * allowing the caller to claim that `deviceToken` exclusively. Used when a new or updated
+ * install collides with one or more existing rows on `deviceToken`.
+ *
+ * @param {Object} options
+ * @param {DatabaseController} options.database
+ * @param {Object} options.query e.g. { deviceToken: 'X', installationId: { $ne: 'I' } }
+ * @param {'delete'|'update'} options.action
+ * @param {boolean} options.enforceAuth
+ * @param {Object} options.runOptions RestWrite.runOptions
+ * @param {SchemaController} options.validSchemaController
+ */
+async function removeConflictingDeviceToken({
+  database,
+  query,
+  action,
+  enforceAuth,
+  runOptions,
+  validSchemaController
+}) {
+  const opts = enforceAuth ? runOptions : {};
+  try {
+    await performAction({
+      database,
+      query,
+      action,
+      fieldToClear: 'deviceToken',
+      runOptions: opts,
+      many: true,
+      validSchemaController
+    });
+    logResult(action, null, null);
+  } catch (err) {
+    if (err && err.code === _node.default.Error.OBJECT_NOT_FOUND) {
+      logResult(action, 0, err);
+      return;
+    }
+    if (err && err.code === _node.default.Error.OPERATION_FORBIDDEN) {
+      logResult(action, null, err);
+      return;
+    }
+    logResult(action, null, err);
+    throw err;
+  }
+}
+
+/**
+ * Resolves a merge conflict between two `_Installation` rows that together represent the
+ * same install: one matched by `installationId`/`objectId` (`idMatch`), and another holding
+ * the same `deviceToken` but no `installationId` (`deviceTokenMatch`). The `mergePriority`
+ * determines which row survives; the loser receives the configured `action`. Returns the
+ * survivor's `objectId` so the save flow can target it.
+ *
+ * @param {Object} options
+ * @param {DatabaseController} options.database
+ * @param {{ objectId: string, installationId?: string, deviceToken?: string }} options.idMatch
+ * @param {{ objectId: string, deviceToken?: string }} options.deviceTokenMatch
+ * @param {'delete'|'update'} options.action
+ * @param {'deviceToken'|'installationId'} options.mergePriority
+ * @param {boolean} options.enforceAuth
+ * @param {Object} options.runOptions
+ * @param {SchemaController} options.validSchemaController
+ * @returns {Promise<string>} survivor's objectId
+ */
+async function applyDuplicateDeviceTokenMerge({
+  database,
+  idMatch,
+  deviceTokenMatch,
+  action,
+  mergePriority,
+  enforceAuth,
+  runOptions,
+  validSchemaController
+}) {
+  // Self-merge guard: when both matches resolve to the same row, there's
+  // nothing to clean up. Skip the action so we don't destroy/update the row
+  // we're about to return as the survivor.
+  if (idMatch.objectId === deviceTokenMatch.objectId) {
+    return idMatch.objectId;
+  }
+  const opts = enforceAuth ? runOptions : {};
+  let loser;
+  let survivorId;
+  let fieldToClear;
+  if (mergePriority === 'deviceToken') {
+    loser = idMatch;
+    survivorId = deviceTokenMatch.objectId;
+    fieldToClear = 'installationId';
+  } else if (mergePriority === 'installationId') {
+    loser = deviceTokenMatch;
+    survivorId = idMatch.objectId;
+    fieldToClear = 'deviceToken';
+  } else {
+    throw new Error(`Unknown installation dedup mergePriority: ${mergePriority}`);
+  }
+  try {
+    await performAction({
+      database,
+      query: {
+        objectId: loser.objectId
+      },
+      action,
+      fieldToClear,
+      runOptions: opts,
+      many: false,
+      validSchemaController
+    });
+    logResult(action, 1, null);
+  } catch (err) {
+    if (err && err.code === _node.default.Error.OBJECT_NOT_FOUND) {
+      logResult(action, 0, err);
+    } else if (err && err.code === _node.default.Error.OPERATION_FORBIDDEN) {
+      logResult(action, null, err);
+    } else {
+      logResult(action, null, err);
+      throw err;
+    }
+  }
+  return survivorId;
+}
+var _default = exports.default = {
+  removeConflictingDeviceToken,
+  applyDuplicateDeviceTokenMerge
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_node","_interopRequireDefault","require","_logger","e","__esModule","default","CLASS_NAME","logResult","action","count","err","code","Parse","Error","OBJECT_NOT_FOUND","logger","verbose","OPERATION_FORBIDDEN","warn","error","message","performAction","database","query","fieldToClear","runOptions","many","validSchemaController","destroy","update","__op","removeConflictingDeviceToken","enforceAuth","opts","applyDuplicateDeviceTokenMerge","idMatch","deviceTokenMatch","mergePriority","objectId","loser","survivorId","_default","exports"],"sources":["../src/InstallationDedup.js"],"sourcesContent":["import Parse from 'parse/node';\nimport logger from './logger';\n\nconst CLASS_NAME = '_Installation';\n\nfunction logResult(action, count, err) {\n  if (err && err.code === Parse.Error.OBJECT_NOT_FOUND) {\n    logger.verbose(`Installation dedup ${action} matched no rows; nothing to do.`);\n    return;\n  }\n  if (err && err.code === Parse.Error.OPERATION_FORBIDDEN) {\n    logger.warn(\n      `Installation dedup ${action} skipped: caller has no permission to ${action} the conflicting row(s). The conflicting row remains.`\n    );\n    return;\n  }\n  if (err) {\n    logger.error(`Installation dedup ${action} failed: ${err.message || err}`);\n    return;\n  }\n  logger.verbose(\n    `Installation dedup ${action} applied to ${count == null ? 'matching' : count} conflicting row(s).`\n  );\n}\n\nasync function performAction({\n  database,\n  query,\n  action,\n  fieldToClear,\n  runOptions,\n  many,\n  validSchemaController,\n}) {\n  if (action === 'delete') {\n    return database.destroy(CLASS_NAME, query, runOptions, validSchemaController);\n  }\n  if (action === 'update') {\n    return database.update(\n      CLASS_NAME,\n      query,\n      { [fieldToClear]: { __op: 'Delete' } },\n      { ...runOptions, many },\n      false,\n      false,\n      validSchemaController\n    );\n  }\n  throw new Error(`Unknown installation dedup action: ${action}`);\n}\n\n/**\n * Removes or updates `_Installation` rows that hold a `deviceToken` matching the query,\n * allowing the caller to claim that `deviceToken` exclusively. Used when a new or updated\n * install collides with one or more existing rows on `deviceToken`.\n *\n * @param {Object} options\n * @param {DatabaseController} options.database\n * @param {Object} options.query e.g. { deviceToken: 'X', installationId: { $ne: 'I' } }\n * @param {'delete'|'update'} options.action\n * @param {boolean} options.enforceAuth\n * @param {Object} options.runOptions RestWrite.runOptions\n * @param {SchemaController} options.validSchemaController\n */\nexport async function removeConflictingDeviceToken({\n  database,\n  query,\n  action,\n  enforceAuth,\n  runOptions,\n  validSchemaController,\n}) {\n  const opts = enforceAuth ? runOptions : {};\n  try {\n    await performAction({\n      database,\n      query,\n      action,\n      fieldToClear: 'deviceToken',\n      runOptions: opts,\n      many: true,\n      validSchemaController,\n    });\n    logResult(action, null, null);\n  } catch (err) {\n    if (err && err.code === Parse.Error.OBJECT_NOT_FOUND) {\n      logResult(action, 0, err);\n      return;\n    }\n    if (err && err.code === Parse.Error.OPERATION_FORBIDDEN) {\n      logResult(action, null, err);\n      return;\n    }\n    logResult(action, null, err);\n    throw err;\n  }\n}\n\n/**\n * Resolves a merge conflict between two `_Installation` rows that together represent the\n * same install: one matched by `installationId`/`objectId` (`idMatch`), and another holding\n * the same `deviceToken` but no `installationId` (`deviceTokenMatch`). The `mergePriority`\n * determines which row survives; the loser receives the configured `action`. Returns the\n * survivor's `objectId` so the save flow can target it.\n *\n * @param {Object} options\n * @param {DatabaseController} options.database\n * @param {{ objectId: string, installationId?: string, deviceToken?: string }} options.idMatch\n * @param {{ objectId: string, deviceToken?: string }} options.deviceTokenMatch\n * @param {'delete'|'update'} options.action\n * @param {'deviceToken'|'installationId'} options.mergePriority\n * @param {boolean} options.enforceAuth\n * @param {Object} options.runOptions\n * @param {SchemaController} options.validSchemaController\n * @returns {Promise<string>} survivor's objectId\n */\nexport async function applyDuplicateDeviceTokenMerge({\n  database,\n  idMatch,\n  deviceTokenMatch,\n  action,\n  mergePriority,\n  enforceAuth,\n  runOptions,\n  validSchemaController,\n}) {\n  // Self-merge guard: when both matches resolve to the same row, there's\n  // nothing to clean up. Skip the action so we don't destroy/update the row\n  // we're about to return as the survivor.\n  if (idMatch.objectId === deviceTokenMatch.objectId) {\n    return idMatch.objectId;\n  }\n  const opts = enforceAuth ? runOptions : {};\n  let loser;\n  let survivorId;\n  let fieldToClear;\n  if (mergePriority === 'deviceToken') {\n    loser = idMatch;\n    survivorId = deviceTokenMatch.objectId;\n    fieldToClear = 'installationId';\n  } else if (mergePriority === 'installationId') {\n    loser = deviceTokenMatch;\n    survivorId = idMatch.objectId;\n    fieldToClear = 'deviceToken';\n  } else {\n    throw new Error(`Unknown installation dedup mergePriority: ${mergePriority}`);\n  }\n\n  try {\n    await performAction({\n      database,\n      query: { objectId: loser.objectId },\n      action,\n      fieldToClear,\n      runOptions: opts,\n      many: false,\n      validSchemaController,\n    });\n    logResult(action, 1, null);\n  } catch (err) {\n    if (err && err.code === Parse.Error.OBJECT_NOT_FOUND) {\n      logResult(action, 0, err);\n    } else if (err && err.code === Parse.Error.OPERATION_FORBIDDEN) {\n      logResult(action, null, err);\n    } else {\n      logResult(action, null, err);\n      throw err;\n    }\n  }\n  return survivorId;\n}\n\nexport default {\n  removeConflictingDeviceToken,\n  applyDuplicateDeviceTokenMerge,\n};\n"],"mappings":";;;;;;;;AAAA,IAAAA,KAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,OAAA,GAAAF,sBAAA,CAAAC,OAAA;AAA8B,SAAAD,uBAAAG,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAE9B,MAAMG,UAAU,GAAG,eAAe;AAElC,SAASC,SAASA,CAACC,MAAM,EAAEC,KAAK,EAAEC,GAAG,EAAE;EACrC,IAAIA,GAAG,IAAIA,GAAG,CAACC,IAAI,KAAKC,aAAK,CAACC,KAAK,CAACC,gBAAgB,EAAE;IACpDC,eAAM,CAACC,OAAO,CAAC,sBAAsBR,MAAM,kCAAkC,CAAC;IAC9E;EACF;EACA,IAAIE,GAAG,IAAIA,GAAG,CAACC,IAAI,KAAKC,aAAK,CAACC,KAAK,CAACI,mBAAmB,EAAE;IACvDF,eAAM,CAACG,IAAI,CACT,sBAAsBV,MAAM,yCAAyCA,MAAM,uDAC7E,CAAC;IACD;EACF;EACA,IAAIE,GAAG,EAAE;IACPK,eAAM,CAACI,KAAK,CAAC,sBAAsBX,MAAM,YAAYE,GAAG,CAACU,OAAO,IAAIV,GAAG,EAAE,CAAC;IAC1E;EACF;EACAK,eAAM,CAACC,OAAO,CACZ,sBAAsBR,MAAM,eAAeC,KAAK,IAAI,IAAI,GAAG,UAAU,GAAGA,KAAK,sBAC/E,CAAC;AACH;AAEA,eAAeY,aAAaA,CAAC;EAC3BC,QAAQ;EACRC,KAAK;EACLf,MAAM;EACNgB,YAAY;EACZC,UAAU;EACVC,IAAI;EACJC;AACF,CAAC,EAAE;EACD,IAAInB,MAAM,KAAK,QAAQ,EAAE;IACvB,OAAOc,QAAQ,CAACM,OAAO,CAACtB,UAAU,EAAEiB,KAAK,EAAEE,UAAU,EAAEE,qBAAqB,CAAC;EAC/E;EACA,IAAInB,MAAM,KAAK,QAAQ,EAAE;IACvB,OAAOc,QAAQ,CAACO,MAAM,CACpBvB,UAAU,EACViB,KAAK,EACL;MAAE,CAACC,YAAY,GAAG;QAAEM,IAAI,EAAE;MAAS;IAAE,CAAC,EACtC;MAAE,GAAGL,UAAU;MAAEC;IAAK,CAAC,EACvB,KAAK,EACL,KAAK,EACLC,qBACF,CAAC;EACH;EACA,MAAM,IAAId,KAAK,CAAC,sCAAsCL,MAAM,EAAE,CAAC;AACjE;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,eAAeuB,4BAA4BA,CAAC;EACjDT,QAAQ;EACRC,KAAK;EACLf,MAAM;EACNwB,WAAW;EACXP,UAAU;EACVE;AACF,CAAC,EAAE;EACD,MAAMM,IAAI,GAAGD,WAAW,GAAGP,UAAU,GAAG,CAAC,CAAC;EAC1C,IAAI;IACF,MAAMJ,aAAa,CAAC;MAClBC,QAAQ;MACRC,KAAK;MACLf,MAAM;MACNgB,YAAY,EAAE,aAAa;MAC3BC,UAAU,EAAEQ,IAAI;MAChBP,IAAI,EAAE,IAAI;MACVC;IACF,CAAC,CAAC;IACFpB,SAAS,CAACC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC;EAC/B,CAAC,CAAC,OAAOE,GAAG,EAAE;IACZ,IAAIA,GAAG,IAAIA,GAAG,CAACC,IAAI,KAAKC,aAAK,CAACC,KAAK,CAACC,gBAAgB,EAAE;MACpDP,SAAS,CAACC,MAAM,EAAE,CAAC,EAAEE,GAAG,CAAC;MACzB;IACF;IACA,IAAIA,GAAG,IAAIA,GAAG,CAACC,IAAI,KAAKC,aAAK,CAACC,KAAK,CAACI,mBAAmB,EAAE;MACvDV,SAAS,CAACC,MAAM,EAAE,IAAI,EAAEE,GAAG,CAAC;MAC5B;IACF;IACAH,SAAS,CAACC,MAAM,EAAE,IAAI,EAAEE,GAAG,CAAC;IAC5B,MAAMA,GAAG;EACX;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,eAAewB,8BAA8BA,CAAC;EACnDZ,QAAQ;EACRa,OAAO;EACPC,gBAAgB;EAChB5B,MAAM;EACN6B,aAAa;EACbL,WAAW;EACXP,UAAU;EACVE;AACF,CAAC,EAAE;EACD;EACA;EACA;EACA,IAAIQ,OAAO,CAACG,QAAQ,KAAKF,gBAAgB,CAACE,QAAQ,EAAE;IAClD,OAAOH,OAAO,CAACG,QAAQ;EACzB;EACA,MAAML,IAAI,GAAGD,WAAW,GAAGP,UAAU,GAAG,CAAC,CAAC;EAC1C,IAAIc,KAAK;EACT,IAAIC,UAAU;EACd,IAAIhB,YAAY;EAChB,IAAIa,aAAa,KAAK,aAAa,EAAE;IACnCE,KAAK,GAAGJ,OAAO;IACfK,UAAU,GAAGJ,gBAAgB,CAACE,QAAQ;IACtCd,YAAY,GAAG,gBAAgB;EACjC,CAAC,MAAM,IAAIa,aAAa,KAAK,gBAAgB,EAAE;IAC7CE,KAAK,GAAGH,gBAAgB;IACxBI,UAAU,GAAGL,OAAO,CAACG,QAAQ;IAC7Bd,YAAY,GAAG,aAAa;EAC9B,CAAC,MAAM;IACL,MAAM,IAAIX,KAAK,CAAC,6CAA6CwB,aAAa,EAAE,CAAC;EAC/E;EAEA,IAAI;IACF,MAAMhB,aAAa,CAAC;MAClBC,QAAQ;MACRC,KAAK,EAAE;QAAEe,QAAQ,EAAEC,KAAK,CAACD;MAAS,CAAC;MACnC9B,MAAM;MACNgB,YAAY;MACZC,UAAU,EAAEQ,IAAI;MAChBP,IAAI,EAAE,KAAK;MACXC;IACF,CAAC,CAAC;IACFpB,SAAS,CAACC,MAAM,EAAE,CAAC,EAAE,IAAI,CAAC;EAC5B,CAAC,CAAC,OAAOE,GAAG,EAAE;IACZ,IAAIA,GAAG,IAAIA,GAAG,CAACC,IAAI,KAAKC,aAAK,CAACC,KAAK,CAACC,gBAAgB,EAAE;MACpDP,SAAS,CAACC,MAAM,EAAE,CAAC,EAAEE,GAAG,CAAC;IAC3B,CAAC,MAAM,IAAIA,GAAG,IAAIA,GAAG,CAACC,IAAI,KAAKC,aAAK,CAACC,KAAK,CAACI,mBAAmB,EAAE;MAC9DV,SAAS,CAACC,MAAM,EAAE,IAAI,EAAEE,GAAG,CAAC;IAC9B,CAAC,MAAM;MACLH,SAAS,CAACC,MAAM,EAAE,IAAI,EAAEE,GAAG,CAAC;MAC5B,MAAMA,GAAG;IACX;EACF;EACA,OAAO8B,UAAU;AACnB;AAAC,IAAAC,QAAA,GAAAC,OAAA,CAAArC,OAAA,GAEc;EACb0B,4BAA4B;EAC5BG;AACF,CAAC","ignoreList":[]}