Skip to content

The open alternative to Salesforce, designed for AI.

fix(twenty-server): notify SSE subscribers when an update leaves their filtered view (#23858)

Charles Bocheta47f566eb151
diff --git a/packages/twenty-server/src/engine/subscriptions/object-record-event/__tests__/object-record-event-publisher.spec.ts b/packages/twenty-server/src/engine/subscriptions/object-record-event/__tests__/object-record-event-publisher.spec.ts
index 2e1d7dbbac5..285533e5f7e 100644
--- a/packages/twenty-server/src/engine/subscriptions/object-record-event/__tests__/object-record-event-publisher.spec.ts
+++ b/packages/twenty-server/src/engine/subscriptions/object-record-event/__tests__/object-record-event-publisher.spec.ts
@@ -475,6 +475,157 @@ describe('ObjectRecordEventPublisher', () => {
).not.toHaveBeenCalled();
});
+ it('should publish update events when only the BEFORE state matches the filter (record leaving the view)', async () => {
+ (
+ isRecordMatchingRLSRowLevelPermissionPredicate as jest.Mock
+ ).mockImplementation(
+ ({ record }: { record: { name?: string } }) =>
+ record.name === 'Open Company',
+ );
+
+ const streamDataWithFilter: EventStreamData = {
+ ...mockStreamData,
+ queries: {
+ 'query-1': {
+ objectNameSingular: 'company',
+ variables: {
+ filter: { name: { eq: 'Open Company' } },
+ },
+ },
+ },
+ };
+
+ mockEventStreamService.getStreamsData.mockResolvedValue(
+ new Map([[streamChannelId, streamDataWithFilter]]) as Map<
+ string,
+ EventStreamData | undefined
+ >,
+ );
+
+ const eventBatch: WorkspaceEventBatch<MockObjectRecordEvent> = {
+ name: 'company.updated',
+ workspaceId,
+ objectMetadata: companyObjectMetadata,
+ events: [
+ createMockEvent({
+ properties: {
+ before: { id: 'record-1', name: 'Open Company' },
+ after: { id: 'record-1', name: 'Done Company' },
+ } as MockObjectRecordEvent['properties'],
+ }),
+ ],
+ };
+
+ await service.publish(eventBatch as WorkspaceEventBatch<never>);
+
+ expect(
+ mockSubscriptionService.publishToEventStream,
+ ).toHaveBeenCalledTimes(1);
+ const publishCall = (
+ mockSubscriptionService.publishToEventStream as jest.Mock
+ ).mock.calls[0][0];
+
+ expect(publishCall.payload.objectRecordEventsWithQueryIds).toHaveLength(
+ 1,
+ );
+ expect(
+ publishCall.payload.objectRecordEventsWithQueryIds[0].queryIds,
+ ).toEqual(['query-1']);
+ });
+
+ it('should not publish update events when the delivered state fails the RLS filter, even if the before state matched', async () => {
+ const rlsFilter: RecordGqlOperationFilter = { status: { eq: 'active' } };
+
+ (buildRowLevelPermissionRecordFilter as jest.Mock).mockReturnValue(
+ rlsFilter,
+ );
+
+ (
+ isRecordMatchingRLSRowLevelPermissionPredicate as jest.Mock
+ ).mockImplementation(
+ ({
+ record,
+ filter,
+ }: {
+ record: { status?: string };
+ filter: RecordGqlOperationFilter;
+ }) => ('status' in filter ? record.status === 'active' : true),
+ );
+
+ const eventBatch: WorkspaceEventBatch<MockObjectRecordEvent> = {
+ name: 'company.updated',
+ workspaceId,
+ objectMetadata: companyObjectMetadata,
+ events: [
+ createMockEvent({
+ properties: {
+ before: {
+ id: 'record-1',
+ name: 'Test Company',
+ status: 'active',
+ },
+ after: {
+ id: 'record-1',
+ name: 'Test Company',
+ status: 'archived',
+ },
+ } as MockObjectRecordEvent['properties'],
+ }),
+ ],
+ };
+
+ await service.publish(eventBatch as WorkspaceEventBatch<never>);
+
+ expect(
+ mockSubscriptionService.publishToEventStream,
+ ).not.toHaveBeenCalled();
+ });
+
+ it('should not publish update events when neither state matches the filter', async () => {
+ (
+ isRecordMatchingRLSRowLevelPermissionPredicate as jest.Mock
+ ).mockReturnValue(false);
+
+ const streamDataWithFilter: EventStreamData = {
+ ...mockStreamData,
+ queries: {
+ 'query-1': {
+ objectNameSingular: 'company',
+ variables: {
+ filter: { name: { eq: 'Open Company' } },
+ },
+ },
+ },
+ };
+
+ mockEventStreamService.getStreamsData.mockResolvedValue(
+ new Map([[streamChannelId, streamDataWithFilter]]) as Map<
+ string,
+ EventStreamData | undefined
+ >,
+ );
+
+ const eventBatch: WorkspaceEventBatch<MockObjectRecordEvent> = {
+ name: 'company.updated',
+ workspaceId,
+ objectMetadata: companyObjectMetadata,
+ events: [
+ createMockEvent({
+ properties: {
+ before: { id: 'record-1', name: 'Unrelated A' },
+ after: { id: 'record-1', name: 'Unrelated B' },
+ } as MockObjectRecordEvent['properties'],
+ }),
+ ],
+ };
+
+ await service.publish(eventBatch as WorkspaceEventBatch<never>);
+
+ expect(
+ mockSubscriptionService.publishToEventStream,
+ ).not.toHaveBeenCalled();
+ });
+
it('should filter restricted fields from events', async () => {
const restrictedField = getFlatFieldMetadataMock({
objectMetadataId: companyObjectMetadata.id,
@@ -915,7 +1066,7 @@ describe('ObjectRecordEventPublisher', () => {
});
});
- it('should combine query filter with RLS filter', async () => {
+ it('should check the RLS filter and the query filter separately', async () => {
const rlsFilter: RecordGqlOperationFilter = { status: { eq: 'active' } };
(buildRowLevelPermissionRecordFilter as jest.Mock).mockReturnValue(
@@ -968,12 +1119,18 @@ describe('ObjectRecordEventPublisher', () => {
name: 'Test Company',
status: 'active',
}),
- filter: expect.objectContaining({
- and: expect.arrayContaining([
- { name: { eq: 'Test Company' } },
- { status: { eq: 'active' } },
- ]),
+ filter: { status: { eq: 'active' } },
+ }),
+ );
+ expect(
+ isRecordMatchingRLSRowLevelPermissionPredicate,
+ ).toHaveBeenCalledWith(
+ expect.objectContaining({
+ record: expect.objectContaining({
+ name: 'Test Company',
+ status: 'active',
}),
+ filter: { name: { eq: 'Test Company' } },
}),
);
});
diff --git a/packages/twenty-server/src/engine/subscriptions/object-record-event/object-record-event-publisher.ts b/packages/twenty-server/src/engine/subscriptions/object-record-event/object-record-event-publisher.ts
index cbb71085e67..1211d257610 100644
--- a/packages/twenty-server/src/engine/subscriptions/object-record-event/object-record-event-publisher.ts
+++ b/packages/twenty-server/src/engine/subscriptions/object-record-event/object-record-event-publisher.ts
@@ -12,7 +12,6 @@ import {
type RestrictedFieldsPermissions,
} from 'twenty-shared/types';
import {
- combineFilters,
isDefined,
isNonEmptyArray,
isRecordGqlOperationSignature,
@@ -547,37 +546,50 @@ export class ObjectRecordEventPublisher {
before?: object;
};
- const record = properties?.after ?? properties?.before;
+ const deliveredRecord = properties?.after ?? properties?.before;
- if (!isDefined(record)) {
+ if (!isDefined(deliveredRecord)) {
return false;
}
- const queryFilter = operationSignature.variables?.filter ?? {};
-
- const filtersToApply: RecordGqlOperationFilter[] = [queryFilter];
+ const shouldIgnoreSoftDeleteDefaultFilter =
+ event.action === DatabaseEventAction.DELETED ||
+ event.action === DatabaseEventAction.RESTORED;
- if (subscriberRLSFilter && Object.keys(subscriberRLSFilter).length > 0) {
- filtersToApply.push(subscriberRLSFilter);
+ if (
+ isDefined(subscriberRLSFilter) &&
+ Object.keys(subscriberRLSFilter).length > 0 &&
+ !isRecordMatchingRLSRowLevelPermissionPredicate({
+ record: deliveredRecord,
+ filter: subscriberRLSFilter,
+ flatObjectMetadata: objectMetadata,
+ flatFieldMetadataMaps,
+ shouldIgnoreSoftDeleteDefaultFilter,
+ })
+ ) {
+ return false;
}
- const combinedFilter = combineFilters(filtersToApply);
+ const queryFilter = operationSignature.variables?.filter ?? {};
- if (Object.keys(combinedFilter).length === 0) {
+ if (Object.keys(queryFilter).length === 0) {
return true;
}
- const shouldIgnoreSoftDeleteDefaultFilter =
- event.action === DatabaseEventAction.DELETED ||
- event.action === DatabaseEventAction.RESTORED;
-
- return isRecordMatchingRLSRowLevelPermissionPredicate({
- record,
- filter: combinedFilter,
- flatObjectMetadata: objectMetadata,
- flatFieldMetadataMaps,
- shouldIgnoreSoftDeleteDefaultFilter,
- });
+ const candidateRecords =
+ event.action === DatabaseEventAction.UPDATED
+ ? [properties?.after, properties?.before].filter(isDefined)
+ : [deliveredRecord];
+
+ return candidateRecords.some((record) =>
+ isRecordMatchingRLSRowLevelPermissionPredicate({
+ record,
+ filter: queryFilter,
+ flatObjectMetadata: objectMetadata,
+ flatFieldMetadataMaps,
+ shouldIgnoreSoftDeleteDefaultFilter,
+ }),
+ );
}
private async fetchPermissionsContext(