@beiguancyc/parse-server 9.9.0-ruixiang.1

package/lib/password.js

@@ -0,0 +1,40 @@
+"use strict";
+
+// Tools for encrypting and decrypting passwords.
+// Basically promise-friendly wrappers for bcrypt.
+var bcrypt = require('bcryptjs');
+try {
+  const _bcrypt = require('@node-rs/bcrypt');
+  bcrypt = {
+    hash: _bcrypt.hash,
+    compare: _bcrypt.verify
+  };
+} catch {
+  /* */
+}
+
+// Returns a promise for a hashed password string.
+function hash(password) {
+  return bcrypt.hash(password, 10);
+}
+
+// Returns a promise for whether this password compares to equal this
+// hashed password.
+function compare(password, hashedPassword) {
+  // Cannot bcrypt compare when one is undefined
+  if (!password || !hashedPassword) {
+    return Promise.resolve(false);
+  }
+  return bcrypt.compare(password, hashedPassword);
+}
+
+// Pre-computed bcrypt hash (cost factor 10) used for timing normalization.
+// The actual value is irrelevant; it ensures bcrypt.compare() runs with
+// realistic cost even when no real password hash is available.
+const dummyHash = '$2b$10$Wd1gvrMYPnQv5pHBbXCwCehxXmJSEzRqNON0ev98L6JJP5296S35i';
+module.exports = {
+  hash: hash,
+  compare: compare,
+  dummyHash: dummyHash
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/request.js

@@ -0,0 +1,175 @@
+"use strict";
+
+var _querystring = _interopRequireDefault(require("querystring"));
+var _logger = _interopRequireDefault(require("./logger"));
+var _followRedirects = require("follow-redirects");
+var _url = require("url");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class HTTPResponse {
+  constructor(response, body) {
+    let _text, _data;
+    this.status = response.statusCode;
+    this.headers = response.headers || {};
+    this.cookies = this.headers['set-cookie'];
+    if (typeof body == 'string') {
+      _text = body;
+    } else if (Buffer.isBuffer(body)) {
+      this.buffer = body;
+    } else if (typeof body == 'object') {
+      _data = body;
+    }
+    const getText = () => {
+      if (!_text && this.buffer) {
+        _text = this.buffer.toString('utf-8');
+      } else if (!_text && _data) {
+        _text = JSON.stringify(_data);
+      }
+      return _text;
+    };
+    const getData = () => {
+      if (!_data) {
+        try {
+          _data = JSON.parse(getText());
+        } catch {
+          /* */
+        }
+      }
+      return _data;
+    };
+    Object.defineProperty(this, 'body', {
+      get: () => {
+        return body;
+      }
+    });
+    Object.defineProperty(this, 'text', {
+      enumerable: true,
+      get: getText
+    });
+    Object.defineProperty(this, 'data', {
+      enumerable: true,
+      get: getData
+    });
+  }
+}
+const clients = {
+  'http:': _followRedirects.http,
+  'https:': _followRedirects.https
+};
+function makeCallback(resolve, reject) {
+  return function (response) {
+    const chunks = [];
+    response.on('data', chunk => {
+      chunks.push(chunk);
+    });
+    response.on('end', () => {
+      const body = Buffer.concat(chunks);
+      const httpResponse = new HTTPResponse(response, body);
+
+      // Consider <200 && >= 400 as errors
+      if (httpResponse.status < 200 || httpResponse.status >= 400) {
+        return reject(httpResponse);
+      } else {
+        return resolve(httpResponse);
+      }
+    });
+    response.on('error', reject);
+  };
+}
+const encodeBody = function ({
+  body,
+  headers = {}
+}) {
+  if (typeof body !== 'object') {
+    return {
+      body,
+      headers
+    };
+  }
+  var contentTypeKeys = Object.keys(headers).filter(key => {
+    return key.match(/content-type/i) != null;
+  });
+  if (contentTypeKeys.length == 0) {
+    // no content type
+    //  As per https://parse.com/docs/cloudcode/guide#cloud-code-advanced-sending-a-post-request the default encoding is supposedly x-www-form-urlencoded
+
+    body = _querystring.default.stringify(body);
+    headers['Content-Type'] = 'application/x-www-form-urlencoded';
+  } else {
+    /* istanbul ignore next */
+    if (contentTypeKeys.length > 1) {
+      _logger.default.error('Parse.Cloud.httpRequest', 'multiple content-type headers are set.');
+    }
+    // There maybe many, we'll just take the 1st one
+    var contentType = contentTypeKeys[0];
+    if (headers[contentType].match(/application\/json/i)) {
+      body = JSON.stringify(body);
+    } else if (headers[contentType].match(/application\/x-www-form-urlencoded/i)) {
+      body = _querystring.default.stringify(body);
+    }
+  }
+  return {
+    body,
+    headers
+  };
+};
+function httpRequest(options) {
+  let url;
+  try {
+    url = (0, _url.parse)(options.url);
+  } catch (e) {
+    return Promise.reject(e);
+  }
+  options = Object.assign(options, encodeBody(options));
+  // support params options
+  if (typeof options.params === 'object') {
+    options.qs = options.params;
+  } else if (typeof options.params === 'string') {
+    options.qs = _querystring.default.parse(options.params);
+  }
+  const client = clients[url.protocol];
+  if (!client) {
+    return Promise.reject(`Unsupported protocol ${url.protocol}`);
+  }
+  const requestOptions = {
+    method: options.method,
+    port: Number(url.port),
+    path: url.pathname,
+    hostname: url.hostname,
+    headers: options.headers,
+    encoding: null,
+    followRedirects: options.followRedirects === true
+  };
+  if (requestOptions.headers) {
+    Object.keys(requestOptions.headers).forEach(key => {
+      if (typeof requestOptions.headers[key] === 'undefined') {
+        delete requestOptions.headers[key];
+      }
+    });
+  }
+  if (url.search) {
+    options.qs = Object.assign({}, options.qs, _querystring.default.parse(url.query));
+  }
+  if (url.auth) {
+    requestOptions.auth = url.auth;
+  }
+  if (options.qs) {
+    requestOptions.path += `?${_querystring.default.stringify(options.qs)}`;
+  }
+  if (options.agent) {
+    requestOptions.agent = options.agent;
+  }
+  return new Promise((resolve, reject) => {
+    const req = client.request(requestOptions, makeCallback(resolve, reject, options));
+    if (options.body) {
+      req.write(options.body);
+    }
+    req.on('error', error => {
+      reject(error);
+    });
+    req.end();
+  });
+}
+module.exports = httpRequest;
+module.exports.encodeBody = encodeBody;
+module.exports.HTTPResponse = HTTPResponse;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_querystring","_interopRequireDefault","require","_logger","_followRedirects","_url","e","__esModule","default","HTTPResponse","constructor","response","body","_text","_data","status","statusCode","headers","cookies","Buffer","isBuffer","buffer","getText","toString","JSON","stringify","getData","parse","Object","defineProperty","get","enumerable","clients","http","https","makeCallback","resolve","reject","chunks","on","chunk","push","concat","httpResponse","encodeBody","contentTypeKeys","keys","filter","key","match","length","querystring","log","error","contentType","httpRequest","options","url","Promise","assign","params","qs","client","protocol","requestOptions","method","port","Number","path","pathname","hostname","encoding","followRedirects","forEach","search","query","auth","agent","req","request","write","end","module","exports"],"sources":["../src/request.js"],"sourcesContent":["import querystring from 'querystring';\nimport log from './logger';\nimport { http, https } from 'follow-redirects';\nimport { parse } from 'url';\n\nclass HTTPResponse {\n  constructor(response, body) {\n    let _text, _data;\n    this.status = response.statusCode;\n    this.headers = response.headers || {};\n    this.cookies = this.headers['set-cookie'];\n\n    if (typeof body == 'string') {\n      _text = body;\n    } else if (Buffer.isBuffer(body)) {\n      this.buffer = body;\n    } else if (typeof body == 'object') {\n      _data = body;\n    }\n\n    const getText = () => {\n      if (!_text && this.buffer) {\n        _text = this.buffer.toString('utf-8');\n      } else if (!_text && _data) {\n        _text = JSON.stringify(_data);\n      }\n      return _text;\n    };\n\n    const getData = () => {\n      if (!_data) {\n        try {\n          _data = JSON.parse(getText());\n        } catch {\n          /* */\n        }\n      }\n      return _data;\n    };\n\n    Object.defineProperty(this, 'body', {\n      get: () => {\n        return body;\n      },\n    });\n\n    Object.defineProperty(this, 'text', {\n      enumerable: true,\n      get: getText,\n    });\n\n    Object.defineProperty(this, 'data', {\n      enumerable: true,\n      get: getData,\n    });\n  }\n}\n\nconst clients = {\n  'http:': http,\n  'https:': https,\n};\n\nfunction makeCallback(resolve, reject) {\n  return function (response) {\n    const chunks = [];\n    response.on('data', chunk => {\n      chunks.push(chunk);\n    });\n    response.on('end', () => {\n      const body = Buffer.concat(chunks);\n      const httpResponse = new HTTPResponse(response, body);\n\n      // Consider <200 && >= 400 as errors\n      if (httpResponse.status < 200 || httpResponse.status >= 400) {\n        return reject(httpResponse);\n      } else {\n        return resolve(httpResponse);\n      }\n    });\n    response.on('error', reject);\n  };\n}\n\nconst encodeBody = function ({ body, headers = {} }) {\n  if (typeof body !== 'object') {\n    return { body, headers };\n  }\n  var contentTypeKeys = Object.keys(headers).filter(key => {\n    return key.match(/content-type/i) != null;\n  });\n\n  if (contentTypeKeys.length == 0) {\n    // no content type\n    //  As per https://parse.com/docs/cloudcode/guide#cloud-code-advanced-sending-a-post-request the default encoding is supposedly x-www-form-urlencoded\n\n    body = querystring.stringify(body);\n    headers['Content-Type'] = 'application/x-www-form-urlencoded';\n  } else {\n    /* istanbul ignore next */\n    if (contentTypeKeys.length > 1) {\n      log.error('Parse.Cloud.httpRequest', 'multiple content-type headers are set.');\n    }\n    // There maybe many, we'll just take the 1st one\n    var contentType = contentTypeKeys[0];\n    if (headers[contentType].match(/application\\/json/i)) {\n      body = JSON.stringify(body);\n    } else if (headers[contentType].match(/application\\/x-www-form-urlencoded/i)) {\n      body = querystring.stringify(body);\n    }\n  }\n  return { body, headers };\n};\n\nfunction httpRequest(options) {\n  let url;\n  try {\n    url = parse(options.url);\n  } catch (e) {\n    return Promise.reject(e);\n  }\n  options = Object.assign(options, encodeBody(options));\n  // support params options\n  if (typeof options.params === 'object') {\n    options.qs = options.params;\n  } else if (typeof options.params === 'string') {\n    options.qs = querystring.parse(options.params);\n  }\n  const client = clients[url.protocol];\n  if (!client) {\n    return Promise.reject(`Unsupported protocol ${url.protocol}`);\n  }\n  const requestOptions = {\n    method: options.method,\n    port: Number(url.port),\n    path: url.pathname,\n    hostname: url.hostname,\n    headers: options.headers,\n    encoding: null,\n    followRedirects: options.followRedirects === true,\n  };\n  if (requestOptions.headers) {\n    Object.keys(requestOptions.headers).forEach(key => {\n      if (typeof requestOptions.headers[key] === 'undefined') {\n        delete requestOptions.headers[key];\n      }\n    });\n  }\n  if (url.search) {\n    options.qs = Object.assign({}, options.qs, querystring.parse(url.query));\n  }\n  if (url.auth) {\n    requestOptions.auth = url.auth;\n  }\n  if (options.qs) {\n    requestOptions.path += `?${querystring.stringify(options.qs)}`;\n  }\n  if (options.agent) {\n    requestOptions.agent = options.agent;\n  }\n  return new Promise((resolve, reject) => {\n    const req = client.request(requestOptions, makeCallback(resolve, reject, options));\n    if (options.body) {\n      req.write(options.body);\n    }\n    req.on('error', error => {\n      reject(error);\n    });\n    req.end();\n  });\n}\nmodule.exports = httpRequest;\nmodule.exports.encodeBody = encodeBody;\nmodule.exports.HTTPResponse = HTTPResponse;\n"],"mappings":"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","ignoreList":[]}

package/lib/requiredParameter.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = errorMessage => {
+  throw errorMessage;
+};
+exports.default = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJlcnJvck1lc3NhZ2UiLCJleHBvcnRzIiwiZGVmYXVsdCIsIl9kZWZhdWx0Il0sInNvdXJjZXMiOlsiLi4vc3JjL3JlcXVpcmVkUGFyYW1ldGVyLmpzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKiBAZmxvdyAqL1xuZXhwb3J0IGRlZmF1bHQgKGVycm9yTWVzc2FnZTogc3RyaW5nKTogYW55ID0+IHtcbiAgdGhyb3cgZXJyb3JNZXNzYWdlO1xufTtcbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7O2VBQ2dCQSxZQUFvQixJQUFVO0VBQzVDLE1BQU1BLFlBQVk7QUFDcEIsQ0FBQztBQUFBQyxPQUFBLENBQUFDLE9BQUEsR0FBQUMsUUFBQSIsImlnbm9yZUxpc3QiOltdfQ==

package/lib/rest.js

@@ -0,0 +1,264 @@
+"use strict";
+
+// This file contains helpers for running operations in REST format.
+// The goal is that handlers that explicitly handle an express route
+// should just be shallow wrappers around things in this file, but
+// these functions should not explicitly depend on the request
+// object.
+// This means that one of these handlers can support multiple
+// routes. That's useful for the routes that do really similar
+// things.
+
+var Parse = require('parse/node').Parse;
+var RestQuery = require('./RestQuery');
+var RestWrite = require('./RestWrite');
+var triggers = require('./triggers');
+const Auth = require('./Auth');
+const {
+  enforceRoleSecurity
+} = require('./SharedRest');
+const {
+  createSanitizedError
+} = require('./Error');
+function checkTriggers(className, config, types) {
+  return types.some(triggerType => {
+    return triggers.getTrigger(className, triggers.Types[triggerType], config.applicationId);
+  });
+}
+function checkLiveQuery(className, config) {
+  return config.liveQueryController && config.liveQueryController.hasLiveQuery(className);
+}
+async function runFindTriggers(config, auth, className, restWhere, restOptions, clientSDK, context, options = {}) {
+  const {
+    isGet
+  } = options;
+  if (restOptions && restOptions.explain && !auth.isMaster) {
+    const allowPublicExplain = config.databaseOptions?.allowPublicExplain ?? false;
+    if (!allowPublicExplain) {
+      throw new Parse.Error(Parse.Error.INVALID_QUERY, 'Using the explain query parameter requires the master key');
+    }
+  }
+
+  // Run beforeFind trigger - may modify query or return objects directly
+  const result = await triggers.maybeRunQueryTrigger(triggers.Types.beforeFind, className, restWhere, restOptions, config, auth, context, isGet);
+  restWhere = result.restWhere || restWhere;
+  restOptions = result.restOptions || restOptions;
+
+  // Short-circuit path: beforeFind returned objects directly
+  // Security risk: These objects may have been fetched with master privileges
+  if (result?.objects) {
+    const objectsFromBeforeFind = result.objects;
+    let objectsForAfterFind = objectsFromBeforeFind;
+
+    // Security check: Re-filter objects if not master to ensure ACL/CLP compliance
+    if (!auth?.isMaster && !auth?.isMaintenance) {
+      const ids = (Array.isArray(objectsFromBeforeFind) ? objectsFromBeforeFind : [objectsFromBeforeFind]).map(o => o && (o.id || o.objectId) || null).filter(Boolean);
+
+      // Objects without IDs are(normally) unsaved objects
+      // For unsaved objects, the ACL security does not apply, so no need to redo the query.
+      // For saved objects, we need to re-query to ensure proper ACL/CLP enforcement
+      if (ids.length > 0) {
+        const refilterWhere = isGet ? {
+          objectId: ids[0]
+        } : {
+          objectId: {
+            $in: ids
+          }
+        };
+
+        // Re-query with proper security: no triggers to avoid infinite loops
+        const refilterQuery = await RestQuery({
+          method: isGet ? RestQuery.Method.get : RestQuery.Method.find,
+          config,
+          auth,
+          className,
+          restWhere: refilterWhere,
+          restOptions,
+          clientSDK,
+          context,
+          runBeforeFind: false,
+          runAfterFind: false
+        });
+        const refiltered = await refilterQuery.execute();
+        objectsForAfterFind = refiltered && refiltered.results || [];
+      }
+    }
+
+    // Run afterFind trigger on security-filtered objects
+    const afterFindProcessedObjects = await triggers.maybeRunAfterFindTrigger(triggers.Types.afterFind, auth, className, objectsForAfterFind, config, new Parse.Query(className).withJSON({
+      where: restWhere,
+      ...restOptions
+    }), context, isGet);
+    return {
+      results: afterFindProcessedObjects
+    };
+  }
+
+  // Normal path: execute database query with modified conditions
+  const query = await RestQuery({
+    method: isGet ? RestQuery.Method.get : RestQuery.Method.find,
+    config,
+    auth,
+    className,
+    restWhere,
+    restOptions,
+    clientSDK,
+    context,
+    runBeforeFind: false
+  });
+  return query.execute();
+}
+
+// Returns a promise for an object with optional keys 'results' and 'count'.
+const find = async (config, auth, className, restWhere, restOptions, clientSDK, context) => {
+  enforceRoleSecurity('find', className, auth, config);
+  return runFindTriggers(config, auth, className, restWhere, restOptions, clientSDK, context, {
+    isGet: false
+  });
+};
+
+// get is just like find but only queries an objectId.
+const get = async (config, auth, className, objectId, restOptions, clientSDK, context) => {
+  enforceRoleSecurity('get', className, auth, config);
+  return runFindTriggers(config, auth, className, {
+    objectId
+  }, restOptions, clientSDK, context, {
+    isGet: true
+  });
+};
+
+// Returns a promise that doesn't resolve to any useful value.
+function del(config, auth, className, objectId, context) {
+  if (typeof objectId !== 'string') {
+    throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad objectId');
+  }
+  if (className === '_User' && auth.isUnauthenticated()) {
+    throw new Parse.Error(Parse.Error.SESSION_MISSING, 'Insufficient auth to delete user');
+  }
+  enforceRoleSecurity('delete', className, auth, config);
+  let inflatedObject;
+  let schemaController;
+  return Promise.resolve().then(async () => {
+    const hasTriggers = checkTriggers(className, config, ['beforeDelete', 'afterDelete']);
+    const hasLiveQuery = checkLiveQuery(className, config);
+    if (hasTriggers || hasLiveQuery || className == '_Session') {
+      const query = await RestQuery({
+        method: RestQuery.Method.get,
+        config,
+        auth,
+        className,
+        restWhere: {
+          objectId
+        }
+      });
+      return query.execute({
+        op: 'delete'
+      }).then(response => {
+        if (response && response.results && response.results.length) {
+          const firstResult = response.results[0];
+          firstResult.className = className;
+          if (className === '_Session' && !auth.isMaster && !auth.isMaintenance) {
+            if (!auth.user || firstResult.user.objectId !== auth.user.id) {
+              throw createSanitizedError(Parse.Error.INVALID_SESSION_TOKEN, 'Invalid session token', config);
+            }
+          }
+          var cacheAdapter = config.cacheController;
+          cacheAdapter.user.del(firstResult.sessionToken);
+          inflatedObject = Parse.Object.fromJSON(firstResult);
+          return triggers.maybeRunTrigger(triggers.Types.beforeDelete, auth, inflatedObject, null, config, context);
+        }
+        throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Object not found for delete.');
+      });
+    }
+    return Promise.resolve({});
+  }).then(() => {
+    if (!auth.isMaster && !auth.isMaintenance) {
+      return auth.getUserRoles();
+    } else {
+      return;
+    }
+  }).then(() => config.database.loadSchema()).then(s => {
+    schemaController = s;
+    const options = {};
+    if (!auth.isMaster && !auth.isMaintenance) {
+      options.acl = ['*'];
+      if (auth.user) {
+        options.acl.push(auth.user.id);
+        options.acl = options.acl.concat(auth.userRoles);
+      }
+    }
+    return config.database.destroy(className, {
+      objectId: objectId
+    }, options, schemaController);
+  }).then(() => {
+    // Notify LiveQuery server if possible
+    const perms = schemaController.getClassLevelPermissions(className);
+    config.liveQueryController.onAfterDelete(className, inflatedObject, null, perms);
+    return triggers.maybeRunTrigger(triggers.Types.afterDelete, auth, inflatedObject, null, config, context);
+  }).catch(error => {
+    handleSessionMissingError(error, className, auth, config);
+  });
+}
+
+// Returns a promise for a {response, status, location} object.
+function create(config, auth, className, restObject, clientSDK, context) {
+  enforceRoleSecurity('create', className, auth, config);
+  var write = new RestWrite(config, auth, className, null, restObject, null, clientSDK, context);
+  return write.execute();
+}
+
+// Returns a promise that contains the fields of the update that the
+// REST API is supposed to return.
+// Usually, this is just updatedAt.
+function update(config, auth, className, restWhere, restObject, clientSDK, context) {
+  enforceRoleSecurity('update', className, auth, config);
+  return Promise.resolve().then(async () => {
+    const hasTriggers = checkTriggers(className, config, ['beforeSave', 'afterSave']);
+    const hasLiveQuery = checkLiveQuery(className, config);
+    if (hasTriggers || hasLiveQuery) {
+      // Do not use find, as it runs the before finds
+      // Use master auth when protectedFieldsTriggerExempt is true to bypass
+      // protectedFields filtering, so triggers see the full original object
+      const queryAuth = config.protectedFieldsTriggerExempt ? Auth.master(config) : auth;
+      const query = await RestQuery({
+        method: RestQuery.Method.get,
+        config,
+        auth: queryAuth,
+        className,
+        restWhere,
+        runAfterFind: false,
+        runBeforeFind: false,
+        context
+      });
+      return query.execute({
+        op: 'update'
+      });
+    }
+    return Promise.resolve({});
+  }).then(({
+    results
+  }) => {
+    var originalRestObject;
+    if (results && results.length) {
+      originalRestObject = results[0];
+    }
+    return new RestWrite(config, auth, className, restWhere, restObject, originalRestObject, clientSDK, context, 'update').execute();
+  }).catch(error => {
+    handleSessionMissingError(error, className, auth, config);
+  });
+}
+function handleSessionMissingError(error, className, auth, config) {
+  // If we're trying to update a user without / with bad session token
+  if (className === '_User' && error.code === Parse.Error.OBJECT_NOT_FOUND && !auth.isMaster && !auth.isMaintenance) {
+    throw createSanitizedError(Parse.Error.SESSION_MISSING, 'Insufficient auth.', config);
+  }
+  throw error;
+}
+module.exports = {
+  create,
+  del,
+  find,
+  get,
+  update
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Parse","require","RestQuery","RestWrite","triggers","Auth","enforceRoleSecurity","createSanitizedError","checkTriggers","className","config","types","some","triggerType","getTrigger","Types","applicationId","checkLiveQuery","liveQueryController","hasLiveQuery","runFindTriggers","auth","restWhere","restOptions","clientSDK","context","options","isGet","explain","isMaster","allowPublicExplain","databaseOptions","Error","INVALID_QUERY","result","maybeRunQueryTrigger","beforeFind","objects","objectsFromBeforeFind","objectsForAfterFind","isMaintenance","ids","Array","isArray","map","o","id","objectId","filter","Boolean","length","refilterWhere","$in","refilterQuery","method","Method","get","find","runBeforeFind","runAfterFind","refiltered","execute","results","afterFindProcessedObjects","maybeRunAfterFindTrigger","afterFind","Query","withJSON","where","query","del","INVALID_JSON","isUnauthenticated","SESSION_MISSING","inflatedObject","schemaController","Promise","resolve","then","hasTriggers","op","response","firstResult","user","INVALID_SESSION_TOKEN","cacheAdapter","cacheController","sessionToken","Object","fromJSON","maybeRunTrigger","beforeDelete","OBJECT_NOT_FOUND","getUserRoles","database","loadSchema","s","acl","push","concat","userRoles","destroy","perms","getClassLevelPermissions","onAfterDelete","afterDelete","catch","error","handleSessionMissingError","create","restObject","write","update","queryAuth","protectedFieldsTriggerExempt","master","originalRestObject","code","module","exports"],"sources":["../src/rest.js"],"sourcesContent":["// This file contains helpers for running operations in REST format.\n// The goal is that handlers that explicitly handle an express route\n// should just be shallow wrappers around things in this file, but\n// these functions should not explicitly depend on the request\n// object.\n// This means that one of these handlers can support multiple\n// routes. That's useful for the routes that do really similar\n// things.\n\nvar Parse = require('parse/node').Parse;\n\nvar RestQuery = require('./RestQuery');\nvar RestWrite = require('./RestWrite');\nvar triggers = require('./triggers');\nconst Auth = require('./Auth');\nconst { enforceRoleSecurity } = require('./SharedRest');\nconst { createSanitizedError } = require('./Error');\n\nfunction checkTriggers(className, config, types) {\n  return types.some(triggerType => {\n    return triggers.getTrigger(className, triggers.Types[triggerType], config.applicationId);\n  });\n}\n\nfunction checkLiveQuery(className, config) {\n  return config.liveQueryController && config.liveQueryController.hasLiveQuery(className);\n}\nasync function runFindTriggers(\n  config,\n  auth,\n  className,\n  restWhere,\n  restOptions,\n  clientSDK,\n  context,\n  options = {}\n) {\n  const { isGet } = options;\n\n  if (restOptions && restOptions.explain && !auth.isMaster) {\n    const allowPublicExplain = config.databaseOptions?.allowPublicExplain ?? false;\n\n    if (!allowPublicExplain) {\n      throw new Parse.Error(\n        Parse.Error.INVALID_QUERY,\n        'Using the explain query parameter requires the master key'\n      );\n    }\n  }\n\n  // Run beforeFind trigger - may modify query or return objects directly\n  const result = await triggers.maybeRunQueryTrigger(\n    triggers.Types.beforeFind,\n    className,\n    restWhere,\n    restOptions,\n    config,\n    auth,\n    context,\n    isGet\n  );\n\n  restWhere = result.restWhere || restWhere;\n  restOptions = result.restOptions || restOptions;\n\n  // Short-circuit path: beforeFind returned objects directly\n  // Security risk: These objects may have been fetched with master privileges\n  if (result?.objects) {\n    const objectsFromBeforeFind = result.objects;\n\n    let objectsForAfterFind = objectsFromBeforeFind;\n\n    // Security check: Re-filter objects if not master to ensure ACL/CLP compliance\n    if (!auth?.isMaster && !auth?.isMaintenance) {\n      const ids = (Array.isArray(objectsFromBeforeFind) ? objectsFromBeforeFind : [objectsFromBeforeFind])\n        .map(o => (o && (o.id || o.objectId)) || null)\n        .filter(Boolean);\n\n      // Objects without IDs are(normally) unsaved objects\n      // For unsaved objects, the ACL security does not apply, so no need to redo the query.\n      // For saved objects, we need to re-query to ensure proper ACL/CLP enforcement\n      if (ids.length > 0) {\n        const refilterWhere = isGet ? { objectId: ids[0] } : { objectId: { $in: ids } };\n\n        // Re-query with proper security: no triggers to avoid infinite loops\n        const refilterQuery = await RestQuery({\n          method: isGet ? RestQuery.Method.get : RestQuery.Method.find,\n          config,\n          auth,\n          className,\n          restWhere: refilterWhere,\n          restOptions,\n          clientSDK,\n          context,\n          runBeforeFind: false,\n          runAfterFind: false,\n        });\n\n        const refiltered = await refilterQuery.execute();\n        objectsForAfterFind = (refiltered && refiltered.results) || [];\n      }\n    }\n\n    // Run afterFind trigger on security-filtered objects\n    const afterFindProcessedObjects = await triggers.maybeRunAfterFindTrigger(\n      triggers.Types.afterFind,\n      auth,\n      className,\n      objectsForAfterFind,\n      config,\n      new Parse.Query(className).withJSON({ where: restWhere, ...restOptions }),\n      context,\n      isGet\n    );\n\n    return {\n      results: afterFindProcessedObjects,\n    };\n  }\n\n  // Normal path: execute database query with modified conditions\n  const query = await RestQuery({\n    method: isGet ? RestQuery.Method.get : RestQuery.Method.find,\n    config,\n    auth,\n    className,\n    restWhere,\n    restOptions,\n    clientSDK,\n    context,\n    runBeforeFind: false,\n  });\n\n  return query.execute();\n}\n\n// Returns a promise for an object with optional keys 'results' and 'count'.\nconst find = async (config, auth, className, restWhere, restOptions, clientSDK, context) => {\n  enforceRoleSecurity('find', className, auth, config);\n  return runFindTriggers(\n    config,\n    auth,\n    className,\n    restWhere,\n    restOptions,\n    clientSDK,\n    context,\n    { isGet: false }\n  );\n};\n\n// get is just like find but only queries an objectId.\nconst get = async (config, auth, className, objectId, restOptions, clientSDK, context) => {\n  enforceRoleSecurity('get', className, auth, config);\n  return runFindTriggers(\n    config,\n    auth,\n    className,\n    { objectId },\n    restOptions,\n    clientSDK,\n    context,\n    { isGet: true }\n  );\n};\n\n// Returns a promise that doesn't resolve to any useful value.\nfunction del(config, auth, className, objectId, context) {\n  if (typeof objectId !== 'string') {\n    throw new Parse.Error(Parse.Error.INVALID_JSON, 'bad objectId');\n  }\n\n  if (className === '_User' && auth.isUnauthenticated()) {\n    throw new Parse.Error(Parse.Error.SESSION_MISSING, 'Insufficient auth to delete user');\n  }\n\n  enforceRoleSecurity('delete', className, auth, config);\n\n  let inflatedObject;\n  let schemaController;\n\n  return Promise.resolve()\n    .then(async () => {\n      const hasTriggers = checkTriggers(className, config, ['beforeDelete', 'afterDelete']);\n      const hasLiveQuery = checkLiveQuery(className, config);\n      if (hasTriggers || hasLiveQuery || className == '_Session') {\n        const query = await RestQuery({\n          method: RestQuery.Method.get,\n          config,\n          auth,\n          className,\n          restWhere: { objectId },\n        });\n        return query.execute({ op: 'delete' }).then(response => {\n          if (response && response.results && response.results.length) {\n            const firstResult = response.results[0];\n            firstResult.className = className;\n            if (className === '_Session' && !auth.isMaster && !auth.isMaintenance) {\n              if (!auth.user || firstResult.user.objectId !== auth.user.id) {\n                throw createSanitizedError(Parse.Error.INVALID_SESSION_TOKEN, 'Invalid session token', config);\n              }\n            }\n            var cacheAdapter = config.cacheController;\n            cacheAdapter.user.del(firstResult.sessionToken);\n            inflatedObject = Parse.Object.fromJSON(firstResult);\n            return triggers.maybeRunTrigger(\n              triggers.Types.beforeDelete,\n              auth,\n              inflatedObject,\n              null,\n              config,\n              context\n            );\n          }\n          throw new Parse.Error(Parse.Error.OBJECT_NOT_FOUND, 'Object not found for delete.');\n        });\n      }\n      return Promise.resolve({});\n    })\n    .then(() => {\n      if (!auth.isMaster && !auth.isMaintenance) {\n        return auth.getUserRoles();\n      } else {\n        return;\n      }\n    })\n    .then(() => config.database.loadSchema())\n    .then(s => {\n      schemaController = s;\n      const options = {};\n      if (!auth.isMaster && !auth.isMaintenance) {\n        options.acl = ['*'];\n        if (auth.user) {\n          options.acl.push(auth.user.id);\n          options.acl = options.acl.concat(auth.userRoles);\n        }\n      }\n\n      return config.database.destroy(\n        className,\n        {\n          objectId: objectId,\n        },\n        options,\n        schemaController\n      );\n    })\n    .then(() => {\n      // Notify LiveQuery server if possible\n      const perms = schemaController.getClassLevelPermissions(className);\n      config.liveQueryController.onAfterDelete(className, inflatedObject, null, perms);\n      return triggers.maybeRunTrigger(\n        triggers.Types.afterDelete,\n        auth,\n        inflatedObject,\n        null,\n        config,\n        context\n      );\n    })\n    .catch(error => {\n      handleSessionMissingError(error, className, auth, config);\n    });\n}\n\n// Returns a promise for a {response, status, location} object.\nfunction create(config, auth, className, restObject, clientSDK, context) {\n  enforceRoleSecurity('create', className, auth, config);\n  var write = new RestWrite(config, auth, className, null, restObject, null, clientSDK, context);\n  return write.execute();\n}\n\n// Returns a promise that contains the fields of the update that the\n// REST API is supposed to return.\n// Usually, this is just updatedAt.\nfunction update(config, auth, className, restWhere, restObject, clientSDK, context) {\n  enforceRoleSecurity('update', className, auth, config);\n\n  return Promise.resolve()\n    .then(async () => {\n      const hasTriggers = checkTriggers(className, config, ['beforeSave', 'afterSave']);\n      const hasLiveQuery = checkLiveQuery(className, config);\n      if (hasTriggers || hasLiveQuery) {\n        // Do not use find, as it runs the before finds\n        // Use master auth when protectedFieldsTriggerExempt is true to bypass\n        // protectedFields filtering, so triggers see the full original object\n        const queryAuth = config.protectedFieldsTriggerExempt ? Auth.master(config) : auth;\n        const query = await RestQuery({\n          method: RestQuery.Method.get,\n          config,\n          auth: queryAuth,\n          className,\n          restWhere,\n          runAfterFind: false,\n          runBeforeFind: false,\n          context,\n        });\n        return query.execute({\n          op: 'update',\n        });\n      }\n      return Promise.resolve({});\n    })\n    .then(({ results }) => {\n      var originalRestObject;\n      if (results && results.length) {\n        originalRestObject = results[0];\n      }\n      return new RestWrite(\n        config,\n        auth,\n        className,\n        restWhere,\n        restObject,\n        originalRestObject,\n        clientSDK,\n        context,\n        'update'\n      ).execute();\n    })\n    .catch(error => {\n      handleSessionMissingError(error, className, auth, config);\n    });\n}\n\nfunction handleSessionMissingError(error, className, auth, config) {\n  // If we're trying to update a user without / with bad session token\n  if (\n    className === '_User' &&\n    error.code === Parse.Error.OBJECT_NOT_FOUND &&\n    !auth.isMaster &&\n    !auth.isMaintenance\n  ) {\n    throw createSanitizedError(Parse.Error.SESSION_MISSING, 'Insufficient auth.', config);\n  }\n  throw error;\n}\n\nmodule.exports = {\n  create,\n  del,\n  find,\n  get,\n  update,\n};\n"],"mappings":"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","ignoreList":[]}