Skip to content

feat: Add a new beforeLiveQueryEvent trigger #9445

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 1 commit into
base: alpha
Choose a base branch
from
Open

feat: Add a new beforeLiveQueryEvent trigger #9445

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
124 changes: 124 additions & 0 deletions spec/ParseLiveQuery.spec.js
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1308,4 +1308,128 @@ describe('ParseLiveQuery', function () {
await new Promise(resolve => setTimeout(resolve, 100));
expect(createSpy).toHaveBeenCalledTimes(1);
});

it('test beforeLiveQueryEvent ran while creating an object', async function () {
await reconfigureServer({
liveQuery: {
classNames: ['TestObject'],
},
startLiveQueryServer: true,
verbose: false,
silent: true,
});


Parse.Cloud.beforeLiveQueryEvent('TestObject', req => {
expect(req.user).toBeUndefined();
expect(req.object.get('foo')).toBe('bar');
})

const query = new Parse.Query(TestObject);
const subscription = await query.subscribe();
subscription.on('create', object => {
expect(object.get('foo')).toBe('bar');
done();
});

const object = new TestObject();
object.set('foo', 'bar');
await object.save();
});
Comment on lines +1312 to +1338
Copy link

@coderabbitai coderabbitai bot May 3, 2025 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

⚠️ Potential issue

Fix test callback handling.

This test is using done() on line 1332, but the function doesn't receive the done parameter. The test should either:

  1. Receive done as a parameter and call it at the end, or
  2. Return a promise or use async/await properly
