@beiguancyc/parse-server 9.9.0-ruixiang.1 → 9.10.0-ruixiang.2

package/README.md

@@ -73,6 +73,11 @@ A big _thank you_ 🙏 to our [sponsors](#sponsors) and [backers](#backers) who
     - [Restricting File URL Domains](#restricting-file-url-domains)
   - [Idempotency Enforcement](#idempotency-enforcement)
   - [Installations](#installations)
+    - [Options](#options)
+      - [`duplicateDeviceTokenActionEnforceAuth`](#duplicatedevicetokenactionenforceauth)
+      - [`duplicateDeviceTokenAction`](#duplicatedevicetokenaction)
+      - [`duplicateDeviceTokenMergePriority`](#duplicatedevicetokenmergepriority)
+    - [Configuration example](#configuration-example)
   - [Localization](#localization)
     - [Pages](#pages)
       - [Localization with Directory Structure](#localization-with-directory-structure)
@@ -314,7 +319,7 @@ The client keys used with Parse are no longer necessary with Parse Server. If yo
 
 ## Route Allow List
 
-The `routeAllowList` option restricts which API routes are accessible to external clients. When set, all external requests are denied by default unless the route matches one of the configured regex patterns. This is useful for apps where all logic runs in Cloud Code and clients should not access the API directly.
+The `routeAllowList` option restricts which REST API routes are accessible to external clients. When set, all external REST API requests are denied by default unless the route matches one of the configured regex patterns. This is useful for apps where all logic runs in Cloud Code and clients should not access the REST API directly.
 
 Internal calls from Cloud Code, Cloud Jobs, and triggers are not affected. Master key and maintenance key requests bypass the restriction.
 
@@ -334,7 +339,7 @@ const server = ParseServer({
 
 Each entry is a regex pattern matched against the normalized route identifier. Patterns are auto-anchored with `^` and `$` for full-match semantics. For example, `classes/Chat` matches only `classes/Chat`, not `classes/ChatRoom`. Use `classes/Chat.*` to match both.
 
-Setting an empty array `[]` blocks all external non-master-key requests (full lockdown). Not setting the option preserves current behavior (all routes accessible).
+Setting an empty array `[]` blocks all external non-master-key REST API requests (full lockdown of REST API routes). Not setting the option preserves current behavior (all routes accessible).
 
 ### Covered Routes
 
@@ -395,6 +400,9 @@ The following table lists all route groups covered by `routeAllowList` with exam
 > [!NOTE]
 > File routes are not covered by `routeAllowList`. File upload access is controlled via the `fileUpload` option. File download and metadata access is controlled via the `fileDownload` option.
 
+> [!NOTE]
+> The GraphQL API is not covered by `routeAllowList`. `routeAllowList` gates the REST API per route, while every GraphQL operation is transported over a single endpoint with the operation, target class, and field set encoded in the request body — so per-route allow-list semantics do not compose with it.
+
 ## Email Verification and Password Reset
 
 Verifying user email addresses and enabling password reset via email requires an email adapter. There are many email adapters provided and maintained by the community. The following is an example configuration with an example email adapter. See the [Parse Server Options][server-options] for more details and a full list of available options.

package/lib/Adapters/Files/setupFilesLink.js

@@ -0,0 +1,85 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.setupFilesLink = setupFilesLink;
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * When filesAdapter.options.filesLinkTarget is set, create a symlink at
+ * files/{filesSubDirectory} -> filesLinkTarget before the FS adapter starts.
+ * This lets multiple Parse instances use distinct link names under files/
+ * without changing @parse/fs-files-adapter.
+ *
+ * @param {Object} filesAdapter parse-server filesAdapter config (module/class form with options)
+ */
+function setupFilesLink(filesAdapter) {
+  if (!filesAdapter || typeof filesAdapter !== 'object' || !filesAdapter.options) {
+    return;
+  }
+  const {
+    filesLinkTarget,
+    filesSubDirectory
+  } = filesAdapter.options;
+  if (filesLinkTarget === undefined || filesLinkTarget === null || filesLinkTarget === '') {
+    return;
+  }
+  if (!filesSubDirectory) {
+    throw new Error('filesAdapter.options.filesSubDirectory is required when filesLinkTarget is set.');
+  }
+  const targetPath = path.resolve(String(filesLinkTarget));
+  const linkPath = path.join('files', filesSubDirectory);
+  const linkParent = path.dirname(linkPath);
+  fs.mkdirSync(targetPath, {
+    recursive: true
+  });
+  fs.mkdirSync(linkParent, {
+    recursive: true
+  });
+  let linkStat;
+  try {
+    linkStat = fs.lstatSync(linkPath);
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      createSymlink(targetPath, linkPath);
+      return;
+    }
+    throw err;
+  }
+  if (linkStat.isSymbolicLink() || isWindowsJunction(linkPath, linkStat)) {
+    const currentTarget = path.resolve(path.dirname(linkPath), fs.readlinkSync(linkPath));
+    if (pathsEqual(currentTarget, targetPath)) {
+      return;
+    }
+    throw new Error(`files link "${linkPath}" already points to "${currentTarget}", expected "${targetPath}".`);
+  }
+  throw new Error(`Cannot create files link at "${linkPath}": path already exists and is not a symlink.`);
+}
+function createSymlink(targetPath, linkPath) {
+  // junction on Windows avoids elevated privileges required for directory symlinks
+  const type = process.platform === 'win32' ? 'junction' : 'dir';
+  fs.symlinkSync(targetPath, linkPath, type);
+}
+function isWindowsJunction(linkPath, linkStat) {
+  // Directory junctions may not always report as symbolic links; readlink is definitive.
+  if (process.platform !== 'win32' || !linkStat.isDirectory()) {
+    return false;
+  }
+  try {
+    fs.readlinkSync(linkPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function pathsEqual(a, b) {
+  if (process.platform === 'win32') {
+    return a.toLowerCase() === b.toLowerCase();
+  }
+  return a === b;
+}
+var _default = exports.default = setupFilesLink;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/Adapters/Storage/Mongo/MongoCollection.js

@@ -4,8 +4,47 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+exports.findGeoIndexField = findGeoIndexField;
 const mongodb = require('mongodb');
 const Collection = mongodb.Collection;
+
+// Query operators that require a geospatial index and therefore trigger
+// on-demand `2d` index creation. `$geoWithin` / `$geoIntersects` are intentionally
+// excluded: they can run as a collection scan and never raise a "no index" error.
+const GEO_INDEX_QUERY_OPERATORS = ['$nearSphere', '$near', '$geoNear'];
+
+// Find the field in a Mongo query document that is constrained by a geo operator
+// requiring a geospatial index. Returns the field name (e.g. 'location'), or
+// undefined if none is found. Used as the reliable source of truth for on-demand
+// geo index creation, since the MongoDB error message that used to carry the field
+// name (`... field=<name> ...`) was dropped in MongoDB 8.3+.
+//
+// A geo-near expression must be top-level or inside `$and`: MongoDB rejects it inside
+// `$or` / `$nor` ("geo $near must be top-level expr") and forbids more than one per
+// query ("Too many geoNear expressions"). So there is at most one field to find, and
+// `$and` is the only combinator we need to recurse into.
+function findGeoIndexField(query) {
+  if (!query || typeof query !== 'object') {
+    return undefined;
+  }
+  for (const field of Object.keys(query)) {
+    const value = query[field];
+    // Recurse into `$and`, which holds an array of sub-queries.
+    if (field === '$and' && Array.isArray(value)) {
+      for (const subQuery of value) {
+        const found = findGeoIndexField(subQuery);
+        if (found) {
+          return found;
+        }
+      }
+      continue;
+    }
+    if (value && typeof value === 'object' && GEO_INDEX_QUERY_OPERATORS.some(op => Object.prototype.hasOwnProperty.call(value, op))) {
+      return field;
+    }
+  }
+  return undefined;
+}
 class MongoCollection {
   constructor(mongoCollection) {
     this._mongoCollection = mongoCollection;
@@ -53,8 +92,12 @@ class MongoCollection {
       if (error.code != 17007 && !error.message.match(/unable to find index for .geoNear/)) {
         throw error;
       }
-      // Figure out what key needs an index
-      const key = error.message.match(/field=([A-Za-z_0-9]+) /)[1];
+      // Figure out which field needs a geo index.
+      // Older MongoDB embeds the field name in the error message (`... field=<name> ...`);
+      // MongoDB 8.3+ shortened the message to `unable to find index for $geoNear query`
+      // and no longer includes it, so fall back to reading the field from the query itself.
+      const messageMatch = error.message.match(/field=([A-Za-z_0-9]+) /);
+      const key = messageMatch && messageMatch[1] || findGeoIndexField(query);
       if (!key) {
         throw error;
       }
@@ -209,4 +252,4 @@ class MongoCollection {
   }
 }
 exports.default = MongoCollection;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["mongodb","require","Collection","MongoCollection","constructor","mongoCollection","_mongoCollection","find","query","skip","limit","sort","keys","maxTimeMS","batchSize","readPreference","hint","caseInsensitive","explain","comment","$score","score","$meta","_rawFind","catch","error","code","message","match","key","index","createIndex","then","caseInsensitiveCollation","locale","strength","findOperation","project","collation","toArray","count","Object","length","estimatedDocumentCount","countOperation","countDocuments","distinct","field","aggregate","pipeline","insertOne","object","session","upsertOne","update","updateOne","upsert","updateMany","deleteMany","_ensureSparseUniqueIndexInBackground","indexRequest","unique","background","sparse","drop","exports","default"],"sources":["../../../../src/Adapters/Storage/Mongo/MongoCollection.js"],"sourcesContent":["const mongodb = require('mongodb');\nconst Collection = mongodb.Collection;\n\nexport default class MongoCollection {\n  _mongoCollection: Collection;\n\n  constructor(mongoCollection: Collection) {\n    this._mongoCollection = mongoCollection;\n  }\n\n  // Does a find with \"smart indexing\".\n  // Currently this just means, if it needs a geoindex and there is\n  // none, then build the geoindex.\n  // This could be improved a lot but it's not clear if that's a good\n  // idea. Or even if this behavior is a good idea.\n  find(\n    query,\n    {\n      skip,\n      limit,\n      sort,\n      keys,\n      maxTimeMS,\n      batchSize,\n      readPreference,\n      hint,\n      caseInsensitive,\n      explain,\n      comment,\n    } = {}\n  ) {\n    // Support for Full Text Search - $text\n    if (keys && keys.$score) {\n      delete keys.$score;\n      keys.score = { $meta: 'textScore' };\n    }\n    return this._rawFind(query, {\n      skip,\n      limit,\n      sort,\n      keys,\n      maxTimeMS,\n      batchSize,\n      readPreference,\n      hint,\n      caseInsensitive,\n      explain,\n      comment,\n    }).catch(error => {\n      // Check for \"no geoindex\" error\n      if (error.code != 17007 && !error.message.match(/unable to find index for .geoNear/)) {\n        throw error;\n      }\n      // Figure out what key needs an index\n      const key = error.message.match(/field=([A-Za-z_0-9]+) /)[1];\n      if (!key) {\n        throw error;\n      }\n\n      var index = {};\n      index[key] = '2d';\n      return (\n        this._mongoCollection\n          .createIndex(index)\n          // Retry, but just once.\n          .then(() =>\n            this._rawFind(query, {\n              skip,\n              limit,\n              sort,\n              keys,\n              maxTimeMS,\n              batchSize,\n              readPreference,\n              hint,\n              caseInsensitive,\n              explain,\n              comment,\n            })\n          )\n      );\n    });\n  }\n\n  /**\n   * Collation to support case insensitive queries\n   */\n  static caseInsensitiveCollation() {\n    return { locale: 'en_US', strength: 2 };\n  }\n\n  _rawFind(\n    query,\n    {\n      skip,\n      limit,\n      sort,\n      keys,\n      maxTimeMS,\n      batchSize,\n      readPreference,\n      hint,\n      caseInsensitive,\n      explain,\n      comment,\n    } = {}\n  ) {\n    let findOperation = this._mongoCollection.find(query, {\n      skip,\n      limit,\n      sort,\n      readPreference,\n      hint,\n      comment,\n      batchSize,\n    });\n\n    if (keys) {\n      findOperation = findOperation.project(keys);\n    }\n\n    if (caseInsensitive) {\n      findOperation = findOperation.collation(MongoCollection.caseInsensitiveCollation());\n    }\n\n    if (maxTimeMS) {\n      findOperation = findOperation.maxTimeMS(maxTimeMS);\n    }\n\n    return explain ? findOperation.explain(explain) : findOperation.toArray();\n  }\n\n  count(query, { skip, limit, sort, maxTimeMS, readPreference, hint, comment } = {}) {\n    // If query is empty, then use estimatedDocumentCount instead.\n    // This is due to countDocuments performing a scan,\n    // which greatly increases execution time when being run on large collections.\n    // See https://github.com/Automattic/mongoose/issues/6713 for more info regarding this problem.\n    if (typeof query !== 'object' || !Object.keys(query).length) {\n      return this._mongoCollection.estimatedDocumentCount({\n        maxTimeMS,\n      });\n    }\n\n    const countOperation = this._mongoCollection.countDocuments(query, {\n      skip,\n      limit,\n      sort,\n      maxTimeMS,\n      readPreference,\n      hint,\n      comment,\n    });\n\n    return countOperation;\n  }\n\n  distinct(field, query) {\n    return this._mongoCollection.distinct(field, query);\n  }\n\n  aggregate(pipeline, { maxTimeMS, batchSize, readPreference, hint, explain, comment } = {}) {\n    return this._mongoCollection\n      .aggregate(pipeline, { maxTimeMS, batchSize, readPreference, hint, explain, comment })\n      .toArray();\n  }\n\n  insertOne(object, session) {\n    return this._mongoCollection.insertOne(object, { session });\n  }\n\n  // Atomically updates data in the database for a single (first) object that matched the query\n  // If there is nothing that matches the query - does insert\n  // Postgres Note: `INSERT ... ON CONFLICT UPDATE` that is available since 9.5.\n  upsertOne(query, update, session) {\n    return this._mongoCollection.updateOne(query, update, {\n      upsert: true,\n      session,\n    });\n  }\n\n  updateOne(query, update) {\n    return this._mongoCollection.updateOne(query, update);\n  }\n\n  updateMany(query, update, session) {\n    return this._mongoCollection.updateMany(query, update, { session });\n  }\n\n  deleteMany(query, session) {\n    return this._mongoCollection.deleteMany(query, { session });\n  }\n\n  _ensureSparseUniqueIndexInBackground(indexRequest) {\n    return this._mongoCollection.createIndex(indexRequest, {\n      unique: true,\n      background: true,\n      sparse: true,\n    });\n  }\n\n  drop() {\n    return this._mongoCollection.drop();\n  }\n}\n"],"mappings":"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","ignoreList":[]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["mongodb","require","Collection","GEO_INDEX_QUERY_OPERATORS","findGeoIndexField","query","undefined","field","Object","keys","value","Array","isArray","subQuery","found","some","op","prototype","hasOwnProperty","call","MongoCollection","constructor","mongoCollection","_mongoCollection","find","skip","limit","sort","maxTimeMS","batchSize","readPreference","hint","caseInsensitive","explain","comment","$score","score","$meta","_rawFind","catch","error","code","message","match","messageMatch","key","index","createIndex","then","caseInsensitiveCollation","locale","strength","findOperation","project","collation","toArray","count","length","estimatedDocumentCount","countOperation","countDocuments","distinct","aggregate","pipeline","insertOne","object","session","upsertOne","update","updateOne","upsert","updateMany","deleteMany","_ensureSparseUniqueIndexInBackground","indexRequest","unique","background","sparse","drop","exports","default"],"sources":["../../../../src/Adapters/Storage/Mongo/MongoCollection.js"],"sourcesContent":["const mongodb = require('mongodb');\nconst Collection = mongodb.Collection;\n\n// Query operators that require a geospatial index and therefore trigger\n// on-demand `2d` index creation. `$geoWithin` / `$geoIntersects` are intentionally\n// excluded: they can run as a collection scan and never raise a \"no index\" error.\nconst GEO_INDEX_QUERY_OPERATORS = ['$nearSphere', '$near', '$geoNear'];\n\n// Find the field in a Mongo query document that is constrained by a geo operator\n// requiring a geospatial index. Returns the field name (e.g. 'location'), or\n// undefined if none is found. Used as the reliable source of truth for on-demand\n// geo index creation, since the MongoDB error message that used to carry the field\n// name (`... field=<name> ...`) was dropped in MongoDB 8.3+.\n//\n// A geo-near expression must be top-level or inside `$and`: MongoDB rejects it inside\n// `$or` / `$nor` (\"geo $near must be top-level expr\") and forbids more than one per\n// query (\"Too many geoNear expressions\"). So there is at most one field to find, and\n// `$and` is the only combinator we need to recurse into.\nexport function findGeoIndexField(query) {\n  if (!query || typeof query !== 'object') {\n    return undefined;\n  }\n  for (const field of Object.keys(query)) {\n    const value = query[field];\n    // Recurse into `$and`, which holds an array of sub-queries.\n    if (field === '$and' && Array.isArray(value)) {\n      for (const subQuery of value) {\n        const found = findGeoIndexField(subQuery);\n        if (found) {\n          return found;\n        }\n      }\n      continue;\n    }\n    if (\n      value &&\n      typeof value === 'object' &&\n      GEO_INDEX_QUERY_OPERATORS.some(op => Object.prototype.hasOwnProperty.call(value, op))\n    ) {\n      return field;\n    }\n  }\n  return undefined;\n}\n\nexport default class MongoCollection {\n  _mongoCollection: Collection;\n\n  constructor(mongoCollection: Collection) {\n    this._mongoCollection = mongoCollection;\n  }\n\n  // Does a find with \"smart indexing\".\n  // Currently this just means, if it needs a geoindex and there is\n  // none, then build the geoindex.\n  // This could be improved a lot but it's not clear if that's a good\n  // idea. Or even if this behavior is a good idea.\n  find(\n    query,\n    {\n      skip,\n      limit,\n      sort,\n      keys,\n      maxTimeMS,\n      batchSize,\n      readPreference,\n      hint,\n      caseInsensitive,\n      explain,\n      comment,\n    } = {}\n  ) {\n    // Support for Full Text Search - $text\n    if (keys && keys.$score) {\n      delete keys.$score;\n      keys.score = { $meta: 'textScore' };\n    }\n    return this._rawFind(query, {\n      skip,\n      limit,\n      sort,\n      keys,\n      maxTimeMS,\n      batchSize,\n      readPreference,\n      hint,\n      caseInsensitive,\n      explain,\n      comment,\n    }).catch(error => {\n      // Check for \"no geoindex\" error\n      if (error.code != 17007 && !error.message.match(/unable to find index for .geoNear/)) {\n        throw error;\n      }\n      // Figure out which field needs a geo index.\n      // Older MongoDB embeds the field name in the error message (`... field=<name> ...`);\n      // MongoDB 8.3+ shortened the message to `unable to find index for $geoNear query`\n      // and no longer includes it, so fall back to reading the field from the query itself.\n      const messageMatch = error.message.match(/field=([A-Za-z_0-9]+) /);\n      const key = (messageMatch && messageMatch[1]) || findGeoIndexField(query);\n      if (!key) {\n        throw error;\n      }\n\n      var index = {};\n      index[key] = '2d';\n      return (\n        this._mongoCollection\n          .createIndex(index)\n          // Retry, but just once.\n          .then(() =>\n            this._rawFind(query, {\n              skip,\n              limit,\n              sort,\n              keys,\n              maxTimeMS,\n              batchSize,\n              readPreference,\n              hint,\n              caseInsensitive,\n              explain,\n              comment,\n            })\n          )\n      );\n    });\n  }\n\n  /**\n   * Collation to support case insensitive queries\n   */\n  static caseInsensitiveCollation() {\n    return { locale: 'en_US', strength: 2 };\n  }\n\n  _rawFind(\n    query,\n    {\n      skip,\n      limit,\n      sort,\n      keys,\n      maxTimeMS,\n      batchSize,\n      readPreference,\n      hint,\n      caseInsensitive,\n      explain,\n      comment,\n    } = {}\n  ) {\n    let findOperation = this._mongoCollection.find(query, {\n      skip,\n      limit,\n      sort,\n      readPreference,\n      hint,\n      comment,\n      batchSize,\n    });\n\n    if (keys) {\n      findOperation = findOperation.project(keys);\n    }\n\n    if (caseInsensitive) {\n      findOperation = findOperation.collation(MongoCollection.caseInsensitiveCollation());\n    }\n\n    if (maxTimeMS) {\n      findOperation = findOperation.maxTimeMS(maxTimeMS);\n    }\n\n    return explain ? findOperation.explain(explain) : findOperation.toArray();\n  }\n\n  count(query, { skip, limit, sort, maxTimeMS, readPreference, hint, comment } = {}) {\n    // If query is empty, then use estimatedDocumentCount instead.\n    // This is due to countDocuments performing a scan,\n    // which greatly increases execution time when being run on large collections.\n    // See https://github.com/Automattic/mongoose/issues/6713 for more info regarding this problem.\n    if (typeof query !== 'object' || !Object.keys(query).length) {\n      return this._mongoCollection.estimatedDocumentCount({\n        maxTimeMS,\n      });\n    }\n\n    const countOperation = this._mongoCollection.countDocuments(query, {\n      skip,\n      limit,\n      sort,\n      maxTimeMS,\n      readPreference,\n      hint,\n      comment,\n    });\n\n    return countOperation;\n  }\n\n  distinct(field, query) {\n    return this._mongoCollection.distinct(field, query);\n  }\n\n  aggregate(pipeline, { maxTimeMS, batchSize, readPreference, hint, explain, comment } = {}) {\n    return this._mongoCollection\n      .aggregate(pipeline, { maxTimeMS, batchSize, readPreference, hint, explain, comment })\n      .toArray();\n  }\n\n  insertOne(object, session) {\n    return this._mongoCollection.insertOne(object, { session });\n  }\n\n  // Atomically updates data in the database for a single (first) object that matched the query\n  // If there is nothing that matches the query - does insert\n  // Postgres Note: `INSERT ... ON CONFLICT UPDATE` that is available since 9.5.\n  upsertOne(query, update, session) {\n    return this._mongoCollection.updateOne(query, update, {\n      upsert: true,\n      session,\n    });\n  }\n\n  updateOne(query, update) {\n    return this._mongoCollection.updateOne(query, update);\n  }\n\n  updateMany(query, update, session) {\n    return this._mongoCollection.updateMany(query, update, { session });\n  }\n\n  deleteMany(query, session) {\n    return this._mongoCollection.deleteMany(query, { session });\n  }\n\n  _ensureSparseUniqueIndexInBackground(indexRequest) {\n    return this._mongoCollection.createIndex(indexRequest, {\n      unique: true,\n      background: true,\n      sparse: true,\n    });\n  }\n\n  drop() {\n    return this._mongoCollection.drop();\n  }\n}\n"],"mappings":"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","ignoreList":[]}