Adding support for AfterFind

Author: jb pringuey

spec/CloudCode.spec.js

@@ -1306,4 +1306,132 @@ describe('beforeFind hooks', () => {
       done();
     });
   });
-})
+});
+
+describe('afterFind hooks', () => {
+  it('should add afterFind trigger using get',(done) => {
+    Parse.Cloud.afterFind('MyObject', (req, res) => {
+      for(let i = 0 ; i < res.results.length ; i++){
+        res.results[i].set("secretField","###");
+      }
+    });
+    let obj = new Parse.Object('MyObject');
+    obj.set('secretField', 'SSID');
+    obj.save().then(function() {
+      let query = new Parse.Query('MyObject');
+      query.get(obj.id).then(function(result) {
+        expect(result.get('secretField')).toEqual('###');
+        done();
+      }, function(error) {
+        fail(error);
+        done();
+      });
+    }, function(error) {
+      fail(error);
+      done();
+    });
+  });
+
+  it('should add afterFind trigger using find',(done) => {
+    Parse.Cloud.afterFind('MyObject', (req, res) => {
+      for(let i = 0 ; i < res.results.length ; i++){
+        res.results[i].set("secretField","###");
+      }
+    });
+    let obj = new Parse.Object('MyObject');
+    obj.set('secretField', 'SSID');
+    obj.save().then(function() {
+      let query = new Parse.Query('MyObject');
+      query.equalTo('objectId',obj.id);
+      query.find().then(function(results) {
+        expect(results[0].get('secretField')).toEqual('###');
+        done();
+      }, function(error) {
+        fail(error);
+        done();
+      });
+    }, function(error) {
+      fail(error);
+      done();
+    });
+  });
+
+  it('should filter out results',(done) => {
+    Parse.Cloud.afterFind('MyObject', (req, res) => {
+      let filteredResults = [];
+      for(let i = 0 ; i < res.results.length ; i++){
+        if(res.results[i].get("secretField")==="SSID1") {
+          filteredResults.push(res.results[i]);
+        }
+      }
+      res.results = filteredResults;
+    });
+    let obj0 = new Parse.Object('MyObject');
+    obj0.set('secretField', 'SSID1');
+    let obj1 = new Parse.Object('MyObject');
+    obj1.set('secretField', 'SSID2');
+    Parse.Object.saveAll([obj0, obj1]).then(function() {
+      let query = new Parse.Query('MyObject');
+      query.find().then(function(results) {
+        expect(results[0].get('secretField')).toEqual('SSID1');
+        expect(results.length).toEqual(1);
+        done();
+      }, function(error) {
+        fail(error);
+        done();
+      });
+    }, function(error) {
+      fail(error);
+      done();
+    });
+  });
+
+  it('should handle failures',(done) => {
+    Parse.Cloud.afterFind('MyObject', (req, res) => {
+      res.error(Parse.Error.SCRIPT_FAILED, "It should fail");
+    });
+    let obj = new Parse.Object('MyObject');
+    obj.set('secretField', 'SSID');
+    obj.save().then(function() {
+      let query = new Parse.Query('MyObject');
+      query.equalTo('objectId',obj.id);
+      query.find().then(function(results) {
+        fail("AfterFind should handle response failure correctly");
+        done();
+      }, function(error) {
+        done();
+      });
+    }, function(error) {
+      done();
+    });
+  });
+
+  it('should also work with promise',(done) => {
+    Parse.Cloud.afterFind('MyObject', (req, res) => {
+      let promise = new Parse.Promise();
+      setTimeout(function(){
+        for(let i = 0 ; i < res.results.length ; i++){
+          res.results[i].set("secretField","###");
+        }
+        promise.resolve(res.results);
+      }, 1000);
+      return promise;
+    });
+    let obj = new Parse.Object('MyObject');
+    obj.set('secretField', 'SSID');
+    obj.save().then(function() {
+      let query = new Parse.Query('MyObject');
+      query.equalTo('objectId',obj.id);
+      query.find().then(function(results) {
+        expect(results[0].get('secretField')).toEqual('###');
+        done();
+      }, function(error) {
+        fail(error);
+      });
+    }, function(error) {
+      fail(error);
+    });
+  });
+
+});
+

src/RestQuery.js

@@ -3,6 +3,7 @@
 
 var SchemaController = require('./Controllers/SchemaController');
 var Parse = require('parse/node').Parse;