-  it('test beforeLiveQueryEvent ran while creating an object', async function () {
+  it('test beforeLiveQueryEvent ran while creating an object', async function (done) {
📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change
it('test beforeLiveQueryEvent ran while creating an object', async function () {
await reconfigureServer({
liveQuery: {
classNames: ['TestObject'],
},
startLiveQueryServer: true,
verbose: false,
silent: true,
});
Parse.Cloud.beforeLiveQueryEvent('TestObject', req => {
expect(req.user).toBeUndefined();
expect(req.object.get('foo')).toBe('bar');
})
const query = new Parse.Query(TestObject);
const subscription = await query.subscribe();
subscription.on('create', object => {
expect(object.get('foo')).toBe('bar');
done();
});
const object = new TestObject();
object.set('foo', 'bar');
await object.save();
});
it('test beforeLiveQueryEvent ran while creating an object', async function (done) {
await reconfigureServer({
liveQuery: {
classNames: ['TestObject'],
},
startLiveQueryServer: true,
verbose: false,
silent: true,
});
Parse.Cloud.beforeLiveQueryEvent('TestObject', req => {
expect(req.user).toBeUndefined();
expect(req.object.get('foo')).toBe('bar');
});
const query = new Parse.Query(TestObject);
const subscription = await query.subscribe();
subscription.on('create', object => {
expect(object.get('foo')).toBe('bar');
done();
});
const object = new TestObject();
object.set('foo', 'bar');
await object.save();
});
🧰 Tools
🪛 ESLint

[error] 1312-1312: 'it' is not defined.

(no-undef)

[error] 1313-1313: 'reconfigureServer' is not defined.

(no-undef)

[error] 1324-1324: 'expect' is not defined.

(no-undef)

[error] 1325-1325: 'expect' is not defined.

(no-undef)

[error] 1328-1328: 'TestObject' is not defined.

(no-undef)

[error] 1331-1331: 'expect' is not defined.

(no-undef)

[error] 1332-1332: 'done' is not defined.

(no-undef)

[error] 1335-1335: 'TestObject' is not defined.

(no-undef)

🤖 Prompt for AI Agents (early access) 
In spec/ParseLiveQuery.spec.js around lines 1312 to 1338, the test uses done() without receiving done as a parameter, causing callback handling issues. Fix this by adding done as a parameter to the test function and calling done() inside the subscription event handler after assertions, or refactor the test to properly use async/await and return a promise without using done().

Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

In fact, we won't use done anymore in new tests. Please restructure the test so that it isn't needed anymore.

Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

@mtrezza I've restructured the test to eliminate the use of the done callback pattern. Instead, it now uses a promise that resolves when the 'create' event fires:

it('test beforeLiveQueryEvent ran while creating an object', async function () {
  await reconfigureServer({
    liveQuery: {
      classNames: ['TestObject'],
    },
    startLiveQueryServer: true,
    verbose: false,
    silent: true,
  });

  Parse.Cloud.beforeLiveQueryEvent('TestObject', req => {
    expect(req.user).toBeUndefined();
    expect(req.object.get('foo')).toBe('bar');
  });

  const query = new Parse.Query(TestObject);
  const subscription = await query.subscribe();
  
  // Create a promise that resolves when the create event happens
  const createEventPromise = new Promise(resolve => {
    subscription.on('create', object => {
      expect(object.get('foo')).toBe('bar');
      resolve();
    });
  });

  // Create and save the object that should trigger the event
  const object = new TestObject();
  object.set('foo', 'bar');
  await object.save();
  
  // Wait for the create event to be processed
  await createEventPromise;
});
✏️ Learnings added 
Learnt from: mtrezza
PR: parse-community/parse-server#9445
File: spec/ParseLiveQuery.spec.js:1312-1338
Timestamp: 2025-05-04T20:41:05.138Z
Learning: New tests in the parse-server repository should use async/await with promise-based patterns rather than callback patterns with `done()`.

Note: Learnings are effective only in the context of similar code segments. To apply general coding guidelines, please configure review instructions. You can manage existing learnings in the app.


it('test beforeLiveQueryEvent ran while updating an object', async function (done) {
await reconfigureServer({
liveQuery: {
classNames: ['TestObject'],
},
startLiveQueryServer: true,
verbose: false,
silent: true,
});
const object = new TestObject();
object.set('foo', 'bar');
await object.save();

Parse.Cloud.afterSave('TestObject', async req => {
expect(req.object.get('foo')).toBe('baz');
})
Parse.Cloud.beforeLiveQueryEvent('TestObject', async req => {
expect(req.object.get('foo')).toBe('baz');
req.object.set('foo', 'rebaz');
})
Parse.Cloud.afterLiveQueryEvent('TestObject', req => {
expect(req.event).toBe('update');
expect(req.user).toBeUndefined();
expect(req.object.get('foo')).toBe('rebaz');
});

const query = new Parse.Query(TestObject);
const subscription = await query.subscribe();
subscription.on('update', object => {
expect(object.get('foo')).toBe('rebaz');
done();
});

object.set('foo', 'baz')
await object.save();
});
Comment on lines +1340 to +1375
Copy link

@coderabbitai coderabbitai bot May 8, 2025 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

⚠️ Potential issue

Replace callback pattern with promise-based approach.

The test is using done as a parameter but should be restructured to use promises per maintainer feedback.

Refactor the test to use a promise approach:

-  it('test beforeLiveQueryEvent ran while updating an object', async function (done) {
+  it('test beforeLiveQueryEvent ran while updating an object', async function () {
     await reconfigureServer({
       liveQuery: {
         classNames: ['TestObject'],
       },
       startLiveQueryServer: true,
       verbose: false,
       silent: true,
     });
     const object = new TestObject();
     object.set('foo', 'bar');
     await object.save();

     Parse.Cloud.afterSave('TestObject', async req => {
       expect(req.object.get('foo')).toBe('baz');
     })
     Parse.Cloud.beforeLiveQueryEvent('TestObject', async req => {
       expect(req.object.get('foo')).toBe('baz');
       req.object.set('foo', 'rebaz');
     })
     Parse.Cloud.afterLiveQueryEvent('TestObject', req => {
       expect(req.event).toBe('update');
       expect(req.user).toBeUndefined();
       expect(req.object.get('foo')).toBe('rebaz');
     });

     const query = new Parse.Query(TestObject);
     const subscription = await query.subscribe();
-    subscription.on('update', object => {
-      expect(object.get('foo')).toBe('rebaz');
-      done();
-    });
+    
+    // Create a promise that resolves when the update event happens
+    const updateEventPromise = new Promise(resolve => {
+      subscription.on('update', object => {
+        expect(object.get('foo')).toBe('rebaz');
+        resolve();
+      });
+    });

     object.set('foo', 'baz')
     await object.save();
+    
+    // Wait for the update event to be processed
+    await updateEventPromise;
📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change
it('test beforeLiveQueryEvent ran while updating an object', async function (done) {
await reconfigureServer({
liveQuery: {
classNames: ['TestObject'],
},
startLiveQueryServer: true,
verbose: false,
silent: true,
});
const object = new TestObject();
object.set('foo', 'bar');
await object.save();
Parse.Cloud.afterSave('TestObject', async req => {
expect(req.object.get('foo')).toBe('baz');
})
Parse.Cloud.beforeLiveQueryEvent('TestObject', async req => {
expect(req.object.get('foo')).toBe('baz');
req.object.set('foo', 'rebaz');
})
Parse.Cloud.afterLiveQueryEvent('TestObject', req => {
expect(req.event).toBe('update');
expect(req.user).toBeUndefined();
expect(req.object.get('foo')).toBe('rebaz');
});
const query = new Parse.Query(TestObject);
const subscription = await query.subscribe();
subscription.on('update', object => {
expect(object.get('foo')).toBe('rebaz');
done();
});
object.set('foo', 'baz')
await object.save();
});
it('test beforeLiveQueryEvent ran while updating an object', async function () {
await reconfigureServer({
liveQuery: {
classNames: ['TestObject'],
},
startLiveQueryServer: true,
verbose: false,
silent: true,
});
const object = new TestObject();
object.set('foo', 'bar');
await object.save();
Parse.Cloud.afterSave('TestObject', async req => {
expect(req.object.get('foo')).toBe('baz');
})
Parse.Cloud.beforeLiveQueryEvent('TestObject', async req => {
expect(req.object.get('foo')).toBe('baz');
req.object.set('foo', 'rebaz');
})
Parse.Cloud.afterLiveQueryEvent('TestObject', req => {
expect(req.event).toBe('update');
expect(req.user).toBeUndefined();
expect(req.object.get('foo')).toBe('rebaz');
});
const query = new Parse.Query(TestObject);
const subscription = await query.subscribe();
// Create a promise that resolves when the update event happens
const updateEventPromise = new Promise(resolve => {
subscription.on('update', object => {
expect(object.get('foo')).toBe('rebaz');
resolve();
});
});
object.set('foo', 'baz')
await object.save();
// Wait for the update event to be processed
await updateEventPromise;
});
🤖 Prompt for AI Agents (early access) 
In spec/ParseLiveQuery.spec.js around lines 1340 to 1375, the test uses the
callback parameter 'done' which should be replaced with a promise-based
approach. Refactor the test by removing the 'done' parameter and instead return
a promise that resolves when the subscription's 'update' event is triggered and
assertions pass. This involves wrapping the subscription event handling in a
promise and resolving it after the expectations are met, ensuring the test
completes correctly without using the callback.

Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

That's right, we don't use done anymore.

Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🧩 Analysis chain

@mtrezza I'll update the test to use a promise-based approach, removing the done callback. Also, I noticed the first test also has a similar issue - it uses done() but doesn't define the parameter. I'll refactor both tests to follow the async/await pattern.

🏁 Script executed:

# Just checking if there are more tests that may need similar refactoring
grep -A 5 "it('test beforeLiveQueryEvent" spec/ParseLiveQuery.spec.js

Length of output: 949

@mtrezza Looking at both tests, I'll refactor them to use the promise-based pattern instead of the done callback:

  1. In the first test "ran while creating an object", the test calls done() but doesn't have the parameter defined in the function signature
  2. In the second test "ran while updating an object", it explicitly uses the done callback pattern

Here's how both should be refactored:

it('test beforeLiveQueryEvent ran while creating an object', async function () {
  await reconfigureServer({
    liveQuery: {
      classNames: ['TestObject'],
    },
    startLiveQueryServer: true,
    verbose: false,
    silent: true,
  });

  Parse.Cloud.beforeLiveQueryEvent('TestObject', req => {
    expect(req.user).toBeUndefined();
    expect(req.object.get('foo')).toBe('bar');
  });

  const query = new Parse.Query(TestObject);
  const subscription = await query.subscribe();
  
  // Create a promise that resolves when the create event happens
  const createEventPromise = new Promise(resolve => {
    subscription.on('create', object => {
      expect(object.get('foo')).toBe('bar');
      resolve();
    });
  });

  const object = new TestObject();
  object.set('foo', 'bar');
  await object.save();
  
  // Wait for the create event to be processed
  await createEventPromise;
});

it('test beforeLiveQueryEvent ran while updating an object', async function () {
  await reconfigureServer({
    liveQuery: {
      classNames: ['TestObject'],
    },
    startLiveQueryServer: true,
    verbose: false,
    silent: true,
  });
  const object = new TestObject();
  object.set('foo', 'bar');
  await object.save();

  Parse.Cloud.afterSave('TestObject', async req => {
    expect(req.object.get('foo')).toBe('baz');
  });
  Parse.Cloud.beforeLiveQueryEvent('TestObject', async req => {
    expect(req.object.get('foo')).toBe('baz');
    req.object.set('foo', 'rebaz');
  });
  Parse.Cloud.afterLiveQueryEvent('TestObject', req => {
    expect(req.event).toBe('update');
    expect(req.user).toBeUndefined();
    expect(req.object.get('foo')).toBe('rebaz');
  });

  const query = new Parse.Query(TestObject);
  const subscription = await query.subscribe();
  
  // Create a promise that resolves when the update event happens
  const updateEventPromise = new Promise(resolve => {
    subscription.on('update', object => {
      expect(object.get('foo')).toBe('rebaz');
      resolve();
    });
  });

  object.set('foo', 'baz');
  await object.save();
  
  // Wait for the update event to be processed
  await updateEventPromise;
});
🧬 Code Graph Analysis Results

Relevant snippet from spec/ParseLiveQuery.spec.js (lines 1-50 approx.)

The file spec/ParseLiveQuery.spec.js itself contains multiple test cases using the Jasmine testing framework. Many tests use the done callback parameter in the it blocks, e.g.:

it('access user on onLiveQueryEvent disconnect', async done => {
  // ...
  done();
});

and

it('can subscribe to query', async done => {
  // ...
  done();
});

The user comment "That's right, we don't use done anymore." likely refers to the fact that these tests are using the done callback style for asynchronous tests, which is an older pattern. Modern Jasmine supports returning a Promise or using async functions without needing done.

Relevant snippet from spec/helper.js (lines 171-205)

const reconfigureServer = async (changedConfiguration = {}) => {
  if (parseServer) {
    await shutdownServer(parseServer);
    return reconfigureServer(changedConfiguration);
  }
  didChangeConfiguration = Object.keys(changedConfiguration).length !== 0;
  databaseAdapter = new databaseAdapter.constructor({
    uri: databaseURI,
    collectionPrefix: 'test_',
  });
  defaultConfiguration.databaseAdapter = databaseAdapter;
  global.databaseAdapter = databaseAdapter;
  if (filesAdapter instanceof GridFSBucketAdapter) {
    defaultConfiguration.filesAdapter = new GridFSBucketAdapter(mongoURI);
  }
  if (process.env.PARSE_SERVER_TEST_CACHE === 'redis') {
    defaultConfiguration.cacheAdapter = new RedisCacheAdapter();
  }
  const newConfiguration = Object.assign({}, defaultConfiguration, changedConfiguration, {
    mountPath: '/1',
    port,
  });
  cache.clear();
  parseServer = await ParseServer.startApp(newConfiguration);
  Parse.CoreManager.setRESTController(RESTController);
  parseServer.expressApp.use('/1', err => {
    console.error(err);
    fail('should not call next');
  });
  openConnections.track(parseServer.server);
  if (parseServer.liveQueryServer?.server && parseServer.liveQueryServer.server !== parseServer.server) {
    openConnections.track(parseServer.liveQueryServer.server);
  }
  return parseServer;
};

This helper function is used in many tests in ParseLiveQuery.spec.js to reconfigure and start the Parse Server with LiveQuery enabled. It returns a Promise and is awaited in the tests.

Relevant snippet from src/TestUtils.js (lines 30-40)

export function resolvingPromise() {
  let res;
  let rej;
  const promise = new Promise((resolve, reject) => {
    res = resolve;
    rej = reject;
  });
  promise.resolve = res;
  promise.reject = rej;
  return promise;
}

This utility function creates a Promise with externally accessible resolve and reject functions. It is used in the tests for asynchronous coordination without using done.

Summary of relevance to the user comment:

  • The test file spec/ParseLiveQuery.spec.js contains many tests that use the done callback style for asynchronous tests.
  • Modern async/await style tests in Jasmine do not require done and can return a Promise or be declared async.
  • The helper function reconfigureServer returns a Promise and is awaited, showing modern async usage.
  • The utility resolvingPromise is used for async coordination without done.
  • The user comment "That's right, we don't use done anymore." is relevant to the usage of done in the test file and the possibility to refactor tests to use async/await without done.

No other code snippets from the provided list are directly relevant to the usage or removal of done in the test file spec/ParseLiveQuery.spec.js.

✏️ Learnings added 
Learnt from: mtrezza
PR: parse-community/parse-server#9445
File: spec/ParseLiveQuery.spec.js:1340-1375
Timestamp: 2025-05-09T09:59:06.266Z
Learning: Tests in the parse-server repository should use promise-based approaches rather than callback patterns with `done()`. Use a pattern where a Promise is created that resolves when the event occurs, then await that promise.

Learnt from: mtrezza
PR: parse-community/parse-server#9445
File: spec/ParseLiveQuery.spec.js:1340-1375
Timestamp: 2025-05-09T09:59:06.266Z
Learning: New tests in the parse-server repository should use async/await with promise-based patterns rather than callback patterns with `done()`. The preferred pattern is to create a Promise that resolves when an expected event occurs, then await that Promise.

Note: Learnings are effective only in the context of similar code segments. To apply general coding guidelines, please configure review instructions. You can manage existing learnings in the app.

🧠 Learnings used 
Learnt from: mtrezza
PR: parse-community/parse-server#9445
File: spec/ParseLiveQuery.spec.js:1312-1338
Timestamp: 2025-05-04T20:41:05.147Z
Learning: New tests in the parse-server repository should use async/await with promise-based patterns rather than callback patterns with `done()`.


it('test beforeLiveQueryEvent should filter specific object creation', async function () {
await reconfigureServer({
liveQuery: {
classNames: ['TestObject'],
},
startLiveQueryServer: true,
verbose: false,
silent: true,
});


Parse.Cloud.beforeLiveQueryEvent('TestObject', req => {
expect(req.object.get('foo')).toBe('bar');
if (req.object.get('foo') === 'bar') {
req.context.preventLiveQuery === true;
}
})
Comment on lines +1388 to +1393
Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

⚠️ Potential issue

Fix critical bug in preventLiveQuery logic.

You're using a comparison operator (===) instead of an assignment operator (=), which means you're comparing the value rather than setting it. This would cause the filtering functionality to fail.

-      if (req.object.get('foo') === 'bar') {
-        req.context.preventLiveQuery === true;
+      if (req.object.get('foo') === 'bar') {
+        req.context.preventLiveQuery = true;
       }
📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change
Parse.Cloud.beforeLiveQueryEvent('TestObject', req => {
expect(req.object.get('foo')).toBe('bar');
if (req.object.get('foo') === 'bar') {
req.context.preventLiveQuery === true;
}
})
Parse.Cloud.beforeLiveQueryEvent('TestObject', req => {
expect(req.object.get('foo')).toBe('bar');
if (req.object.get('foo') === 'bar') {
req.context.preventLiveQuery = true;
}
})
🧰 Tools
🪛 ESLint

[error] 1389-1389: 'expect' is not defined.

(no-undef)

🤖 Prompt for AI Agents (early access) 
In spec/ParseLiveQuery.spec.js around lines 1388 to 1393, replace the comparison operator (===) with the assignment operator (=) when setting req.context.preventLiveQuery to true. This change will correctly assign the value and enable the intended filtering functionality.


const query = new Parse.Query(TestObject).equalTo('foo', 'bar');
const subscription = await query.subscribe();
subscription.on('create', () => {
fail('create should not have been called.');
});

const object = new TestObject();
object.set('foo', 'bar');
await object.save();
});

it('test beforeLiveQueryEvent should filter specific object update', async function () {
await reconfigureServer({
liveQuery: {
classNames: ['TestObject'],
},
startLiveQueryServer: true,
verbose: false,
silent: true,
});
const object = new TestObject();
object.set('foo', 'bar');
await object.save();

Parse.Cloud.beforeLiveQueryEvent('TestObject', async req => {
expect(req.object.get('foo')).toBe('baz');
if (req.object.get('foo') === 'baz') {
req.context.preventLiveQuery === true;
}
})
Comment on lines +1419 to +1424
Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

⚠️ Potential issue

Fix critical bug in preventLiveQuery logic.

Same issue as in the previous test - you're using a comparison operator (===) instead of an assignment operator (=).

-      if (req.object.get('foo') === 'baz') {
-        req.context.preventLiveQuery === true;
+      if (req.object.get('foo') === 'baz') {
+        req.context.preventLiveQuery = true;
       }
📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change
Parse.Cloud.beforeLiveQueryEvent('TestObject', async req => {
expect(req.object.get('foo')).toBe('baz');
if (req.object.get('foo') === 'baz') {
req.context.preventLiveQuery === true;
}
})
Parse.Cloud.beforeLiveQueryEvent('TestObject', async req => {
expect(req.object.get('foo')).toBe('baz');
if (req.object.get('foo') === 'baz') {
req.context.preventLiveQuery = true;
}
})
🧰 Tools
🪛 ESLint

[error] 1420-1420: 'expect' is not defined.

(no-undef)

🤖 Prompt for AI Agents (early access) 
In spec/ParseLiveQuery.spec.js around lines 1419 to 1424, the code mistakenly uses the comparison operator (===) instead of the assignment operator (=) when setting req.context.preventLiveQuery. Change req.context.preventLiveQuery === true to req.context.preventLiveQuery = true to correctly assign the value and fix the preventLiveQuery logic.


const query = new Parse.Query(TestObject).equalTo('foo', 'baz');
const subscription = await query.subscribe();
subscription.on('update', object => {
fail('update should not have been called.');
});

object.set('foo', 'baz')
await object.save();
});
});
34 changes: 22 additions & 12 deletions src/RestWrite.js
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1645,7 +1645,7 @@ RestWrite.prototype.runDatabaseOperation = function () {
};

// Returns nothing - doesn't wait for the trigger.
RestWrite.prototype.runAfterSaveTrigger = function () {
RestWrite.prototype.runAfterSaveTrigger = async function () {
if (!this.response || !this.response.response || this.runOptions.many) {
return;
}
Expand All @@ -1660,21 +1660,31 @@ RestWrite.prototype.runAfterSaveTrigger = function () {
if (!hasAfterSaveHook && !hasLiveQuery) {
return Promise.resolve();
}

const { originalObject, updatedObject } = this.buildParseObjects();
updatedObject._handleSaveResponse(this.response.response, this.response.status || 200);

if (hasLiveQuery) {
this.config.database.loadSchema().then(schemaController => {
// Notify LiveQueryServer if possible
const perms = schemaController.getClassLevelPermissions(updatedObject.className);
this.config.liveQueryController.onAfterSave(
updatedObject.className,
updatedObject,
originalObject,
perms
);
});
const hasBeforeEventHook = triggers.triggerExists(
this.className,
triggers.Types.beforeEvent,
this.config.applicationId
);
const publishedObject = updatedObject.clone();
if (hasBeforeEventHook) {
await triggers.maybeRunTrigger(triggers.Types.beforeEvent, this.auth, publishedObject, originalObject, this.config, this.context);
}
if (this.context.preventLiveQuery !== true) {
this.config.database.loadSchema().then(schemaController => {
// Notify LiveQueryServer if possible
const perms = schemaController.getClassLevelPermissions(publishedObject.className);
this.config.liveQueryController.onAfterSave(
publishedObject.className,
publishedObject,
originalObject,
perms
);
});
Comment on lines +1677 to +1686
Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

⚠️ Potential issue

Await the schema call to avoid silent LiveQuery failures

this.config.database.loadSchema() returns a promise, but the surrounding async function does not await or return it.
If the DB lookup rejects (e.g. transient connectivity, schema inconsistency) the rejection becomes an unhandled promise, the catch in the caller never fires and LiveQuery delivery silently fails.

-      this.config.database.loadSchema().then(schemaController => {
-        // Notify LiveQueryServer if possible
-        const perms = schemaController.getClassLevelPermissions(publishedObject.className);
-        this.config.liveQueryController.onAfterSave(
-          publishedObject.className,
-          publishedObject,
-          originalObject,
-          perms
-        );
-      });
+      const schemaController = await this.config.database.loadSchema();
+      // Notify LiveQueryServer if possible
+      const perms = schemaController.getClassLevelPermissions(publishedObject.className);
+      this.config.liveQueryController.onAfterSave(
+        publishedObject.className,
+        publishedObject,
+        originalObject,
+        perms
+      );

This keeps the method “fire-and-forget” semantics for LiveQuery success but still propagates unexpected errors up the promise chain for proper logging / retries.
Please consider the change or add an explicit .catch() to prevent unhandled rejections.

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change
this.config.database.loadSchema().then(schemaController => {
// Notify LiveQueryServer if possible
const perms = schemaController.getClassLevelPermissions(publishedObject.className);
this.config.liveQueryController.onAfterSave(
publishedObject.className,
publishedObject,
originalObject,
perms
);
});
const schemaController = await this.config.database.loadSchema();
// Notify LiveQueryServer if possible
const perms = schemaController.getClassLevelPermissions(publishedObject.className);
this.config.liveQueryController.onAfterSave(
publishedObject.className,
publishedObject,
originalObject,
perms
);
🤖 Prompt for AI Agents (early access) 
In src/RestWrite.js around lines 1677 to 1686, the call to this.config.database.loadSchema() returns a promise that is neither awaited nor returned, causing unhandled promise rejections if it fails. To fix this, modify the code to either await the loadSchema() call or return the promise chain, and add a .catch() handler to properly handle and propagate errors, ensuring that any failures in loading the schema do not silently fail and are logged or retried as needed.

}
}
if (!hasAfterSaveHook) {
return Promise.resolve();
Expand Down
37 changes: 37 additions & 0 deletions src/cloud-code/Parse.Cloud.js
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -604,6 +604,43 @@ ParseCloud.beforeSubscribe = function (parseClass, handler, validationHandler) {
);
};

/**
* Registers a before live query event function.
*
* **Available in Cloud Code only.**
*
* If you want to use beforeLiveQueryEvent for a predefined class in the Parse JavaScript SDK (e.g. {@link Parse.User} or {@link Parse.File}), you should pass the class itself and not the String for arg1.
* ```
* Parse.Cloud.beforeLiveQueryEvent('MyCustomClass', (request) => {
* // code here
* }, (request) => {
* // validation code here
* });
*
* Parse.Cloud.beforeLiveQueryEvent(Parse.User, (request) => {
* // code here
* }, { ...validationObject });
*```
*
* @method beforeLiveQueryEvent
* @name Parse.Cloud.beforeLiveQueryEvent
* @param {(String|Parse.Object)} arg1 The Parse.Object subclass to register the before live query event function for. This can instead be a String that is the className of the subclass.
* @param {Function} func The function to run before a live query event (publish) is made. This function can be async and should take one parameter, a {@link Parse.Cloud.TriggerRequest}.
* @param {(Object|Function)} validator An optional function to help validating cloud code. This function can be an async function and should take one parameter a {@link Parse.Cloud.TriggerRequest}, or a {@link Parse.Cloud.ValidatorObject}.
*/
ParseCloud.beforeLiveQueryEvent = function (parseClass, handler, validationHandler) {
validateValidator(validationHandler);
const className = triggers.getClassName(parseClass);
triggers.addTrigger(
triggers.Types.beforeEvent,
className,
handler,
Parse.applicationId,
validationHandler
);
};


ParseCloud.onLiveQueryEvent = function (handler) {
triggers.addLiveQueryEventHandler(handler, Parse.applicationId);
};
Expand Down
7 changes: 5 additions & 2 deletions src/triggers.js
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -14,6 +14,7 @@ export const Types = {
afterFind: 'afterFind',
beforeConnect: 'beforeConnect',
beforeSubscribe: 'beforeSubscribe',
beforeEvent: 'beforeEvent',
afterEvent: 'afterEvent',
};

Expand Down Expand Up @@ -278,7 +279,8 @@ export function getRequestObject(
triggerType === Types.afterDelete ||
triggerType === Types.beforeLogin ||
triggerType === Types.afterLogin ||
triggerType === Types.afterFind
triggerType === Types.afterFind ||
triggerType === Types.beforeEvent
) {
// Set a copy of the context on the request object.
request.context = Object.assign({}, context);
Expand Down Expand Up @@ -885,7 +887,8 @@ export function maybeRunTrigger(
triggerType === Types.beforeSave ||
triggerType === Types.afterSave ||
triggerType === Types.beforeDelete ||
triggerType === Types.afterDelete
triggerType === Types.afterDelete ||
triggerType === Types.beforeEvent
) {
Object.assign(context, request.context);
}
Expand Down