import CoreManager from './CoreManager'; import encode from './encode'; import { continueWhile } from './promiseUtils'; import ParseError from './ParseError'; import ParseGeoPoint from './ParseGeoPoint'; import ParseObject from './ParseObject'; import OfflineQuery from './OfflineQuery'; import { DEFAULT_PIN } from './LocalDatastoreUtils'; import type LiveQuerySubscription from './LiveQuerySubscription'; import type { RequestOptions, BaseRequestOptions } from './RESTController'; import type { Pointer, BaseAttributes } from './ParseObject'; export interface BatchOptions extends BaseRequestOptions { batchSize?: number; json?: boolean; } export type WhereClause = Record; export interface QueryOptions extends BaseRequestOptions { json?: boolean; } export type FindOptions = QueryOptions; /** CountOptions - no json since count() returns a number, not objects */ export type CountOptions = BaseRequestOptions; export type GetOptions = QueryOptions; export type FirstOptions = QueryOptions; export interface AggregateOptions extends QueryOptions { rawValues?: boolean; rawFieldNames?: boolean; } export interface FullTextOptions { language?: string; caseSensitive?: boolean; diacriticSensitive?: boolean; } export interface QueryJSON { where: WhereClause; watch?: string; include?: string; excludeKeys?: string; keys?: string; limit?: number; skip?: number; order?: string; className?: string; count?: number; hint?: any; explain?: boolean; readPreference?: string; includeReadPreference?: string; subqueryReadPreference?: string; comment?: string; } /** * Converts a string into a regex that matches it. * Surrounding with \Q .. \E does this, we just need to escape any \E's in * the text separately. * * @param s * @private * @returns {string} */ function quote(s: string): string { return '\\Q' + s.replace('\\E', '\\E\\\\E\\Q') + '\\E'; } /** * Extracts the class name from queries. If not all queries have the same * class name an error will be thrown. * * @param queries * @private * @returns {string} */ function _getClassNameFromQueries(queries: ParseQuery[]): string | null { let className: string | null = null; queries.forEach(q => { if (!className) { className = q.className; } if (className !== q.className) { throw new Error('All queries must be for the same class.'); } }); return className; } /* * Handles pre-populating the result data of a query with select fields, * making sure that the data object contains keys for all objects that have * been requested with a select, so that our cached state updates correctly. */ function handleSelectResult(data: any, select: string[]) { const serverDataMask = {}; select.forEach(field => { const hasSubObjectSelect = field.indexOf('.') !== -1; if (!hasSubObjectSelect && !Object.hasOwn(data, field)) { // this field was selected, but is missing from the retrieved data data[field] = undefined; } else if (hasSubObjectSelect) { // this field references a sub-object, // so we need to walk down the path components const pathComponents = field.split('.'); let obj = data; let serverMask = serverDataMask; pathComponents.forEach((component, index, arr) => { // add keys if the expected data is missing if (obj && !Object.hasOwn(obj, component)) { obj[component] = undefined; } if (obj && typeof obj === 'object') { obj = obj[component]; } //add this path component to the server mask so we can fill it in later if needed if (index < arr.length - 1) { if (!serverMask[component]) { serverMask[component] = {}; } serverMask = serverMask[component]; } }); } }); if (Object.keys(serverDataMask).length > 0) { // When selecting from sub-objects, we don't want to blow away the missing // information that we may have retrieved before. We've already added any // missing selected keys to sub-objects, but we still need to add in the // data for any previously retrieved sub-objects that were not selected. const serverData = CoreManager.getObjectStateController().getServerData({ id: data.objectId, className: data.className, }); copyMissingDataWithMask(serverData, data, serverDataMask, false); } } function copyMissingDataWithMask(src, dest, mask, copyThisLevel) { //copy missing elements at this level if (copyThisLevel) { for (const key in src) { if (Object.hasOwn(src, key) && !Object.hasOwn(dest, key)) { dest[key] = src[key]; } } } for (const key in mask) { if (dest[key] !== undefined && dest[key] !== null && src !== undefined && src !== null) { //traverse into objects as needed copyMissingDataWithMask(src[key], dest[key], mask[key], true); } } } function handleOfflineSort(a, b, sorts) { let order = sorts[0]; const operator = order.slice(0, 1); const isDescending = operator === '-'; if (isDescending) { order = order.substring(1); } if (order === '_created_at') { order = 'createdAt'; } if (order === '_updated_at') { order = 'updatedAt'; } if (!/^[A-Za-z][0-9A-Za-z_]*$/.test(order) || order === 'password') { throw new ParseError(ParseError.INVALID_KEY_NAME, `Invalid Key: ${order}`); } const field1 = a.get(order); const field2 = b.get(order); if (field1 < field2) { return isDescending ? 1 : -1; } if (field1 > field2) { return isDescending ? -1 : 1; } if (sorts.length > 1) { const remainingSorts = sorts.slice(1); return handleOfflineSort(a, b, remainingSorts); } return 0; } /** * Creates a new parse Parse.Query for the given Parse.Object subclass. * *

Parse.Query defines a query that is used to fetch Parse.Objects. The * most common use case is finding all objects that match a query through the * find method. for example, this sample code fetches all objects * of class myclass. it calls a different function depending on * whether the fetch succeeded or not. * *

 * var query = new Parse.Query(myclass);
 * query.find().then((results) => {
 *   // results is an array of parse.object.
 * }).catch((error) =>  {
 *  // error is an instance of parse.error.
 * });

* *

a Parse.Query can also be used to retrieve a single object whose id is * known, through the get method. for example, this sample code fetches an * object of class myclass and id myid. it calls a * different function depending on whether the fetch succeeded or not. * *

 * var query = new Parse.Query(myclass);
 * query.get(myid).then((object) => {
 *     // object is an instance of parse.object.
 * }).catch((error) =>  {
 *  // error is an instance of parse.error.
 * });

* *

a Parse.Query can also be used to count the number of objects that match * the query without retrieving all of those objects. for example, this * sample code counts the number of objects of the class myclass *

 * var query = new Parse.Query(myclass);
 * query.count().then((number) => {
 *     // there are number instances of myclass.
 * }).catch((error) => {
 *     // error is an instance of Parse.Error.
 * });

* * @alias Parse.Query */ class ParseQuery { /** * @property {string} className */ className: string; _where: any; _watch: string[]; _include: string[]; _exclude: string[]; _select: string[]; _limit: number; _skip: number; _count: boolean; _order: string[]; _readPreference: string | null; _includeReadPreference: string | null; _subqueryReadPreference: string | null; _queriesLocalDatastore: boolean; _localDatastorePinName: any; _extraOptions: Record; _hint: any; _explain: boolean; _xhrRequest: any; _comment: string; /** * @param {(string | Parse.Object)} objectClass An instance of a subclass of Parse.Object, or a Parse className string. */ constructor(objectClass: string | (new (...args: any[]) => T | ParseObject)) { if (typeof objectClass === 'string') { if (objectClass === 'User' && CoreManager.get('PERFORM_USER_REWRITE')) { this.className = '_User'; } else { this.className = objectClass; } } else if (objectClass instanceof ParseObject) { this.className = objectClass.className; } else if (typeof objectClass === 'function') { const objClass = objectClass as any; if (typeof objClass.className === 'string') { this.className = objClass.className; } else { const obj = new objClass(); this.className = obj.className; } } else { throw new TypeError('A ParseQuery must be constructed with a ParseObject or class name.'); } this._where = {}; this._watch = []; this._include = []; this._exclude = []; this._count = false; this._limit = -1; // negative limit is not sent in the server request this._skip = 0; this._readPreference = null; this._includeReadPreference = null; this._subqueryReadPreference = null; this._queriesLocalDatastore = false; this._localDatastorePinName = null; this._extraOptions = {}; this._xhrRequest = { task: null, onchange: () => {}, }; this._comment = null; } /** * Adds constraint that at least one of the passed in queries matches. * * @param {Array} queries * @returns {Parse.Query} Returns the query, so you can chain this call. */ _orQuery(queries: ParseQuery[]): this { const queryJSON = queries.map(q => { return q.toJSON().where; }); this._where.$or = queryJSON; return this; } /** * Adds constraint that all of the passed in queries match. * * @param {Array} queries * @returns {Parse.Query} Returns the query, so you can chain this call. */ _andQuery(queries: ParseQuery[]): this { const queryJSON = queries.map(q => { return q.toJSON().where; }); this._where.$and = queryJSON; return this; } /** * Adds constraint that none of the passed in queries match. * * @param {Array} queries * @returns {Parse.Query} Returns the query, so you can chain this call. */ _norQuery(queries: ParseQuery[]): this { const queryJSON = queries.map(q => { return q.toJSON().where; }); this._where.$nor = queryJSON; return this; } /** * Helper for condition queries * * @param key * @param condition * @param value * @returns {Parse.Query} */ _addCondition( key: K, condition: string, value: any ): this { if (!this._where[key] || typeof this._where[key] === 'string') { this._where[key] = {}; } this._where[key][condition] = encode(value, false, true); return this; } /** * Converts string for regular expression at the beginning * * @param string * @returns {string} */ _regexStartWith(string: string): string { return '^' + quote(string); } async _handleOfflineQuery(params: QueryJSON) { OfflineQuery.validateQuery(this); const localDatastore = CoreManager.getLocalDatastore(); const objects = await localDatastore._serializeObjectsFromPinName(this._localDatastorePinName); let results = objects .map((json, _index, arr) => { const object = ParseObject.fromJSON(json, false); if (json._localId && !json.objectId) { object._localId = json._localId; } if (!OfflineQuery.matchesQuery(this.className, object, arr, this)) { return null; } return object; }) .filter(object => object !== null); if (params.keys) { let keys = params.keys.split(','); const alwaysSelectedKeys = ['className', 'objectId', 'createdAt', 'updatedAt', 'ACL']; keys = keys.concat(alwaysSelectedKeys); results = results.map(object => { const json = object._toFullJSON(); Object.keys(json).forEach(key => { if (!keys.includes(key)) { delete json[key]; } }); return ParseObject.fromJSON(json, false); }); } if (params.order) { const sorts = params.order.split(','); results.sort((a, b) => { return handleOfflineSort(a, b, sorts); }); } let count; // count total before applying limit/skip if (params.count) { count = results.length; // total count from response } if (params.skip) { if (params.skip >= results.length) { results = []; } else { results = results.splice(params.skip, results.length); } } let limit = results.length; if (params.limit !== 0 && params.limit < results.length) { limit = params.limit; } results = results.splice(0, limit); if (typeof count === 'number') { return { results, count }; } return results; } /** * Returns a JSON representation of this query. * * @returns {object} The JSON representation of the query. */ toJSON(): QueryJSON { const params: QueryJSON = { where: this._where, }; if (this._watch.length) { params.watch = this._watch.join(','); } if (this._include.length) { params.include = this._include.join(','); } if (this._exclude.length) { params.excludeKeys = this._exclude.join(','); } if (this._select) { params.keys = this._select.join(','); } if (this._count) { params.count = 1; } if (this._limit >= 0) { params.limit = this._limit; } if (this._skip > 0) { params.skip = this._skip; } if (this._order) { params.order = this._order.join(','); } if (this._readPreference) { params.readPreference = this._readPreference; } if (this._includeReadPreference) { params.includeReadPreference = this._includeReadPreference; } if (this._subqueryReadPreference) { params.subqueryReadPreference = this._subqueryReadPreference; } if (this._hint) { params.hint = this._hint; } if (this._explain) { params.explain = true; } if (this._comment) { params.comment = this._comment; } for (const key in this._extraOptions) { params[key] = this._extraOptions[key]; } return params; } /** * Return a query with conditions from json, can be useful to send query from server side to client * Not static, all query conditions was set before calling this method will be deleted. * For example on the server side we have * var query = new Parse.Query("className"); * query.equalTo(key: value); * query.limit(100); * ... (others queries) * Create JSON representation of Query Object * var jsonFromServer = query.fromJSON(); * * On client side getting query: * var query = new Parse.Query("className"); * query.fromJSON(jsonFromServer); * * and continue to query... * query.skip(100).find().then(...); * * @param {QueryJSON} json from Parse.Query.toJSON() method * @returns {Parse.Query} Returns the query, so you can chain this call. */ withJSON(json: QueryJSON): this { if (json.where) { this._where = json.where; } if (json.watch) { this._watch = json.watch.split(','); } if (json.include) { this._include = json.include.split(','); } if (json.keys) { this._select = json.keys.split(','); } if (json.excludeKeys) { this._exclude = json.excludeKeys.split(','); } if (json.count) { this._count = json.count === 1; } if (json.limit) { this._limit = json.limit; } if (json.skip) { this._skip = json.skip; } if (json.order) { this._order = json.order.split(','); } if (json.readPreference) { this._readPreference = json.readPreference; } if (json.includeReadPreference) { this._includeReadPreference = json.includeReadPreference; } if (json.subqueryReadPreference) { this._subqueryReadPreference = json.subqueryReadPreference; } if (json.hint) { this._hint = json.hint; } if (json.explain) { this._explain = !!json.explain; } if (json.comment) { this._comment = json.comment; } for (const key in json) { if (Object.hasOwn(json, key)) { if ( [ 'where', 'include', 'keys', 'count', 'limit', 'skip', 'order', 'readPreference', 'includeReadPreference', 'subqueryReadPreference', 'hint', 'explain', 'comment', ].indexOf(key) === -1 ) { this._extraOptions[key] = json[key]; } } } return this; } /** * Static method to restore Parse.Query by json representation * Internally calling Parse.Query.withJSON * * @param {string} className * @param {QueryJSON} json from Parse.Query.toJSON() method * @returns {Parse.Query} new created query */ static fromJSON(className: string, json: QueryJSON): ParseQuery { const query = new ParseQuery(className); return query.withJSON(json); } /** * Constructs a Parse.Object whose id is already known by fetching data from * the server. Unlike the first method, it never returns undefined. * * @param {string} objectId The id of the object to be fetched. * @param {object} options * Valid options are:
    *
  • useMasterKey: In Cloud Code and Node only, causes the Master Key to * be used for this request. *
  • sessionToken: A valid session token, used for making a request on * behalf of a specific user. *
  • context: A dictionary that is accessible in Cloud Code `beforeFind` trigger. *
  • json: Return raw json without converting to Parse.Object *
* @returns {Promise} A promise that is resolved with the result when * the query completes. */ get(objectId: string, options?: GetOptions): Promise { this.equalTo('objectId', objectId as any); const firstOptions = ParseObject._getRequestOptions(options); return this.first(firstOptions).then(response => { if (response) { return response; } const errorObject = new ParseError(ParseError.OBJECT_NOT_FOUND, 'Object not found.'); return Promise.reject(errorObject); }); } /** * Retrieves a list of ParseObjects that satisfy this query. * * @param {object} options Valid options * are:
    *
  • useMasterKey: In Cloud Code and Node only, causes the Master Key to * be used for this request. *
  • sessionToken: A valid session token, used for making a request on * behalf of a specific user. *
  • context: A dictionary that is accessible in Cloud Code `beforeFind` trigger. *
  • json: Return raw json without converting to Parse.Object *
* @returns {Promise} A promise that is resolved with the results when * the query completes. */ find(options?: FindOptions): Promise { const findOptions = ParseObject._getRequestOptions(options); this._setRequestTask(findOptions); const controller = CoreManager.getQueryController(); const select = this._select; if (this._queriesLocalDatastore) { return this._handleOfflineQuery(this.toJSON()); } return controller.find(this.className, this.toJSON(), findOptions).then(response => { // Return generic object when explain is used if (this._explain) { return response.results; } const results = response.results?.map(data => { // In cases of relations, the server may send back a className // on the top level of the payload const override = response.className || this.className; if (!data.className) { data.className = override; } // Make sure the data object contains keys for all objects that // have been requested with a select, so that our cached state // updates correctly. if (select) { handleSelectResult(data, select); } if (findOptions.json) { return data; } else { return ParseObject.fromJSON(data, !select); } }); const count = response.count; if (typeof count === 'number') { return { results, count } as any; } else { return results; } }); } /** * Retrieves a complete list of ParseObjects that satisfy this query. * Using `eachBatch` under the hood to fetch all the valid objects. * * @param {object} options Valid options are:
    *
  • batchSize: How many objects to yield in each batch (default: 100) *
  • useMasterKey: In Cloud Code and Node only, causes the Master Key to * be used for this request. *
  • sessionToken: A valid session token, used for making a request on * behalf of a specific user. *
  • json: Return raw JSON without converting to Parse.Object. *
* @returns {Promise} A promise that is resolved with the results when * the query completes. */ async findAll(options?: BatchOptions): Promise { let result: T[] = []; await this.eachBatch((objects: T[]) => { result = [...result, ...objects]; }, options); return result; } /** * Counts the number of objects that match this query. * * @param {object} options * @param {boolean} [options.useMasterKey] * @param {string} [options.sessionToken] * Valid options are:
    *
  • useMasterKey: In Cloud Code and Node only, causes the Master Key to * be used for this request. *
  • sessionToken: A valid session token, used for making a request on * behalf of a specific user. *
* @returns {Promise} A promise that is resolved with the count when * the query completes. */ count(options?: CountOptions): Promise { options = options || {}; const findOptions = ParseObject._getRequestOptions(options); this._setRequestTask(findOptions); const controller = CoreManager.getQueryController(); const params = this.toJSON(); params.limit = 0; params.count = 1; return controller.find(this.className, params, findOptions).then(result => { return result.count; }); } /** * Executes a distinct query and returns unique values * * @param {string} key A field to find distinct values * @returns {Promise} A promise that is resolved with the query completes. */ distinct(key: K): Promise { const distinctOptions = { useMasterKey: true }; this._setRequestTask(distinctOptions); const params = { distinct: key, where: this._where, hint: this._hint, }; const controller = CoreManager.getQueryController(); return controller.aggregate(this.className, params, distinctOptions).then(results => { return results.results!; }); } /** * Executes an aggregate query and returns aggregate results * * @param {(Array|object)} pipeline Array or Object of stages to process query * @param {object} options Valid options are:
    *
  • useMasterKey: In Cloud Code and Node only, causes the Master Key to * be used for this request. Defaults to `true` when not provided, for * backward compatibility. *
  • sessionToken: A valid session token, used for making a request on * behalf of a specific user. *
  • context: A dictionary that is accessible in Cloud Code triggers. *
  • rawValues: When `true`, disables schema-based value transformation * in the pipeline. Pipeline values are interpreted using MongoDB * Extended JSON (EJSON), so typed values such as `{ $date: '...' }`, * `{ $oid: '...' }`, `{ $numberDecimal: '...' }`, etc. are converted * to their corresponding BSON types by the server. Requires Parse * Server 9.9.0+ *
  • rawFieldNames: When `true`, disables automatic field-name * transformation (e.g. `createdAt` → `_created_at`) in the pipeline. * Users write native MongoDB field names directly. Requires Parse * Server 9.9.0+ *
* @returns {Promise} A promise that is resolved with the query completes. */ aggregate(pipeline: any, options?: AggregateOptions): Promise { if (!Array.isArray(pipeline) && typeof pipeline !== 'object') { throw new Error('Invalid pipeline must be Array or Object'); } if (Object.keys(this._where || {}).length) { if (!Array.isArray(pipeline)) { pipeline = [pipeline]; } pipeline.unshift({ $match: this._where }); } const params: Record = { pipeline, hint: this._hint, explain: this._explain, readPreference: this._readPreference, }; if (options?.rawValues !== undefined) { params.rawValues = options.rawValues; } if (options?.rawFieldNames !== undefined) { params.rawFieldNames = options.rawFieldNames; } const aggregateOptions = ParseObject._getRequestOptions(options); if (aggregateOptions.useMasterKey === undefined) { aggregateOptions.useMasterKey = true; } this._setRequestTask(aggregateOptions); const controller = CoreManager.getQueryController(); return controller.aggregate(this.className, params, aggregateOptions).then(results => { return results.results!; }); } /** * Retrieves at most one Parse.Object that satisfies this query. * * Returns the object if there is one, otherwise undefined. * * @param {object} options Valid options are:
    *
  • useMasterKey: In Cloud Code and Node only, causes the Master Key to * be used for this request. *
  • sessionToken: A valid session token, used for making a request on * behalf of a specific user. *
  • context: A dictionary that is accessible in Cloud Code `beforeFind` trigger. *
  • json: Return raw json without converting to Parse.Object *
* @returns {Promise} A promise that is resolved with the object when * the query completes. */ first(options: FirstOptions = {}): Promise { const findOptions = ParseObject._getRequestOptions(options); this._setRequestTask(findOptions); const controller = CoreManager.getQueryController(); const params = this.toJSON(); params.limit = 1; const select = this._select; if (this._queriesLocalDatastore) { return this._handleOfflineQuery(params).then(objects => { if (!objects[0]) { return undefined; } return objects[0]; }); } return controller.find(this.className, params, findOptions).then(response => { const objects = response.results!; if (!objects[0]) { return undefined; } if (!objects[0].className) { objects[0].className = this.className; } // Make sure the data object contains keys for all objects that // have been requested with a select, so that our cached state // updates correctly. if (select) { handleSelectResult(objects[0], select); } if (findOptions.json) { return objects[0] as T; } else { return ParseObject.fromJSON(objects[0], !select) as T; } }); } /** * Iterates over objects matching a query, calling a callback for each batch. * If the callback returns a promise, the iteration will not continue until * that promise has been fulfilled. If the callback returns a rejected * promise, then iteration will stop with that error. The items are processed * in an unspecified order. The query may not have any sort order, and may * not use limit or skip. * * @param {Function} callback Callback that will be called with each result * of the query. * @param {object} options Valid options are:
    *
  • batchSize: How many objects to yield in each batch (default: 100) *
  • useMasterKey: In Cloud Code and Node only, causes the Master Key to * be used for this request. *
  • sessionToken: A valid session token, used for making a request on * behalf of a specific user. *
  • context: A dictionary that is accessible in Cloud Code `beforeFind` trigger. *
* @returns {Promise} A promise that will be fulfilled once the * iteration has completed. */ eachBatch( callback: (objs: T[]) => PromiseLike | void, options?: BatchOptions ): Promise { options = options || {}; if (this._order || this._skip || this._limit >= 0) { const error = 'Cannot iterate on a query with sort, skip, or limit.'; return Promise.reject(error); } const query = ParseQuery.fromJSON(this.className, this.toJSON()); query.ascending('objectId'); query._limit = options.batchSize || 100; const findOptions = ParseObject._getRequestOptions(options); let finished = false; let previousResults: T[] = []; return continueWhile( () => { return !finished; }, async () => { const [results] = await Promise.all([ query.find(findOptions), Promise.resolve(previousResults.length > 0 && callback(previousResults)), ]); if (results.length >= query._limit) { if (findOptions.json) { query.greaterThan('objectId', (results[results.length - 1] as any).objectId); } else { query.greaterThan('objectId', results[results.length - 1].id); } previousResults = results as T[]; } else if (results.length > 0) { await Promise.resolve(callback(results as T[])); finished = true; } else { finished = true; } } ); } /** * Iterates over each result of a query, calling a callback for each one. If * the callback returns a promise, the iteration will not continue until * that promise has been fulfilled. If the callback returns a rejected * promise, then iteration will stop with that error. The items are * processed in an unspecified order. The query may not have any sort order, * and may not use limit or skip. * * @param {Function} callback Callback that will be called with each result * of the query. * @param {object} options Valid options are:
    *
  • useMasterKey: In Cloud Code and Node only, causes the Master Key to * be used for this request. *
  • sessionToken: A valid session token, used for making a request on * behalf of a specific user. *
  • json: Return raw json without converting to Parse.Object *
* @returns {Promise} A promise that will be fulfilled once the * iteration has completed. */ each(callback: (obj: T) => PromiseLike | void, options?: BatchOptions): Promise { return this.eachBatch(results => { let callbacksDone = Promise.resolve(); results.forEach((result: T) => { callbacksDone = callbacksDone.then(() => { return callback(result); }); }); return callbacksDone; }, options); } /** * Adds a hint to force index selection. (https://docs.mongodb.com/manual/reference/operator/meta/hint/) * * @param {(string|object)} value String or Object of index that should be used when executing query * @returns {Parse.Query} Returns the query, so you can chain this call. */ hint(value: any): this { if (typeof value === 'undefined') { delete this._hint; } this._hint = value; return this; } /** * Investigates the query execution plan. Useful for optimizing queries. (https://docs.mongodb.com/manual/reference/operator/meta/explain/) * * @param {boolean} explain Used to toggle the information on the query plan. * @returns {Parse.Query} Returns the query, so you can chain this call. */ explain(explain = true): this { if (typeof explain !== 'boolean') { throw new Error('You can only set explain to a boolean value'); } this._explain = explain; return this; } /** * Iterates over each result of a query, calling a callback for each one. If * the callback returns a promise, the iteration will not continue until * that promise has been fulfilled. If the callback returns a rejected * promise, then iteration will stop with that error. The items are * processed in an unspecified order. The query may not have any sort order, * and may not use limit or skip. * * @param {Function} callback Callback
    *
  • currentObject: The current Parse.Object being processed in the array.
  • *
  • index: The index of the current Parse.Object being processed in the array.
  • *
  • query: The query map was called upon.
  • *
* @param {object} options Valid options are:
    *
  • useMasterKey: In Cloud Code and Node only, causes the Master Key to * be used for this request. *
  • sessionToken: A valid session token, used for making a request on * behalf of a specific user. *
* @returns {Promise} A promise that will be fulfilled once the * iteration has completed. */ async map( callback: (currentObject: ParseObject, index: number, query: ParseQuery) => any, options?: BatchOptions ): Promise { const array: ParseObject[] = []; let index = 0; await this.each(object => { return Promise.resolve(callback(object, index, this)).then(result => { array.push(result); index += 1; }); }, options); return array; } /** * Iterates over each result of a query, calling a callback for each one. If * the callback returns a promise, the iteration will not continue until * that promise has been fulfilled. If the callback returns a rejected * promise, then iteration will stop with that error. The items are * processed in an unspecified order. The query may not have any sort order, * and may not use limit or skip. * * @param {Function} callback Callback
    *
  • accumulator: The accumulator accumulates the callback's return values. It is the accumulated value previously returned in the last invocation of the callback.
  • *
  • currentObject: The current Parse.Object being processed in the array.
  • *
  • index: The index of the current Parse.Object being processed in the array.
  • *
* @param {*} initialValue A value to use as the first argument to the first call of the callback. If no initialValue is supplied, the first object in the query will be used and skipped. * @param {object} options Valid options are:
    *
  • useMasterKey: In Cloud Code and Node only, causes the Master Key to * be used for this request. *
  • sessionToken: A valid session token, used for making a request on * behalf of a specific user. *
* @returns {Promise} A promise that will be fulfilled once the * iteration has completed. */ async reduce( callback: (accumulator: any, currentObject: ParseObject, index: number) => any, initialValue: any, options?: BatchOptions ): Promise { let accumulator = initialValue; let index = 0; await this.each(object => { // If no initial value was given, we take the first object from the query // as the initial value and don't call the callback with it. if (index === 0 && initialValue === undefined) { accumulator = object; index += 1; return; } return Promise.resolve(callback(accumulator, object, index)).then(result => { accumulator = result; index += 1; }); }, options); if (index === 0 && initialValue === undefined) { // Match Array.reduce behavior: "Calling reduce() on an empty array // without an initialValue will throw a TypeError". throw new TypeError('Reducing empty query result set with no initial value'); } return accumulator; } /** * Iterates over each result of a query, calling a callback for each one. If * the callback returns a promise, the iteration will not continue until * that promise has been fulfilled. If the callback returns a rejected * promise, then iteration will stop with that error. The items are * processed in an unspecified order. The query may not have any sort order, * and may not use limit or skip. * * @param {Function} callback Callback
    *
  • currentObject: The current Parse.Object being processed in the array.
  • *
  • index: The index of the current Parse.Object being processed in the array.
  • *
  • query: The query filter was called upon.
  • *
* @param {object} options Valid options are:
    *
  • useMasterKey: In Cloud Code and Node only, causes the Master Key to * be used for this request. *
  • sessionToken: A valid session token, used for making a request on * behalf of a specific user. *
* @returns {Promise} A promise that will be fulfilled once the * iteration has completed. */ async filter( callback: (currentObject: ParseObject, index: number, query: ParseQuery) => boolean, options?: BatchOptions ): Promise { const array: ParseObject[] = []; let index = 0; await this.each(object => { return Promise.resolve(callback(object, index, this)).then(flag => { if (flag) { array.push(object); } index += 1; }); }, options); return array; } /* Query Conditions */ /** * Adds a constraint to the query that requires a particular key's value to * be equal to the provided value. * * @param {string} key The key to check. * @param value The value that the Parse.Object must contain. * @returns {Parse.Query} Returns the query, so you can chain this call. */ equalTo( key: K, value: | T['attributes'][K] | (NonNullable extends ParseObject ? Pointer : NonNullable extends (infer E)[] ? E : never) ): this { if (key && typeof key === 'object') { Object.entries(key).forEach(([k, val]) => this.equalTo(k, val as any)); return this; } if (typeof value === 'undefined') { return this.doesNotExist(key as string); } this._where[key as string] = encode(value, false, true); return this; } /** * Adds a constraint to the query that requires a particular key's value to * be not equal to the provided value. * * @param {string} key The key to check. * @param value The value that must not be equalled. * @returns {Parse.Query} Returns the query, so you can chain this call. */ notEqualTo( key: K, value: | T['attributes'][K] | (NonNullable extends ParseObject ? Pointer : NonNullable extends (infer E)[] ? E : never) ): this { if (key && typeof key === 'object') { Object.entries(key).forEach(([k, val]) => this.notEqualTo(k, val as any)); return this; } return this._addCondition(key, '$ne', value); } /** * Adds a constraint to the query that requires a particular key's value to * be less than the provided value. * * @param {string} key The key to check. * @param value The value that provides an upper bound. * @returns {Parse.Query} Returns the query, so you can chain this call. */ lessThan( key: K, value: T['attributes'][K] ): this { return this._addCondition(key, '$lt', value); } /** * Adds a constraint to the query that requires a particular key's value to * be greater than the provided value. * * @param {string} key The key to check. * @param value The value that provides an lower bound. * @returns {Parse.Query} Returns the query, so you can chain this call. */ greaterThan( key: K, value: T['attributes'][K] ): this { return this._addCondition(key, '$gt', value); } /** * Adds a constraint to the query that requires a particular key's value to * be less than or equal to the provided value. * * @param {string} key The key to check. * @param value The value that provides an upper bound. * @returns {Parse.Query} Returns the query, so you can chain this call. */ lessThanOrEqualTo( key: K, value: T['attributes'][K] ): this { return this._addCondition(key, '$lte', value); } /** * Adds a constraint to the query that requires a particular key's value to * be greater than or equal to the provided value. * * @param {string} key The key to check. * @param {*} value The value that provides an lower bound. * @returns {Parse.Query} Returns the query, so you can chain this call. */ greaterThanOrEqualTo( key: K, value: T['attributes'][K] ): this { return this._addCondition(key, '$gte', value); } /** * Adds a constraint to the query that requires a particular key's value to * be contained in the provided list of values. * * @param {string} key The key to check. * @param {Array<*>} values The values that will match. * @returns {Parse.Query} Returns the query, so you can chain this call. */ containedIn( key: K, values: (T['attributes'][K] | (T['attributes'][K] extends ParseObject ? string : never))[] ): this { return this._addCondition(key, '$in', values); } /** * Adds a constraint to the query that requires a particular key's value to * not be contained in the provided list of values. * * @param {string} key The key to check. * @param {Array<*>} values The values that will not match. * @returns {Parse.Query} Returns the query, so you can chain this call. */ notContainedIn( key: K, values: T['attributes'][K][] ): this { return this._addCondition(key, '$nin', values); } /** * Adds a constraint to the query that requires a particular key's value to * be contained by the provided list of values. Get objects where all array elements match. * * @param {string} key The key to check. * @param {Array} values The values that will match. * @returns {Parse.Query} Returns the query, so you can chain this call. */ containedBy( key: K, values: (T['attributes'][K] | (T['attributes'][K] extends ParseObject ? string : never))[] ): this { return this._addCondition(key, '$containedBy', values); } /** * Adds a constraint to the query that requires a particular key's value to * contain each one of the provided list of values. * * @param {string} key The key to check. This key's value must be an array. * @param {Array} values The values that will match. * @returns {Parse.Query} Returns the query, so you can chain this call. */ containsAll(key: K, values: any[]): this { return this._addCondition(key, '$all', values); } /** * Adds a constraint to the query that requires a particular key's value to * contain each one of the provided list of values starting with given strings. * * @param {string} key The key to check. This key's value must be an array. * @param {Array} values The string values that will match as starting string. * @returns {Parse.Query} Returns the query, so you can chain this call. */ containsAllStartingWith( key: K, values: any[] ): this { if (!Array.isArray(values)) { values = [values]; } const regexObject = values.map(value => { return { $regex: this._regexStartWith(value) }; }); return this.containsAll(key, regexObject); } /** * Adds a constraint for finding objects that contain the given key. * * @param {string} key The key that should exist. * @returns {Parse.Query} Returns the query, so you can chain this call. */ exists(key: K): this { return this._addCondition(key, '$exists', true); } /** * Adds a constraint for finding objects that do not contain a given key. * * @param {string} key The key that should not exist * @returns {Parse.Query} Returns the query, so you can chain this call. */ doesNotExist(key: K): this { return this._addCondition(key, '$exists', false); } /** * Adds a regular expression constraint for finding string values that match * the provided regular expression. * This may be slow for large datasets. * * @param {string} key The key that the string to match is stored in. * @param {RegExp | string} regex The regular expression pattern to match. * @param {string} modifiers The regular expression mode. * @returns {Parse.Query} Returns the query, so you can chain this call. */ matches( key: K, regex: RegExp | string, modifiers?: string ): this { this._addCondition(key, '$regex', regex); if (!modifiers) { modifiers = ''; } if (typeof regex !== 'string') { if (regex.ignoreCase) { modifiers += 'i'; } if (regex.multiline) { modifiers += 'm'; } } if (modifiers.length) { this._addCondition(key, '$options', modifiers); } return this; } /** * Adds a constraint that requires that a key's value matches a Parse.Query * constraint. * * @param {string} key The key that the contains the object to match the * query. * @param {Parse.Query} query The query that should match. * @returns {Parse.Query} Returns the query, so you can chain this call. */ matchesQuery( key: K, query: ParseQuery ): this { const queryJSON = query.toJSON(); queryJSON.className = query.className; return this._addCondition(key, '$inQuery', queryJSON); } /** * Adds a constraint that requires that a key's value not matches a * Parse.Query constraint. * * @param {string} key The key that the contains the object to match the * query. * @param {Parse.Query} query The query that should not match. * @returns {Parse.Query} Returns the query, so you can chain this call. */ doesNotMatchQuery( key: K, query: ParseQuery ): this { const queryJSON = query.toJSON(); queryJSON.className = query.className; return this._addCondition(key, '$notInQuery', queryJSON); } /** * Adds a constraint that requires that a key's value matches a value in * an object returned by a different Parse.Query. * * @param {string} key The key that contains the value that is being * matched. * @param {string} queryKey The key in the objects returned by the query to * match against. * @param {Parse.Query} query The query to run. * @returns {Parse.Query} Returns the query, so you can chain this call. */ matchesKeyInQuery< U extends ParseObject, K extends keyof T['attributes'], X extends Extract, >(key: K, queryKey: X, query: ParseQuery): this { const queryJSON = query.toJSON(); queryJSON.className = query.className; return this._addCondition(key, '$select', { key: queryKey, query: queryJSON, }); } /** * Adds a constraint that requires that a key's value not match a value in * an object returned by a different Parse.Query. * * @param {string} key The key that contains the value that is being * excluded. * @param {string} queryKey The key in the objects returned by the query to * match against. * @param {Parse.Query} query The query to run. * @returns {Parse.Query} Returns the query, so you can chain this call. */ doesNotMatchKeyInQuery< U extends ParseObject, K extends keyof T['attributes'] | keyof BaseAttributes, X extends Extract, >(key: K, queryKey: X, query: ParseQuery): this { const queryJSON = query.toJSON(); queryJSON.className = query.className; return this._addCondition(key, '$dontSelect', { key: queryKey, query: queryJSON, }); } /** * Adds a constraint for finding string values that contain a provided * string. This may be slow for large datasets. * * @param {string} key The key that the string to match is stored in. * @param {string} substring The substring that the value must contain. * @returns {Parse.Query} Returns the query, so you can chain this call. */ contains( key: K, substring: string ): this { if (typeof substring !== 'string') { throw new Error('The value being searched for must be a string.'); } return this._addCondition(key, '$regex', quote(substring)); } /** * Adds a constraint for finding string values that contain a provided * string. This may be slow for large datasets. Requires Parse-Server > 2.5.0 * * In order to sort you must use select and ascending ($score is required) *
   *   query.fullText('field', 'term');
   *   query.ascending('$score');
   *   query.select('$score');
   *  
* * To retrieve the weight / rank *
   *   object->get('score');
   *  
* * You can define optionals by providing an object as a third parameter *
   *   query.fullText('field', 'term', { language: 'es', diacriticSensitive: true });
   *  
* * @param {string} key The key that the string to match is stored in. * @param {string} value The string to search * @param {object} options (Optional) * @param {string} options.language The language that determines the list of stop words for the search and the rules for the stemmer and tokenizer. * @param {boolean} options.caseSensitive A boolean flag to enable or disable case sensitive search. * @param {boolean} options.diacriticSensitive A boolean flag to enable or disable diacritic sensitive search. * @returns {Parse.Query} Returns the query, so you can chain this call. */ fullText( key: K, value: string, options?: FullTextOptions ): this { options = options || {}; if (!key) { throw new Error('A key is required.'); } if (!value) { throw new Error('A search term is required'); } if (typeof value !== 'string') { throw new Error('The value being searched for must be a string.'); } const fullOptions: { $term?: string; $language?: string; $caseSensitive?: boolean; $diacriticSensitive?: boolean; } = {}; fullOptions.$term = value; for (const option in options) { switch (option) { case 'language': fullOptions.$language = options[option]; break; case 'caseSensitive': fullOptions.$caseSensitive = options[option]; break; case 'diacriticSensitive': fullOptions.$diacriticSensitive = options[option]; break; default: throw new Error(`Unknown option: ${option}`); } } return this._addCondition(key, '$text', { $search: fullOptions }); } /** * Method to sort the full text search by text score * * @returns {Parse.Query} Returns the query, so you can chain this call. */ sortByTextScore() { this.ascending('$score'); this.select(['$score'] as any); return this; } /** * Adds a constraint for finding string values that start with a provided * string. This query will use the backend index, so it will be fast even * for large datasets. * * @param {string} key The key that the string to match is stored in. * @param {string} prefix The substring that the value must start with. * @param {string} modifiers The regular expression mode. * @returns {Parse.Query} Returns the query, so you can chain this call. */ startsWith( key: K, prefix: string, modifiers?: string ): this { if (typeof prefix !== 'string') { throw new Error('The value being searched for must be a string.'); } return this.matches(key, this._regexStartWith(prefix), modifiers); } /** * Adds a constraint for finding string values that end with a provided * string. This will be slow for large datasets. * * @param {string} key The key that the string to match is stored in. * @param {string} suffix The substring that the value must end with. * @param {string} modifiers The regular expression mode. * @returns {Parse.Query} Returns the query, so you can chain this call. */ endsWith( key: K, suffix: string, modifiers?: string ): this { if (typeof suffix !== 'string') { throw new Error('The value being searched for must be a string.'); } return this.matches(key, quote(suffix) + '$', modifiers); } /** * Adds a proximity based constraint for finding objects with key point * values near the point given. * * @param {string} key The key that the Parse.GeoPoint is stored in. * @param {Parse.GeoPoint} point The reference Parse.GeoPoint that is used. * @returns {Parse.Query} Returns the query, so you can chain this call. */ near(key: K, point: ParseGeoPoint): this { if (!(point instanceof ParseGeoPoint)) { // Try to cast it as a GeoPoint point = new ParseGeoPoint(point); } return this._addCondition(key, '$nearSphere', point); } /** * Adds a proximity based constraint for finding objects with key point * values near the point given and within the maximum distance given. * * @param {string} key The key that the Parse.GeoPoint is stored in. * @param {Parse.GeoPoint} point The reference Parse.GeoPoint that is used. * @param {number} maxDistance Maximum distance (in radians) of results to return. * @param {boolean} sorted A Bool value that is true if results should be * sorted by distance ascending, false is no sorting is required, * defaults to true. * @returns {Parse.Query} Returns the query, so you can chain this call. */ withinRadians( key: K, point: ParseGeoPoint, maxDistance: number, sorted?: boolean ): this { if (sorted || sorted === undefined) { this.near(key, point); return this._addCondition(key, '$maxDistance', maxDistance); } else { return this._addCondition(key, '$geoWithin', { $centerSphere: [[point.longitude, point.latitude], maxDistance], }); } } /** * Adds a proximity based constraint for finding objects with key point * values near the point given and within the maximum distance given. * Radius of earth used is 3958.8 miles. * * @param {string} key The key that the Parse.GeoPoint is stored in. * @param {Parse.GeoPoint} point The reference Parse.GeoPoint that is used. * @param {number} maxDistance Maximum distance (in miles) of results to return. * @param {boolean} sorted A Bool value that is true if results should be * sorted by distance ascending, false is no sorting is required, * defaults to true. * @returns {Parse.Query} Returns the query, so you can chain this call. */ withinMiles( key: K, point: ParseGeoPoint, maxDistance: number, sorted?: boolean ): this { return this.withinRadians(key, point, maxDistance / 3958.8, sorted); } /** * Adds a proximity based constraint for finding objects with key point * values near the point given and within the maximum distance given. * Radius of earth used is 6371.0 kilometers. * * @param {string} key The key that the Parse.GeoPoint is stored in. * @param {Parse.GeoPoint} point The reference Parse.GeoPoint that is used. * @param {number} maxDistance Maximum distance (in kilometers) of results to return. * @param {boolean} sorted A Bool value that is true if results should be * sorted by distance ascending, false is no sorting is required, * defaults to true. * @returns {Parse.Query} Returns the query, so you can chain this call. */ withinKilometers( key: K, point: ParseGeoPoint, maxDistance: number, sorted?: boolean ): this { return this.withinRadians(key, point, maxDistance / 6371.0, sorted); } /** * Adds a constraint to the query that requires a particular key's * coordinates be contained within a given rectangular geographic bounding * box. * * @param {string} key The key to be constrained. * @param {Parse.GeoPoint} southwest * The lower-left inclusive corner of the box. * @param {Parse.GeoPoint} northeast * The upper-right inclusive corner of the box. * @returns {Parse.Query} Returns the query, so you can chain this call. */ withinGeoBox( key: K, southwest: ParseGeoPoint, northeast: ParseGeoPoint ): this { if (!(southwest instanceof ParseGeoPoint)) { southwest = new ParseGeoPoint(southwest); } if (!(northeast instanceof ParseGeoPoint)) { northeast = new ParseGeoPoint(northeast); } this._addCondition(key, '$within', { $box: [southwest, northeast] }); return this; } /** * Adds a constraint to the query that requires a particular key's * coordinates be contained within and on the bounds of a given polygon. * Supports closed and open (last point is connected to first) paths * * Polygon must have at least 3 points * * @param {string} key The key to be constrained. * @param {Array} points Array of Coordinates / GeoPoints * @returns {Parse.Query} Returns the query, so you can chain this call. */ withinPolygon( key: K, points: number[][] ): this { return this._addCondition(key, '$geoWithin', { $polygon: points }); } /** * Add a constraint to the query that requires a particular key's * coordinates that contains a ParseGeoPoint * * @param {string} key The key to be constrained. * @param {Parse.GeoPoint} point * @returns {Parse.Query} Returns the query, so you can chain this call. */ polygonContains( key: K, point: ParseGeoPoint ): this { return this._addCondition(key, '$geoIntersects', { $point: point }); } /* Query Orderings */ /** * Sorts the results in ascending order by the given key. * * @param {(string|string[])} keys The key to order by, which is a * string of comma separated values, or an Array of keys, or multiple keys. * @returns {Parse.Query} Returns the query, so you can chain this call. */ ascending(...keys: string[]): this { this._order = []; return this.addAscending.apply(this, keys); } /** * Sorts the results in ascending order by the given key, * but can also add secondary sort descriptors without overwriting _order. * * @param {(string|string[])} keys The key to order by, which is a * string of comma separated values, or an Array of keys, or multiple keys. * @returns {Parse.Query} Returns the query, so you can chain this call. */ addAscending(...keys: string[]): this { if (!this._order) { this._order = []; } keys.forEach((key: any) => { if (Array.isArray(key)) { key = key.join(); } this._order = this._order.concat(key.replace(/\s/g, '').split(',')); }); return this; } /** * Sorts the results in descending order by the given key. * * @param {(string|string[])} keys The key to order by, which is a * string of comma separated values, or an Array of keys, or multiple keys. * @returns {Parse.Query} Returns the query, so you can chain this call. */ descending(...keys: string[]): this { this._order = []; return this.addDescending.apply(this, keys); } /** * Sorts the results in descending order by the given key, * but can also add secondary sort descriptors without overwriting _order. * * @param {(string|string[])} keys The key to order by, which is a * string of comma separated values, or an Array of keys, or multiple keys. * @returns {Parse.Query} Returns the query, so you can chain this call. */ addDescending(...keys: string[]): this { if (!this._order) { this._order = []; } keys.forEach((key: any) => { if (Array.isArray(key)) { key = key.join(); } this._order = this._order.concat( key .replace(/\s/g, '') .split(',') .map((k: string) => { return '-' + k; }) ); }); return this; } /* Query Options */ /** * Sets the number of results to skip before returning any results. * This is useful for pagination. * Default is to skip zero results. * * @param {number} n the number of results to skip. * @returns {Parse.Query} Returns the query, so you can chain this call. */ skip(n: number): this { if (typeof n !== 'number' || n < 0) { throw new Error('You can only skip by a positive number'); } this._skip = n; return this; } /** * Sets the limit of the number of results to return. The default limit is 100. * * @param {number} n the number of results to limit to. * @returns {Parse.Query} Returns the query, so you can chain this call. */ limit(n: number): this { if (typeof n !== 'number') { throw new Error('You can only set the limit to a numeric value'); } this._limit = n; return this; } /** * Sets the flag to include with response the total number of objects satisfying this query, * despite limits/skip. Might be useful for pagination. * Note that result of this query will be wrapped as an object with * `results`: holding {ParseObject} array and `count`: integer holding total number * * @param {boolean} includeCount false - disable, true - enable. * @returns {Parse.Query} Returns the query, so you can chain this call. */ withCount(includeCount = true): this { if (typeof includeCount !== 'boolean') { throw new Error('You can only set withCount to a boolean value'); } this._count = includeCount; return this; } /** * Includes nested Parse.Objects for the provided key. You can use dot * notation to specify which fields in the included object are also fetched. * * You can include all nested Parse.Objects by passing in '*'. * Requires Parse Server 3.0.0+ *
query.include('*');
* * @param {...string|Array} keys The name(s) of the key(s) to include. * @returns {Parse.Query} Returns the query, so you can chain this call. */ include(...keys: (K | K[])[]): this { keys.forEach(key => { if (Array.isArray(key)) { this._include = this._include.concat(key as string[]); } else { this._include.push(key as string); } }); return this; } /** * Includes all nested Parse.Objects one level deep. * * Requires Parse Server 3.0.0+ * * @returns {Parse.Query} Returns the query, so you can chain this call. */ includeAll(): this { return this.include('*'); } /** * Restricts the fields of the returned Parse.Objects to include only the * provided keys. If this is called multiple times, then all of the keys * specified in each of the calls will be included. * * When selecting `authData` on `Parse.User`, only auth data of currently * configured auth providers is returned. Auth data of providers that are no * longer configured is not included. To return all auth data regardless of * the provider configuration, do not select `authData`. * * @param {...string|Array} keys The name(s) of the key(s) to include. * @returns {Parse.Query} Returns the query, so you can chain this call. */ select(...keys: (K | K[])[]): this { if (!this._select) { this._select = []; } keys.forEach(key => { if (Array.isArray(key)) { this._select = this._select.concat(key as string[]); } else { this._select.push(key as string); } }); return this; } /** * Restricts the fields of the returned Parse.Objects to all keys except the * provided keys. Exclude takes precedence over select and include. * * Requires Parse Server 3.6.0+ * * @param {...string|Array} keys The name(s) of the key(s) to exclude. * @returns {Parse.Query} Returns the query, so you can chain this call. */ exclude(...keys: (K | K[])[]): this { keys.forEach(key => { if (Array.isArray(key)) { this._exclude = this._exclude.concat(key as string[]); } else { this._exclude.push(key as string); } }); return this; } /** * Restricts live query to trigger only for watched fields. * * Requires Parse Server 6.0.0+ * * @param {...string|Array} keys The name(s) of the key(s) to watch. * @returns {Parse.Query} Returns the query, so you can chain this call. */ watch(...keys: (K | K[])[]): this { keys.forEach(key => { if (Array.isArray(key)) { this._watch = this._watch.concat(key as string[]); } else { this._watch.push(key as string); } }); return this; } /** * Changes the read preference that the backend will use when performing the query to the database. * * @param {string} readPreference The read preference for the main query. * @param {string} includeReadPreference The read preference for the queries to include pointers. * @param {string} subqueryReadPreference The read preference for the sub queries. * @returns {Parse.Query} Returns the query, so you can chain this call. */ readPreference( readPreference: string, includeReadPreference?: string, subqueryReadPreference?: string ): this { this._readPreference = readPreference; this._includeReadPreference = includeReadPreference || null; this._subqueryReadPreference = subqueryReadPreference || null; return this; } /** * Subscribe this query to get liveQuery updates * * @param {string} sessionToken (optional) Defaults to the currentUser * @returns {Promise} Returns the liveQuerySubscription, it's an event emitter * which can be used to get liveQuery updates. */ async subscribe(sessionToken?: string | null): Promise { const currentUser = await CoreManager.getUserController().currentUserAsync(); if (!sessionToken) { sessionToken = currentUser ? currentUser.getSessionToken() || undefined : undefined; } const liveQueryClient = await CoreManager.getLiveQueryController().getDefaultLiveQueryClient(); if (liveQueryClient.shouldOpen()) { liveQueryClient.open(); } const subscription = liveQueryClient.subscribe(this, sessionToken!); return subscription.subscribePromise.then(() => { return subscription; }); } /** * Constructs a Parse.Query that is the OR of the passed in queries. For * example: *
var compoundQuery = Parse.Query.or(query1, query2, query3);
* * will create a compoundQuery that is an or of the query1, query2, and * query3. * * @param {...Parse.Query} queries The list of queries to OR. * @static * @returns {Parse.Query} The query that is the OR of the passed in queries. */ static or(...queries: ParseQuery[]): ParseQuery { const className = _getClassNameFromQueries(queries); const query = new ParseQuery(className!); query._orQuery(queries); return query; } /** * Constructs a Parse.Query that is the AND of the passed in queries. For * example: *
var compoundQuery = Parse.Query.and(query1, query2, query3);
* * will create a compoundQuery that is an and of the query1, query2, and * query3. * * @param {...Parse.Query} queries The list of queries to AND. * @static * @returns {Parse.Query} The query that is the AND of the passed in queries. */ static and(...queries: ParseQuery[]): ParseQuery { const className = _getClassNameFromQueries(queries); const query = new ParseQuery(className!); query._andQuery(queries); return query; } /** * Constructs a Parse.Query that is the NOR of the passed in queries. For * example: *
const compoundQuery = Parse.Query.nor(query1, query2, query3);
* * will create a compoundQuery that is a nor of the query1, query2, and * query3. * * @param {...Parse.Query} queries The list of queries to NOR. * @static * @returns {Parse.Query} The query that is the NOR of the passed in queries. */ static nor(...queries: ParseQuery[]): ParseQuery { const className = _getClassNameFromQueries(queries); const query = new ParseQuery(className!); query._norQuery(queries); return query; } /** * Change the source of this query to the server. * * @returns {Parse.Query} Returns the query, so you can chain this call. */ fromNetwork(): this { this._queriesLocalDatastore = false; this._localDatastorePinName = null; return this; } /** * Changes the source of this query to all pinned objects. * * @returns {Parse.Query} Returns the query, so you can chain this call. */ fromLocalDatastore(): this { return this.fromPinWithName(null); } /** * Changes the source of this query to the default group of pinned objects. * * @returns {Parse.Query} Returns the query, so you can chain this call. */ fromPin(): this { return this.fromPinWithName(DEFAULT_PIN); } /** * Changes the source of this query to a specific group of pinned objects. * * @param {string} name The name of query source. * @returns {Parse.Query} Returns the query, so you can chain this call. */ fromPinWithName(name?: string | null): this { const localDatastore = CoreManager.getLocalDatastore(); if (localDatastore.checkIfEnabled()) { this._queriesLocalDatastore = true; this._localDatastorePinName = name; } return this; } /** * Cancels the current network request (if any is running). * * @returns {Parse.Query} Returns the query, so you can chain this call. */ cancel(): this { if (this._xhrRequest.task && typeof this._xhrRequest.task.abort === 'function') { this._xhrRequest.task._aborted = true; this._xhrRequest.task.abort(); this._xhrRequest.task = null; this._xhrRequest.onchange = () => {}; return this; } this._xhrRequest.onchange = () => this.cancel(); return this; } _setRequestTask(options) { options.requestTask = task => { this._xhrRequest.task = task; this._xhrRequest.onchange(); }; } /** * Sets a comment to the query so that the query * can be identified when using a the profiler for MongoDB. * * @param {string} value a comment can make your profile data easier to interpret and trace. * @returns {Parse.Query} Returns the query, so you can chain this call. */ comment(value: string): this { if (value == null) { delete this._comment; return this; } if (typeof value !== 'string') { throw new Error('The value of a comment to be sent with this query must be a string.'); } this._comment = value; return this; } } const DefaultController = { find( className: string, params: QueryJSON, options?: RequestOptions ): Promise<{ results: ParseObject[] }> { const RESTController = CoreManager.getRESTController(); return RESTController.request('GET', 'classes/' + className, params, options); }, aggregate(className: string, params: any, options?: RequestOptions): Promise<{ results: any[] }> { const RESTController = CoreManager.getRESTController(); return RESTController.request('GET', 'aggregate/' + className, params, options); }, }; CoreManager.setParseQuery(ParseQuery); CoreManager.setQueryController(DefaultController); export default ParseQuery;