+const triggers = require('./triggers');
 
 import { default as FilesController } from './Controllers/FilesController';
 
@@ -122,6 +123,8 @@ RestQuery.prototype.execute = function(executeOptions) {
     return this.runCount();
   }).then(() => {
     return this.handleInclude();
+  }).then(() => {
+    return this.runAfterFindTrigger();
   }).then(() => {
     return this.response;
   });
@@ -468,6 +471,22 @@ RestQuery.prototype.handleInclude = function() {
   return pathResponse;
 };
 
+//Returns a promise of a processed set of results
+RestQuery.prototype.runAfterFindTrigger = function() {
+  if (!this.response) {
+    return;
+  }
+  // Avoid doing any setup for triggers if there is no 'afterFind' trigger for this class.
+  const hasAfterFindHook = triggers.triggerExists(this.className, triggers.Types.afterFind, this.config.applicationId);
+  if (!hasAfterFindHook) {
+    return Promise.resolve();
+  }
+  // Run afterFind trigger and set the new results
+  return triggers.maybeRunAfterFindTrigger(triggers.Types.afterFind, this.auth, this.className,this.response.results, this.config).then((results) => {
+    this.response.results = results;
+  });
+};
+
 // Adds included values to the response.
 // Path is a list of field names.
 // Returns a promise for an augmented response.

src/cloud-code/Parse.Cloud.js

@@ -50,6 +50,11 @@ ParseCloud.beforeFind = function(parseClass, handler) {
   triggers.addTrigger(triggers.Types.beforeFind, className, handler, Parse.applicationId);
 };
 
+ParseCloud.afterFind = function(parseClass, handler) {
+  const className = getClassName(parseClass);
+  triggers.addTrigger(triggers.Types.afterFind, className, handler, Parse.applicationId);
+};
+
 ParseCloud._removeAllHooks = () => {
   triggers._unregisterAll();
 }

src/triggers.js

@@ -8,7 +8,8 @@ export const Types = {
   afterSave: 'afterSave',
   beforeDelete: 'beforeDelete',
   afterDelete: 'afterDelete',
-  beforeFind: 'beforeFind'
+  beforeFind: 'beforeFind',
+  afterFind: 'afterFind'
 };
 
 const baseStore = function() {
@@ -240,6 +241,51 @@ function logTriggerErrorBeforeHook(triggerType, className, input, auth, error) {
   });
 }
 
+export function maybeRunAfterFindTrigger(triggerType, auth, className, results, config) {
+  return new Promise(function (resolve, reject) {
+    const trigger = getTrigger(className, triggerType, config.applicationId);
+    if (!trigger) {
+      return resolve();
+    }
+    const request = getRequestObject(triggerType, auth, null, null, config);
+    const response = {
+      error: function(code, message) {
+        if (!message) {
+          message = code;
+          code = Parse.Error.SCRIPT_FAILED;
+        }
+        const scriptError = new Parse.Error(code, message);
+        return reject(scriptError);
+      }
+    };
+    logTriggerSuccessBeforeHook(triggerType, className, 'AfterFind', JSON.stringify(results), auth);
+    response.results = results.map(result => {
+      //setting the class name to transform into parse object
+      result.className=className;
+      return Parse.Object.fromJSON(result);
+    });
+    const triggerPromise = trigger(request, response);
+    logTriggerAfterHook(triggerType, className, JSON.stringify(modifiedJSONResults), auth);
+    if (triggerPromise && typeof triggerPromise.then === "function") {
+      return triggerPromise.then(function(promiseResults){
+        if(promiseResults) {
+          var modifiedJSONResults = promiseResults.map(result => {
+                return result.toJSON();
+          });
+          resolve(modifiedJSONResults);
+        }else{
+          return reject(new Parse.Error(Parse.Error.SCRIPT_FAILED, "AfterFind expect results to be returned in the promise"));
+        }
+      });
+    } else {
+      var modifiedJSONResults = response.results.map(result => {
+            return result.toJSON();
+      });
+      return resolve(modifiedJSONResults);
+    }
+  });
+}
+
 export function maybeRunQueryTrigger(triggerType, className, restWhere, restOptions, config, auth) {
   let trigger = getTrigger(className, triggerType, config.applicationId);
   if (!trigger) {