docs: function handleGetRequest(request) {
    const objId = request.objectId;
    const className = request.className;
    if (objId) {
      // Object.fetch() query
      const collection = getCollection(className);
      const currentObject = collection[objId];
      if (!currentObject) {
        return Parse.Promise.as(respond(404, {
          code: 101,
          error: 'object not found for update',
        }));
      }
      let match = _.cloneDeep(currentObject);
  
      if (match) {
        const toOmit = Array.from(getMask(className));
        match = _.omit(match, toOmit);
      }
  
      return Parse.Promise.as(respond(200, match));
    }
    const data = request.data;
    indirect = data.redirectClassNameForKey;
    let matches = recursivelyMatch(className, data.where);
    let matchesClassName = '';
    if (indirect) {
      matches = outOfBandResults.matches;
      if (outOfBandResults.className) {
        matchesClassName = outOfBandResults.className;
      }
    }
  
    if (request.data.count) {
      return Parse.Promise.as(respond(200, { count: matches.length }));
    }
  
    matches = queryMatchesAfterIncluding(matches, data.include);
  
    const toOmit = Array.from(getMask(className));
    matches = matches.map((match) => _.omit(match, toOmit));
  
    // TODO: Can we just call toJSON() in order to avoid this?
    matches.forEach(match => {
      if (match.createdAt) {
        match.createdAt = match.createdAt.toJSON();
      }
      if (match.updatedAt) {
        match.updatedAt = match.updatedAt.toJSON();
      }
    });
  
    // sort results if necessary
    if (data.order && data.order.length > 0 && matches.length > 0) {
      matches = sortQueryresults(matches, data.order);
    }
  
    const limit = data.limit || DEFAULT_LIMIT;
    const startIndex = data.skip || 0;
    const endIndex = startIndex + limit;
    const response = { results: matches.slice(startIndex, endIndex) };
  
    // Add the class name for the outgoing objects to the response if sepcified
    if (matchesClassName.length > 0) {
      response.className = matchesClassName;
    }
  
    return Parse.Promise.as(respond(200, response));
  }