feat: allow short circuit of beforeFind

Author: dblythy

spec/CloudCode.spec.js

@@ -202,6 +202,61 @@ describe('Cloud Code', () => {
     }
   });
 
+  it('beforeFind can short circuit', async () => {
+    Parse.Cloud.beforeFind('beforeFind', () => {
+      return new Parse.Object('TestObject', { foo: 'bar' });
+    });
+    Parse.Cloud.afterFind('beforeFind', () => {
+      throw 'afterFind should not run';
+    });
+    const obj = new Parse.Object('beforeFind');
+    await obj.save();
+    const newObj = await new Parse.Query('beforeFind').first();
+    expect(newObj.className).toBe('TestObject');
+    expect(newObj.toJSON()).toEqual({ foo: 'bar' });
+  });
+
+  it('beforeFind can short circuit arrays', async () => {
+    Parse.Cloud.beforeFind('beforeFind', () => {
+      return [new Parse.Object('TestObject', { foo: 'bar' })];
+    });
+    Parse.Cloud.afterFind('beforeFind', () => {
+      throw 'afterFind should not run';
+    });
+    const obj = new Parse.Object('beforeFind');
+    await obj.save();
+    const newObj = await new Parse.Query('beforeFind').first();
+    expect(newObj.className).toBe('TestObject');
+    expect(newObj.toJSON()).toEqual({ foo: 'bar' });
+  });
+
+  it('beforeFind can short circuit get', async () => {
+    Parse.Cloud.beforeFind('beforeFind', () => {
+      return [new Parse.Object('TestObject', { foo: 'bar' })];
+    });
+    Parse.Cloud.afterFind('beforeFind', () => {
+      throw 'afterFind should not run';
+    });
+    const obj = new Parse.Object('beforeFind');
+    await obj.save();
+    const newObj = await new Parse.Query('beforeFind').get(obj.id);
+    expect(newObj.className).toBe('TestObject');
+    expect(newObj.toJSON()).toEqual({ foo: 'bar' });
+  });
+
+  it('beforeFind can short circuit empty array', async () => {
+    Parse.Cloud.beforeFind('beforeFind', () => {
+      return [];
+    });
+    Parse.Cloud.afterFind('beforeFind', () => {
+      throw 'afterFind should not run';
+    });
+    const obj = new Parse.Object('beforeFind');
+    await obj.save();
+    const newObj = await new Parse.Query('beforeFind').first();
+    expect(newObj).toBeUndefined();
+  });
+
   it('beforeSave rejection with custom error code', function (done) {
     Parse.Cloud.beforeSave('BeforeSaveFailWithErrorCode', function () {
       throw new Parse.Error(999, 'Nope');

src/rest.js

@@ -26,33 +26,74 @@ function checkLiveQuery(className, config) {
 
 // Returns a promise for an object with optional keys 'results' and 'count'.
 const find = async (config, auth, className, restWhere, restOptions, clientSDK, context) => {
-  const query = await RestQuery({
-    method: RestQuery.Method.find,
-    config,
-    auth,
-    className,
-    restWhere,
-    restOptions,
-    clientSDK,
-    context,
-  });
-  return query.execute();
+  enforceRoleSecurity('find', className, auth);
+  return triggers
+    .maybeRunQueryTrigger(
+      triggers.Types.beforeFind,
+      className,
+      restWhere,
+      restOptions,
+      config,
+      auth,
+      context
+    )
+    .then(async result => {
+      restWhere = result.restWhere || restWhere;
+      restOptions = result.restOptions || restOptions;
+      if (result?.objects) {
+        return {
+          results: result.objects.map(row => row._toFullJSON()),
+        };
+      }
+      const query = await RestQuery({
+        method: RestQuery.Method.find,
+        config,
+        auth,
+        className,
+        restWhere,
+        restOptions,
+        clientSDK,
+        context,
+      });
+      return query.execute();
+    });
 };
 
 // get is just like find but only queries an objectId.
 const get = async (config, auth, className, objectId, restOptions, clientSDK, context) => {
   var restWhere = { objectId };
-  const query = await RestQuery({
-    method: RestQuery.Method.get,
-    config,
-    auth,
-    className,
-    restWhere,
-    restOptions,
-    clientSDK,
-    context,
-  });
-  return query.execute();
+  enforceRoleSecurity('get', className, auth);
+  return triggers
+    .maybeRunQueryTrigger(
+      triggers.Types.beforeFind,
+      className,
+      restWhere,
+      restOptions,
+      config,
+      auth,
+      context,
+      true
+    )
+    .then(async result => {
+      restWhere = result.restWhere || restWhere;
+      restOptions = result.restOptions || restOptions;
+      if (result?.objects) {
+        return {
+          results: result.objects.map(row => row._toFullJSON()),
+        };
+      }
+      const query = await RestQuery({
+        method: RestQuery.Method.get,
+        config,
+        auth,
+        className,
+        restWhere,
+        restOptions,
+        clientSDK,
+        context,
+      });
+      return query.execute();
+    });
 };
 
 // Returns a promise that doesn't resolve to any useful value.

src/triggers.js

@@ -607,9 +607,19 @@ export function maybeRunQueryTrigger(
           restOptions = restOptions || {};
           restOptions.subqueryReadPreference = requestObject.subqueryReadPreference;
         }
+        let objects = undefined;
+        if (result instanceof Parse.Object) {
+          objects = [result];
+        } else if (
+          Array.isArray(result) &&
+          (!result.length || result.some(obj => obj instanceof Parse.Object))
+        ) {
+          objects = result;
+        }
         return {
           restWhere,
           restOptions,
+          objects,
         };
       },
       err => {