feat: Allow short circuit of beforeFind

spec/CloudCode.spec.js

@@ -201,6 +201,267 @@ describe('Cloud Code', () => {
       done();
     }
   });
+  it('beforeFind can return object without DB operation', async () => {
+    const config = Config.get('test');
+    const databaseAdapter = config.database.adapter;
+    const findSpy = spyOn(databaseAdapter, 'find').and.callThrough();
+
+    Parse.Cloud.beforeFind('TestObject', () => {
+      return new Parse.Object('TestObject', { foo: 'bar' });
+    });
+
+    Parse.Cloud.afterFind('TestObject', req => {
+      expect(req.objects).toBeDefined();
+      expect(req.objects[0].get('foo')).toBe('bar');
+    });
+
+    const newObj = await new Parse.Query('TestObject').first();
+    expect(newObj.className).toBe('TestObject');
+    expect(newObj.toJSON()).toEqual({ foo: 'bar' });
+
+    expect(findSpy).not.toHaveBeenCalled();
+
+    await newObj.save();
+  });
+
+  it('beforeFind can return array of objects without DB operation', async () => {
+    const config = Config.get('test');
+    const databaseAdapter = config.database.adapter;
+    const findSpy = spyOn(databaseAdapter, 'find').and.callThrough();
+
+    Parse.Cloud.beforeFind('TestObject', () => {
+      return [new Parse.Object('TestObject', { foo: 'bar' })];
+    });
+
+    Parse.Cloud.afterFind('TestObject', req => {
+      expect(req.objects).toBeDefined();
+      expect(req.objects[0].get('foo')).toBe('bar');
+    });
+
+    const newObj = await new Parse.Query('TestObject').first();
+    expect(newObj.className).toBe('TestObject');
+    expect(newObj.toJSON()).toEqual({ foo: 'bar' });
+
+    expect(findSpy).not.toHaveBeenCalled();
+
+    await newObj.save();
+  });
+
+  it('beforeFind can return object for get query without DB operation', async () => {
+    const config = Config.get('test');
+    const databaseAdapter = config.database.adapter;
+    const findSpy = spyOn(databaseAdapter, 'find').and.callThrough();
+
+    Parse.Cloud.beforeFind('TestObject', () => {
+      return [new Parse.Object('TestObject', { foo: 'bar' })];
+    });
+
+    Parse.Cloud.afterFind('TestObject', req => {
+      expect(req.objects).toBeDefined();
+      expect(req.objects[0].get('foo')).toBe('bar');
+    });
+
+    const testObj = new Parse.Object('TestObject');
+    await testObj.save();
+
+    findSpy.calls.reset();
+
+    const newObj = await new Parse.Query('TestObject').get(testObj.id);
+    expect(newObj.className).toBe('TestObject');
+    expect(newObj.toJSON()).toEqual({ foo: 'bar' });
+
+    expect(findSpy).not.toHaveBeenCalled();
+
+    await newObj.save();
+  });
+
+  it('beforeFind can return empty array without DB operation', async () => {
+    const config = Config.get('test');
+    const databaseAdapter = config.database.adapter;
+    const findSpy = spyOn(databaseAdapter, 'find').and.callThrough();
+
+    Parse.Cloud.beforeFind('TestObject', () => {
+      return [];
+    });
+
+    Parse.Cloud.afterFind('TestObject', req => {
+      expect(req.objects.length).toBe(0);
+    });
+
+    const obj = new Parse.Object('TestObject');
+    await obj.save();
+
+    findSpy.calls.reset();
+
+    const newObj = await new Parse.Query('TestObject').first();
+    expect(newObj).toBeUndefined();
+
+    expect(findSpy).not.toHaveBeenCalled();
+  });
+
+  const { maybeRunAfterFindTrigger } = require('../lib/triggers');
+
+  describe('maybeRunAfterFindTrigger - direct function tests', () => {
+    const testConfig = {
+      applicationId: 'test',
+      logLevels: { triggerBeforeSuccess: 'info', triggerAfter: 'info' },
+    };
+
+    it('should convert Parse.Object instances to JSON when no trigger defined', async () => {
+      const className = 'TestParseObjectDirect_' + Date.now();
+
+      const parseObj1 = new Parse.Object(className);
+      parseObj1.set('name', 'test1');
+      parseObj1.id = 'obj1';
+
+      const parseObj2 = new Parse.Object(className);
+      parseObj2.set('name', 'test2');
+      parseObj2.id = 'obj2';
+
+      const result = await maybeRunAfterFindTrigger(
+        'afterFind',
+        null,
+        className,
+        [parseObj1, parseObj2],
+        testConfig,
+        null,
+        {}
+      );
+
+      expect(result).toBeDefined();
+      expect(Array.isArray(result)).toBe(true);
+      expect(result.length).toBe(2);
+      expect(result[0].name).toBe('test1');
+      expect(result[1].name).toBe('test2');
+    });
+
+    it('should handle null/undefined objectsInput when no trigger', async () => {
+      const className = 'TestNullDirect_' + Date.now();
+
+      const resultNull = await maybeRunAfterFindTrigger(
+        'afterFind',
+        null,
+        className,
+        null,
+        testConfig,
+        null,
+        {}
+      );
+      expect(resultNull).toEqual([]);
+
+      const resultUndefined = await maybeRunAfterFindTrigger(
+        'afterFind',
+        null,
+        className,
+        undefined,
+        testConfig,
+        null,
+        {}
+      );
+      expect(resultUndefined).toEqual([]);
+
+      const resultEmpty = await maybeRunAfterFindTrigger(
+        'afterFind',
+        null,
+        className,
+        [],
+        testConfig,
+        null,
+        {}
+      );
+      expect(resultEmpty).toEqual([]);
+    });
+
+    it('should handle plain object query with where clause', async () => {
+      const className = 'TestQueryWhereDirect_' + Date.now();
+      let receivedQuery = null;
+
+      Parse.Cloud.afterFind(className, req => {
+        receivedQuery = req.query;
+        return req.objects;
+      });
+
+      const mockObject = { id: 'test123', className: className, name: 'test' };
+
+      const result = await maybeRunAfterFindTrigger(
+        'afterFind',
+        null,
+        className,
+        [mockObject],
+        testConfig,
+        { where: { name: 'test' }, limit: 10 },
+        {}
+      );
+
+      expect(receivedQuery).toBeInstanceOf(Parse.Query);
+      expect(result).toBeDefined();
+    });
+
+    it('should handle plain object query without where clause', async () => {
+      const className = 'TestQueryNoWhereDirect_' + Date.now();
+      let receivedQuery = null;
+
+      Parse.Cloud.afterFind(className, req => {
+        receivedQuery = req.query;
+        return req.objects;
+      });
+
+      const mockObject = { id: 'test456', className: className, name: 'test' };
+
+      const result = await maybeRunAfterFindTrigger(
+        'afterFind',
+        null,
+        className,
+        [mockObject],
+        testConfig,
+        { limit: 5, skip: 0 },
+        {}
+      );
+
+      expect(receivedQuery).toBeInstanceOf(Parse.Query);
+      expect(result).toBeDefined();
+    });
+
+    it('should create default query for invalid query parameter', async () => {
+      const className = 'TestInvalidQueryDirect_' + Date.now();
+      let receivedQuery = null;
+
+      Parse.Cloud.afterFind(className, req => {
+        receivedQuery = req.query;
+        return req.objects;
+      });
+
+      const mockObject = { id: 'test789', className: className, name: 'test' };
+
+      await maybeRunAfterFindTrigger(
+        'afterFind',
+        null,
+        className,
+        [mockObject],
+        testConfig,
+        'invalid_query_string',
+        {}
+      );
+
+      expect(receivedQuery).toBeInstanceOf(Parse.Query);
+      expect(receivedQuery.className).toBe(className);
+
+      receivedQuery = null;
+
+      await maybeRunAfterFindTrigger(
+        'afterFind',
+        null,
+        className,
+        [mockObject],
+        testConfig,
+        null,
+        {}
+      );
+
+      expect(receivedQuery).toBeInstanceOf(Parse.Query);
+      expect(receivedQuery.className).toBe(className);
+    });
+  });
 
   it('beforeSave rejection with custom error code', function (done) {
     Parse.Cloud.beforeSave('BeforeSaveFailWithErrorCode', function () {

src/RestQuery.js

@@ -50,6 +50,7 @@ async function RestQuery({
   if (![RestQuery.Method.find, RestQuery.Method.get].includes(method)) {
     throw new Parse.Error(Parse.Error.INVALID_QUERY, 'bad query type');
   }
+  const isGet = method === RestQuery.Method.get;
   enforceRoleSecurity(method, className, auth);
   const result = runBeforeFind
     ? await triggers.maybeRunQueryTrigger(
@@ -60,7 +61,7 @@ async function RestQuery({
       config,
       auth,
       context,
-      method === RestQuery.Method.get
+      isGet
     )
     : Promise.resolve({ restWhere, restOptions });
 
@@ -72,7 +73,8 @@ async function RestQuery({
     result.restOptions || restOptions,
     clientSDK,
     runAfterFind,
-    context
+    context,
+    isGet
   );
 }
 
@@ -101,7 +103,8 @@ function _UnsafeRestQuery(
   restOptions = {},
   clientSDK,
   runAfterFind = true,
-  context
+  context,
+  isGet
 ) {
   this.config = config;
   this.auth = auth;
@@ -113,6 +116,7 @@ function _UnsafeRestQuery(
   this.response = null;
   this.findOptions = {};
   this.context = context || {};
+  this.isGet = isGet;
   if (!this.auth.isMaster) {
     if (this.className == '_Session') {
       if (!this.auth.user) {
@@ -914,7 +918,8 @@ _UnsafeRestQuery.prototype.runAfterFindTrigger = function () {
       this.response.results,
       this.config,
       parseQuery,
-      this.context
+      this.context,
+      this.isGet
     )
     .then(results => {
       // Ensure we properly set the className back