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

package/lib/Deprecator/Deprecations.js

@@ -92,5 +92,9 @@ module.exports = [{
   optionKey: 'protectedFieldsSaveResponseExempt',
   changeNewDefault: 'false',
   solution: "Set 'protectedFieldsSaveResponseExempt' to 'false' to strip protected fields from write operation responses (create, update), consistent with how they are stripped from query results. Set to 'true' to keep the current behavior where protected fields are included in write responses."
+}, {
+  optionKey: 'installation.duplicateDeviceTokenActionEnforceAuth',
+  changeNewDefault: 'true',
+  solution: "Set 'installation.duplicateDeviceTokenActionEnforceAuth' to 'true' to enforce the caller's auth context (and the resulting ACL and CLP) when Parse Server deduplicates _Installation records sharing the same deviceToken. Set to 'false' to keep the current behavior of bypassing permissions on the dedup operation."
 }];
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["module","exports","optionKey","changeNewDefault","solution","changeNewKey","resolvedValue"],"sources":["../../src/Deprecator/Deprecations.js"],"sourcesContent":["/**\n * The deprecations.\n *\n * Add deprecations to the array using the following keys:\n * - `optionKey` {String}: The option key incl. its path, e.g. `security.enableCheck`.\n * - `envKey` {String}: The environment key, e.g. `PARSE_SERVER_SECURITY`.\n * - `changeNewKey` {String}: Set the new key name if the current key will be replaced,\n * or set to an empty string if the current key will be removed without replacement.\n * - `changeNewDefault` {String}: Set the new default value if the key's default value\n * will change in a future version.\n * - `resolvedValue` {any}: The option value that suppresses the deprecation warning,\n * indicating the user has already adopted the future behavior. Only applicable when\n * `changeNewKey` is an empty string (option will be removed without replacement).\n * For example, `false` for an option that will be removed, if setting it to `false`\n * disables the deprecated feature.\n * - `solution`: The instruction to resolve this deprecation warning. Optional. This\n * instruction must not include the deprecation warning which is auto-generated.\n * It should only contain additional instruction regarding the deprecation if\n * necessary.\n *\n * If there are no deprecations, this must return an empty array.\n */\nmodule.exports = [\n  {\n    optionKey: 'fileUpload.allowedFileUrlDomains',\n    changeNewDefault: '[]',\n    solution: \"Set 'fileUpload.allowedFileUrlDomains' to the domains you want to allow, or to '[]' to block all file URLs.\",\n  },\n  {\n    optionKey: 'pages.encodePageParamHeaders',\n    changeNewDefault: 'true',\n    solution: \"Set 'pages.encodePageParamHeaders' to 'true' to URI-encode non-ASCII characters in page parameter headers.\",\n  },\n  {\n    optionKey: 'readOnlyMasterKeyIps',\n    changeNewDefault: '[\"127.0.0.1\", \"::1\"]',\n    solution: \"Set 'readOnlyMasterKeyIps' to the IP addresses that should be allowed to use the read-only master key, or to '[\\\"127.0.0.1\\\", \\\"::1\\\"]' to restrict access to localhost.\",\n  },\n  {\n    optionKey: 'mountPlayground',\n    changeNewKey: '',\n    solution: \"Use Parse Dashboard as GraphQL IDE or configure a third-party GraphQL client such as Apollo Sandbox, GraphiQL, or Insomnia with custom request headers.\",\n  },\n  {\n    optionKey: 'playgroundPath',\n    changeNewKey: '',\n    solution: \"Use Parse Dashboard as GraphQL IDE or configure a third-party GraphQL client such as Apollo Sandbox, GraphiQL, or Insomnia with custom request headers.\",\n  },\n  {\n    optionKey: 'requestComplexity.includeDepth',\n    changeNewDefault: '10',\n    solution: \"Set 'requestComplexity.includeDepth' to a positive integer appropriate for your app to limit include pointer chain depth, or to '-1' to disable.\",\n  },\n  {\n    optionKey: 'requestComplexity.includeCount',\n    changeNewDefault: '100',\n    solution: \"Set 'requestComplexity.includeCount' to a positive integer appropriate for your app to limit the number of include paths per query, or to '-1' to disable.\",\n  },\n  {\n    optionKey: 'requestComplexity.subqueryDepth',\n    changeNewDefault: '10',\n    solution: \"Set 'requestComplexity.subqueryDepth' to a positive integer appropriate for your app to limit subquery nesting depth, or to '-1' to disable.\",\n  },\n  {\n    optionKey: 'requestComplexity.queryDepth',\n    changeNewDefault: '10',\n    solution: \"Set 'requestComplexity.queryDepth' to a positive integer appropriate for your app to limit query condition nesting depth, or to '-1' to disable.\",\n  },\n  {\n    optionKey: 'requestComplexity.graphQLDepth',\n    changeNewDefault: '20',\n    solution: \"Set 'requestComplexity.graphQLDepth' to a positive integer appropriate for your app to limit GraphQL field selection depth, or to '-1' to disable.\",\n  },\n  {\n    optionKey: 'requestComplexity.graphQLFields',\n    changeNewDefault: '200',\n    solution: \"Set 'requestComplexity.graphQLFields' to a positive integer appropriate for your app to limit the number of GraphQL field selections, or to '-1' to disable.\",\n  },\n  {\n    optionKey: 'requestComplexity.batchRequestLimit',\n    changeNewDefault: '100',\n    solution: \"Set 'requestComplexity.batchRequestLimit' to a positive integer appropriate for your app to limit the number of sub-requests per batch request, or to '-1' to disable.\",\n  },\n  {\n    optionKey: 'enableProductPurchaseLegacyApi',\n    changeNewKey: '',\n    resolvedValue: false,\n    solution: \"The product purchase API is an undocumented, unmaintained legacy feature that may not function as expected and will be removed in a future major version. We strongly advise against using it. Set 'enableProductPurchaseLegacyApi' to 'false' to disable it, or remove the option to accept the future removal.\",\n  },\n  {\n    optionKey: 'allowExpiredAuthDataToken',\n    changeNewKey: '',\n    resolvedValue: false,\n    solution: \"Auth providers are always validated on login regardless of this setting. Set 'allowExpiredAuthDataToken' to 'false' or remove the option to accept the future removal.\",\n  },\n  {\n    optionKey: 'protectedFieldsOwnerExempt',\n    changeNewDefault: 'false',\n    solution: \"Set 'protectedFieldsOwnerExempt' to 'false' to apply protectedFields consistently to the user's own _User object (same as all other classes), or to 'true' to keep the current behavior where a user can see all their own fields.\",\n  },\n  {\n    optionKey: 'protectedFieldsTriggerExempt',\n    changeNewDefault: 'true',\n    solution: \"Set 'protectedFieldsTriggerExempt' to 'true' to make Cloud Code triggers (e.g. beforeSave, afterSave) receive the full object including protected fields, or to 'false' to keep the current behavior where protected fields are stripped from trigger objects.\",\n  },\n  {\n    optionKey: 'protectedFieldsSaveResponseExempt',\n    changeNewDefault: 'false',\n    solution: \"Set 'protectedFieldsSaveResponseExempt' to 'false' to strip protected fields from write operation responses (create, update), consistent with how they are stripped from query results. Set to 'true' to keep the current behavior where protected fields are included in write responses.\",\n  },\n];\n"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAA,MAAM,CAACC,OAAO,GAAG,CACf;EACEC,SAAS,EAAE,kCAAkC;EAC7CC,gBAAgB,EAAE,IAAI;EACtBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,8BAA8B;EACzCC,gBAAgB,EAAE,MAAM;EACxBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,sBAAsB;EACjCC,gBAAgB,EAAE,sBAAsB;EACxCC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,iBAAiB;EAC5BG,YAAY,EAAE,EAAE;EAChBD,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,gBAAgB;EAC3BG,YAAY,EAAE,EAAE;EAChBD,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,gCAAgC;EAC3CC,gBAAgB,EAAE,IAAI;EACtBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,gCAAgC;EAC3CC,gBAAgB,EAAE,KAAK;EACvBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,iCAAiC;EAC5CC,gBAAgB,EAAE,IAAI;EACtBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,8BAA8B;EACzCC,gBAAgB,EAAE,IAAI;EACtBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,gCAAgC;EAC3CC,gBAAgB,EAAE,IAAI;EACtBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,iCAAiC;EAC5CC,gBAAgB,EAAE,KAAK;EACvBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,qCAAqC;EAChDC,gBAAgB,EAAE,KAAK;EACvBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,gCAAgC;EAC3CG,YAAY,EAAE,EAAE;EAChBC,aAAa,EAAE,KAAK;EACpBF,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,2BAA2B;EACtCG,YAAY,EAAE,EAAE;EAChBC,aAAa,EAAE,KAAK;EACpBF,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,4BAA4B;EACvCC,gBAAgB,EAAE,OAAO;EACzBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,8BAA8B;EACzCC,gBAAgB,EAAE,MAAM;EACxBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,mCAAmC;EAC9CC,gBAAgB,EAAE,OAAO;EACzBC,QAAQ,EAAE;AACZ,CAAC,CACF","ignoreList":[]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["module","exports","optionKey","changeNewDefault","solution","changeNewKey","resolvedValue"],"sources":["../../src/Deprecator/Deprecations.js"],"sourcesContent":["/**\n * The deprecations.\n *\n * Add deprecations to the array using the following keys:\n * - `optionKey` {String}: The option key incl. its path, e.g. `security.enableCheck`.\n * - `envKey` {String}: The environment key, e.g. `PARSE_SERVER_SECURITY`.\n * - `changeNewKey` {String}: Set the new key name if the current key will be replaced,\n * or set to an empty string if the current key will be removed without replacement.\n * - `changeNewDefault` {String}: Set the new default value if the key's default value\n * will change in a future version.\n * - `resolvedValue` {any}: The option value that suppresses the deprecation warning,\n * indicating the user has already adopted the future behavior. Only applicable when\n * `changeNewKey` is an empty string (option will be removed without replacement).\n * For example, `false` for an option that will be removed, if setting it to `false`\n * disables the deprecated feature.\n * - `solution`: The instruction to resolve this deprecation warning. Optional. This\n * instruction must not include the deprecation warning which is auto-generated.\n * It should only contain additional instruction regarding the deprecation if\n * necessary.\n *\n * If there are no deprecations, this must return an empty array.\n */\nmodule.exports = [\n  {\n    optionKey: 'fileUpload.allowedFileUrlDomains',\n    changeNewDefault: '[]',\n    solution: \"Set 'fileUpload.allowedFileUrlDomains' to the domains you want to allow, or to '[]' to block all file URLs.\",\n  },\n  {\n    optionKey: 'pages.encodePageParamHeaders',\n    changeNewDefault: 'true',\n    solution: \"Set 'pages.encodePageParamHeaders' to 'true' to URI-encode non-ASCII characters in page parameter headers.\",\n  },\n  {\n    optionKey: 'readOnlyMasterKeyIps',\n    changeNewDefault: '[\"127.0.0.1\", \"::1\"]',\n    solution: \"Set 'readOnlyMasterKeyIps' to the IP addresses that should be allowed to use the read-only master key, or to '[\\\"127.0.0.1\\\", \\\"::1\\\"]' to restrict access to localhost.\",\n  },\n  {\n    optionKey: 'mountPlayground',\n    changeNewKey: '',\n    solution: \"Use Parse Dashboard as GraphQL IDE or configure a third-party GraphQL client such as Apollo Sandbox, GraphiQL, or Insomnia with custom request headers.\",\n  },\n  {\n    optionKey: 'playgroundPath',\n    changeNewKey: '',\n    solution: \"Use Parse Dashboard as GraphQL IDE or configure a third-party GraphQL client such as Apollo Sandbox, GraphiQL, or Insomnia with custom request headers.\",\n  },\n  {\n    optionKey: 'requestComplexity.includeDepth',\n    changeNewDefault: '10',\n    solution: \"Set 'requestComplexity.includeDepth' to a positive integer appropriate for your app to limit include pointer chain depth, or to '-1' to disable.\",\n  },\n  {\n    optionKey: 'requestComplexity.includeCount',\n    changeNewDefault: '100',\n    solution: \"Set 'requestComplexity.includeCount' to a positive integer appropriate for your app to limit the number of include paths per query, or to '-1' to disable.\",\n  },\n  {\n    optionKey: 'requestComplexity.subqueryDepth',\n    changeNewDefault: '10',\n    solution: \"Set 'requestComplexity.subqueryDepth' to a positive integer appropriate for your app to limit subquery nesting depth, or to '-1' to disable.\",\n  },\n  {\n    optionKey: 'requestComplexity.queryDepth',\n    changeNewDefault: '10',\n    solution: \"Set 'requestComplexity.queryDepth' to a positive integer appropriate for your app to limit query condition nesting depth, or to '-1' to disable.\",\n  },\n  {\n    optionKey: 'requestComplexity.graphQLDepth',\n    changeNewDefault: '20',\n    solution: \"Set 'requestComplexity.graphQLDepth' to a positive integer appropriate for your app to limit GraphQL field selection depth, or to '-1' to disable.\",\n  },\n  {\n    optionKey: 'requestComplexity.graphQLFields',\n    changeNewDefault: '200',\n    solution: \"Set 'requestComplexity.graphQLFields' to a positive integer appropriate for your app to limit the number of GraphQL field selections, or to '-1' to disable.\",\n  },\n  {\n    optionKey: 'requestComplexity.batchRequestLimit',\n    changeNewDefault: '100',\n    solution: \"Set 'requestComplexity.batchRequestLimit' to a positive integer appropriate for your app to limit the number of sub-requests per batch request, or to '-1' to disable.\",\n  },\n  {\n    optionKey: 'enableProductPurchaseLegacyApi',\n    changeNewKey: '',\n    resolvedValue: false,\n    solution: \"The product purchase API is an undocumented, unmaintained legacy feature that may not function as expected and will be removed in a future major version. We strongly advise against using it. Set 'enableProductPurchaseLegacyApi' to 'false' to disable it, or remove the option to accept the future removal.\",\n  },\n  {\n    optionKey: 'allowExpiredAuthDataToken',\n    changeNewKey: '',\n    resolvedValue: false,\n    solution: \"Auth providers are always validated on login regardless of this setting. Set 'allowExpiredAuthDataToken' to 'false' or remove the option to accept the future removal.\",\n  },\n  {\n    optionKey: 'protectedFieldsOwnerExempt',\n    changeNewDefault: 'false',\n    solution: \"Set 'protectedFieldsOwnerExempt' to 'false' to apply protectedFields consistently to the user's own _User object (same as all other classes), or to 'true' to keep the current behavior where a user can see all their own fields.\",\n  },\n  {\n    optionKey: 'protectedFieldsTriggerExempt',\n    changeNewDefault: 'true',\n    solution: \"Set 'protectedFieldsTriggerExempt' to 'true' to make Cloud Code triggers (e.g. beforeSave, afterSave) receive the full object including protected fields, or to 'false' to keep the current behavior where protected fields are stripped from trigger objects.\",\n  },\n  {\n    optionKey: 'protectedFieldsSaveResponseExempt',\n    changeNewDefault: 'false',\n    solution: \"Set 'protectedFieldsSaveResponseExempt' to 'false' to strip protected fields from write operation responses (create, update), consistent with how they are stripped from query results. Set to 'true' to keep the current behavior where protected fields are included in write responses.\",\n  },\n  {\n    optionKey: 'installation.duplicateDeviceTokenActionEnforceAuth',\n    changeNewDefault: 'true',\n    solution: \"Set 'installation.duplicateDeviceTokenActionEnforceAuth' to 'true' to enforce the caller's auth context (and the resulting ACL and CLP) when Parse Server deduplicates _Installation records sharing the same deviceToken. Set to 'false' to keep the current behavior of bypassing permissions on the dedup operation.\",\n  },\n];\n"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAA,MAAM,CAACC,OAAO,GAAG,CACf;EACEC,SAAS,EAAE,kCAAkC;EAC7CC,gBAAgB,EAAE,IAAI;EACtBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,8BAA8B;EACzCC,gBAAgB,EAAE,MAAM;EACxBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,sBAAsB;EACjCC,gBAAgB,EAAE,sBAAsB;EACxCC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,iBAAiB;EAC5BG,YAAY,EAAE,EAAE;EAChBD,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,gBAAgB;EAC3BG,YAAY,EAAE,EAAE;EAChBD,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,gCAAgC;EAC3CC,gBAAgB,EAAE,IAAI;EACtBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,gCAAgC;EAC3CC,gBAAgB,EAAE,KAAK;EACvBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,iCAAiC;EAC5CC,gBAAgB,EAAE,IAAI;EACtBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,8BAA8B;EACzCC,gBAAgB,EAAE,IAAI;EACtBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,gCAAgC;EAC3CC,gBAAgB,EAAE,IAAI;EACtBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,iCAAiC;EAC5CC,gBAAgB,EAAE,KAAK;EACvBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,qCAAqC;EAChDC,gBAAgB,EAAE,KAAK;EACvBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,gCAAgC;EAC3CG,YAAY,EAAE,EAAE;EAChBC,aAAa,EAAE,KAAK;EACpBF,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,2BAA2B;EACtCG,YAAY,EAAE,EAAE;EAChBC,aAAa,EAAE,KAAK;EACpBF,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,4BAA4B;EACvCC,gBAAgB,EAAE,OAAO;EACzBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,8BAA8B;EACzCC,gBAAgB,EAAE,MAAM;EACxBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,mCAAmC;EAC9CC,gBAAgB,EAAE,OAAO;EACzBC,QAAQ,EAAE;AACZ,CAAC,EACD;EACEF,SAAS,EAAE,oDAAoD;EAC/DC,gBAAgB,EAAE,MAAM;EACxBC,QAAQ,EAAE;AACZ,CAAC,CACF","ignoreList":[]}

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":"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","ignoreList":[]}