Skip to content

The open alternative to Salesforce, designed for AI.

Recover SSE live updates after stream teardown and register listeners without delay (#27835)

Thomas Trompette6e217ded668b
diff --git a/packages/twenty-front/src/modules/sse-db-event/components/SSEKeepAliveEffect.tsx b/packages/twenty-front/src/modules/sse-db-event/components/SSEKeepAliveEffect.tsx
index fcba4785a39..c3811dcfd0a 100644
--- a/packages/twenty-front/src/modules/sse-db-event/components/SSEKeepAliveEffect.tsx
+++ b/packages/twenty-front/src/modules/sse-db-event/components/SSEKeepAliveEffect.tsx
@@ -1,6 +1,5 @@
import { SSE_LIVENESS_CHECK_INTERVAL_IN_MS } from '@/sse-db-event/constants/SseLivenessCheckIntervalInMs';
import { SSE_LIVENESS_TIMEOUT_IN_MS } from '@/sse-db-event/constants/SseLivenessTimeoutInMs';
-import { activeQueryListenersState } from '@/sse-db-event/states/activeQueryListenersState';
import { lastSseEventReceivedTimestampState } from '@/sse-db-event/states/lastSseEventReceivedTimestampState';
import { shouldDestroyEventStreamState } from '@/sse-db-event/states/shouldDestroyEventStreamState';
import { sseEventStreamIdState } from '@/sse-db-event/states/sseEventStreamIdState';
@@ -31,7 +30,6 @@ export const SSEKeepAliveEffect = () => {
const timeSinceLastEvent = Date.now() - lastTimestamp;
if (timeSinceLastEvent > SSE_LIVENESS_TIMEOUT_IN_MS) {
- store.set(activeQueryListenersState.atom, []);
store.set(shouldDestroyEventStreamState.atom, true);
}
}, SSE_LIVENESS_CHECK_INTERVAL_IN_MS);
diff --git a/packages/twenty-front/src/modules/sse-db-event/components/SSEQuerySubscribeEffect.tsx b/packages/twenty-front/src/modules/sse-db-event/components/SSEQuerySubscribeEffect.tsx
index 00693210ede..4942bfd824b 100644
--- a/packages/twenty-front/src/modules/sse-db-event/components/SSEQuerySubscribeEffect.tsx
+++ b/packages/twenty-front/src/modules/sse-db-event/components/SSEQuerySubscribeEffect.tsx
@@ -5,17 +5,16 @@ import { requiredQueryListenersState } from '@/sse-db-event/states/requiredQuery
import { shouldDestroyEventStreamState } from '@/sse-db-event/states/shouldDestroyEventStreamState';
import { sseEventStreamIdState } from '@/sse-db-event/states/sseEventStreamIdState';
import { sseEventStreamReadyState } from '@/sse-db-event/states/sseEventStreamReadyState';
+import { createSerialTaskQueuesByKey } from '@/sse-db-event/utils/createSerialTaskQueuesByKey';
+import { isCurrentEventStream } from '@/sse-db-event/utils/isCurrentEventStream';
import { isGracefullyHandledEventStreamError } from '@/sse-db-event/utils/isGracefullyHandledEventStreamError';
import { useAtomStateValue } from '@/ui/utilities/state/jotai/hooks/useAtomStateValue';
import { captureException } from '@sentry/react';
import { useMutation } from '@apollo/client/react';
import { isNonEmptyString } from '@sniptt/guards';
import { useStore } from 'jotai';
-import { useCallback, useEffect } from 'react';
-import {
- compareArraysOfObjectsByProperty,
- isDefined,
-} from 'twenty-shared/utils';
+import { useCallback, useEffect, useMemo } from 'react';
+import { compareArraysOfObjectsByProperty } from 'twenty-shared/utils';
import { useDebouncedCallback } from 'use-debounce';
import {
type AddQuerySubscriptionInput,
@@ -61,130 +60,172 @@ export const SSEQuerySubscribeEffect = () => {
);
}
- store.set(activeQueryListenersState.atom, []);
store.set(shouldDestroyEventStreamState.atom, true);
},
[store],
);
- const syncAdditions = useCallback(async () => {
- if (!isDefined(sseEventStreamId)) {
- return;
- }
+ const syncAdditions = useCallback(
+ async ({ eventStreamId }: { eventStreamId: string }) => {
+ if (
+ !isCurrentEventStream({ store, eventStreamId }) ||
+ !store.get(sseEventStreamReadyState.atom)
+ ) {
+ return;
+ }
- const requiredQueryListeners = store.get(requiredQueryListenersState.atom);
- const activeQueryListeners = store.get(activeQueryListenersState.atom);
+ const requiredQueryListeners = store.get(
+ requiredQueryListenersState.atom,
+ );
+ const activeQueryListeners = store.get(activeQueryListenersState.atom);
- const queryListenersToAdd = requiredQueryListeners.filter(
- (listener) =>
- !activeQueryListeners.some(
- (activeListener) => activeListener.queryId === listener.queryId,
- ),
- );
+ const queryListenersToAdd = requiredQueryListeners.filter(
+ (listener) =>
+ !activeQueryListeners.some(
+ (activeListener) => activeListener.queryId === listener.queryId,
+ ),
+ );
- if (queryListenersToAdd.length === 0) {
- return;
- }
+ if (queryListenersToAdd.length === 0) {
+ return;
+ }
- try {
- for (const queryListenerToAdd of queryListenersToAdd) {
- const result = await addQueryToEventStream({
- variables: {
- input: {
- eventStreamId: sseEventStreamId,
- queryId: queryListenerToAdd.queryId,
- operationSignature: queryListenerToAdd.operationSignature,
+ try {
+ for (const queryListenerToAdd of queryListenersToAdd) {
+ const result = await addQueryToEventStream({
+ variables: {
+ input: {
+ eventStreamId,
+ queryId: queryListenerToAdd.queryId,
+ operationSignature: queryListenerToAdd.operationSignature,
+ },
},
- },
- });
+ });
- if (result.data?.addQueryToEventStream === false) {
- store.set(activeQueryListenersState.atom, []);
- store.set(shouldDestroyEventStreamState.atom, true);
+ if (!isCurrentEventStream({ store, eventStreamId })) {
+ return;
+ }
- return;
- }
- }
- } catch (error) {
- handleError(error);
+ if (result.data?.addQueryToEventStream === false) {
+ store.set(shouldDestroyEventStreamState.atom, true);
- return;
- }
+ return;
+ }
+ }
+ } catch (error) {
+ if (isCurrentEventStream({ store, eventStreamId })) {
+ handleError(error);
+ }
- const currentActive = store.get(activeQueryListenersState.atom);
+ return;
+ }
- store.set(activeQueryListenersState.atom, [
- ...currentActive,
- ...queryListenersToAdd,
- ]);
- }, [addQueryToEventStream, handleError, sseEventStreamId, store]);
+ const currentActive = store.get(activeQueryListenersState.atom);
- const syncRemovals = useCallback(async () => {
- if (!isDefined(sseEventStreamId)) {
- return;
- }
+ store.set(activeQueryListenersState.atom, [
+ ...currentActive,
+ ...queryListenersToAdd,
+ ]);
+ },
+ [addQueryToEventStream, handleError, store],
+ );
- const freshRequiredQueryListeners = store.get(
- requiredQueryListenersState.atom,
- );
- const activeQueryListeners = store.get(activeQueryListenersState.atom);
+ const syncRemovals = useCallback(
+ async ({ eventStreamId }: { eventStreamId: string }) => {
+ if (
+ !isCurrentEventStream({ store, eventStreamId }) ||
+ !store.get(sseEventStreamReadyState.atom)
+ ) {
+ return;
+ }
- const queryListenersToRemove = activeQueryListeners.filter(
- (listener) =>
- !freshRequiredQueryListeners.some(
- (requiredListener) => requiredListener.queryId === listener.queryId,
- ),
- );
+ const freshRequiredQueryListeners = store.get(
+ requiredQueryListenersState.atom,
+ );
+ const activeQueryListeners = store.get(activeQueryListenersState.atom);
- if (queryListenersToRemove.length === 0) {
- return;
- }
+ const queryListenersToRemove = activeQueryListeners.filter(
+ (listener) =>
+ !freshRequiredQueryListeners.some(
+ (requiredListener) => requiredListener.queryId === listener.queryId,
+ ),
+ );
- const removedQueryIds = new Set(
- queryListenersToRemove.map((listener) => listener.queryId),
- );
+ if (queryListenersToRemove.length === 0) {
+ return;
+ }
- try {
- for (const queryListenerToRemove of queryListenersToRemove) {
- const result = await removeQueryFromEventStream({
- variables: {
- input: {
- eventStreamId: sseEventStreamId,
- queryId: queryListenerToRemove.queryId,
+ const removedQueryIds = new Set(
+ queryListenersToRemove.map((listener) => listener.queryId),
+ );
+
+ try {
+ for (const queryListenerToRemove of queryListenersToRemove) {
+ const result = await removeQueryFromEventStream({
+ variables: {
+ input: {
+ eventStreamId,
+ queryId: queryListenerToRemove.queryId,
+ },
},
- },
- });
+ });
- if (result.data?.removeQueryFromEventStream === false) {
- store.set(activeQueryListenersState.atom, []);
- store.set(shouldDestroyEventStreamState.atom, true);
+ if (!isCurrentEventStream({ store, eventStreamId })) {
+ return;
+ }
- return;
+ if (result.data?.removeQueryFromEventStream === false) {
+ store.set(shouldDestroyEventStreamState.atom, true);
+
+ return;
+ }
+ }
+ } catch (error) {
+ if (isCurrentEventStream({ store, eventStreamId })) {
+ handleError(error);
}
+
+ return;
}
- } catch (error) {
- handleError(error);
- return;
- }
+ const currentActive = store.get(activeQueryListenersState.atom);
- const currentActive = store.get(activeQueryListenersState.atom);
+ store.set(
+ activeQueryListenersState.atom,
+ currentActive.filter(
+ (listener) => !removedQueryIds.has(listener.queryId),
+ ),
+ );
+ },
+ [handleError, removeQueryFromEventStream, store],
+ );
- store.set(
- activeQueryListenersState.atom,
- currentActive.filter(
- (listener) => !removedQueryIds.has(listener.queryId),
- ),
- );
- }, [handleError, removeQueryFromEventStream, sseEventStreamId, store]);
+ const queryListenersSyncQueuesByEventStreamId = useMemo(
+ () => createSerialTaskQueuesByKey(),
+ [],
+ );
- const debouncedSyncAdditions = useDebouncedCallback(syncAdditions, 1000, {
- leading: true,
- });
+ const enqueueQueryListenersSync = useCallback(
+ (sync: (params: { eventStreamId: string }) => Promise<void>) => {
+ const eventStreamId = store.get(sseEventStreamIdState.atom);
- const debouncedSyncRemovals = useDebouncedCallback(syncRemovals, 200, {
- leading: false,
- });
+ if (!isNonEmptyString(eventStreamId)) {
+ return;
+ }
+
+ void queryListenersSyncQueuesByEventStreamId.enqueue({
+ key: eventStreamId,
+ task: () => sync({ eventStreamId }),
+ });
+ },
+ [queryListenersSyncQueuesByEventStreamId, store],
+ );
+
+ const debouncedEnqueueSyncRemovals = useDebouncedCallback(
+ () => enqueueQueryListenersSync(syncRemovals),
+ 200,
+ { leading: false },
+ );
useEffect(() => {
if (!isNonEmptyString(sseEventStreamId) || !sseEventStreamReady) {
@@ -216,19 +257,20 @@ export const SSEQuerySubscribeEffect = () => {
);
if (hasAdditions) {
- debouncedSyncAdditions();
+ enqueueQueryListenersSync(syncAdditions);
}
if (hasRemovals) {
- debouncedSyncRemovals();
+ debouncedEnqueueSyncRemovals();
}
}, [
sseEventStreamId,
sseEventStreamReady,
requiredQueryListeners,
activeQueryListeners,
- debouncedSyncAdditions,
- debouncedSyncRemovals,
+ enqueueQueryListenersSync,
+ syncAdditions,
+ debouncedEnqueueSyncRemovals,
]);
return null;
diff --git a/packages/twenty-front/src/modules/sse-db-event/components/__tests__/SSEQuerySubscribeEffect.test.tsx b/packages/twenty-front/src/modules/sse-db-event/components/__tests__/SSEQuerySubscribeEffect.test.tsx
new file mode 100644
index 00000000000..3d91b1f4f09
--- /dev/null
+++ b/packages/twenty-front/src/modules/sse-db-event/components/__tests__/SSEQuerySubscribeEffect.test.tsx
@@ -0,0 +1,188 @@
+import { act, render } from '@testing-library/react';
+import { type DocumentNode } from 'graphql';
+import { createStore, Provider } from 'jotai';
+
+import { SSEQuerySubscribeEffect } from '@/sse-db-event/components/SSEQuerySubscribeEffect';
+import { activeQueryListenersState } from '@/sse-db-event/states/activeQueryListenersState';
+import { requiredQueryListenersState } from '@/sse-db-event/states/requiredQueryListenersState';
+import { sseEventStreamIdState } from '@/sse-db-event/states/sseEventStreamIdState';
+import { sseEventStreamReadyState } from '@/sse-db-event/states/sseEventStreamReadyState';
+
+type MockSentMutation = {
+ operationName: string;
+ eventStreamId: string;
+ queryId: string;
+ resolve: () => void;
+};
+
+const mockSentMutations: MockSentMutation[] = [];
+
+const mockSendMutation =
+ (operationName: string) =>
+ ({
+ variables,
+ }: {
+ variables: { input: { eventStreamId: string; queryId: string } };
+ }) =>
+ new Promise((resolve) => {
+ mockSentMutations.push({
+ operationName,
+ eventStreamId: variables.input.eventStreamId,
+ queryId: variables.input.queryId,
+ resolve: () =>
+ resolve({
+ data: {
+ [operationName === 'AddQueryToEventStream'
+ ? 'addQueryToEventStream'
+ : 'removeQueryFromEventStream']: true,
+ },
+ }),
+ });
+ });
+
+const mockAddQueryToEventStream = mockSendMutation('AddQueryToEventStream');
+const mockRemoveQueryFromEventStream = mockSendMutation(
+ 'RemoveQueryFromEventStream',
+);
+
+jest.mock('@apollo/client/react', () => ({
+ useMutation: (document: DocumentNode) => {
+ const definition = document.definitions[0];
+
+ return [
+ 'name' in definition && definition.name?.value === 'AddQueryToEventStream'
+ ? mockAddQueryToEventStream
+ : mockRemoveQueryFromEventStream,
+ ];
+ },
+}));
+
+const buildQueryListener = (queryId: string) => ({
+ queryId,
+ operationSignature: { objectNameSingular: 'workflowRun', variables: {} },
+});
+
+const getSentMutations = () =>
+ mockSentMutations.map(({ operationName, queryId }) => ({
+ operationName,
+ queryId,
+ }));
+
+const flushAfter = async (callback: () => void = () => {}) => {
+ await act(async () => {
+ callback();
+ await new Promise((resolve) => setTimeout(resolve, 0));
+ });
+};
+
+const setup = ({
+ queryListeners = [],
+}: {
+ queryListeners?: ReturnType<typeof buildQueryListener>[];
+} = {}) => {
+ const store = createStore();
+
+ store.set(sseEventStreamIdState.atom, 'event-stream-1');
+ store.set(sseEventStreamReadyState.atom, true);
+ store.set(requiredQueryListenersState.atom, queryListeners);
+ store.set(activeQueryListenersState.atom, queryListeners);
+
+ render(
+ <Provider store={store}>
+ <SSEQuerySubscribeEffect />
+ </Provider>,
+ );
+
+ return { store };
+};
+
+describe('SSEQuerySubscribeEffect', () => {
+ beforeEach(() => {
+ mockSentMutations.length = 0;
+ });
+
+ it('should register a listener as soon as the previous registration settles', async () => {
+ const { store } = setup();
+
+ await flushAfter(() =>
+ store.set(requiredQueryListenersState.atom, [
+ buildQueryListener('record-table'),
+ ]),
+ );
+
+ await flushAfter(() =>
+ store.set(requiredQueryListenersState.atom, [
+ buildQueryListener('record-table'),
+ buildQueryListener('workflow-run'),
+ ]),
+ );
+
+ expect(getSentMutations()).toEqual([
+ { operationName: 'AddQueryToEventStream', queryId: 'record-table' },
+ ]);
+
+ await flushAfter(() => mockSentMutations[0].resolve());
+
+ expect(getSentMutations()).toEqual([
+ { operationName: 'AddQueryToEventStream', queryId: 'record-table' },
+ { operationName: 'AddQueryToEventStream', queryId: 'workflow-run' },
+ ]);
+
+ await flushAfter(() => mockSentMutations[1].resolve());
+
+ expect(
+ store.get(activeQueryListenersState.atom).map(({ queryId }) => queryId),
+ ).toEqual(['record-table', 'workflow-run']);
+ });
+
+ it('should wait for an in-flight registration before removing a listener', async () => {
+ const { store } = setup({
+ queryListeners: [buildQueryListener('closed-panel')],
+ });
+
+ await flushAfter(() =>
+ store.set(requiredQueryListenersState.atom, [
+ buildQueryListener('opened-panel'),
+ ]),
+ );
+
+ await act(async () => {
+ await new Promise((resolve) => setTimeout(resolve, 250));
+ });
+
+ expect(getSentMutations()).toEqual([
+ { operationName: 'AddQueryToEventStream', queryId: 'opened-panel' },
+ ]);
+
+ await flushAfter(() => mockSentMutations[0].resolve());
+
+ expect(getSentMutations()).toEqual([
+ { operationName: 'AddQueryToEventStream', queryId: 'opened-panel' },
+ { operationName: 'RemoveQueryFromEventStream', queryId: 'closed-panel' },
+ ]);
+ });
+
+ it('should register listeners on a new stream while a request to the previous one is still pending', async () => {
+ const { store } = setup();
+
+ await flushAfter(() =>
+ store.set(requiredQueryListenersState.atom, [
+ buildQueryListener('record-table'),
+ ]),
+ );
+
+ await flushAfter(() =>
+ store.set(sseEventStreamIdState.atom, 'event-stream-2'),
+ );
+
+ expect(
+ mockSentMutations.map(({ eventStreamId, queryId }) => ({
+ eventStreamId,
+ queryId,
+ })),
+ ).toEqual([
+ { eventStreamId: 'event-stream-1', queryId: 'record-table' },
+ { eventStreamId: 'event-stream-2', queryId: 'record-table' },
+ ]);
+ });
+});
diff --git a/packages/twenty-front/src/modules/sse-db-event/hooks/__tests__/useTriggerEventStreamCreation.test.tsx b/packages/twenty-front/src/modules/sse-db-event/hooks/__tests__/useTriggerEventStreamCreation.test.tsx
new file mode 100644
index 00000000000..05f37c22e3a
--- /dev/null
+++ b/packages/twenty-front/src/modules/sse-db-event/hooks/__tests__/useTriggerEventStreamCreation.test.tsx
@@ -0,0 +1,139 @@
+import { act, renderHook } from '@testing-library/react';
+import { type Client } from 'graphql-sse';
+import { createStore, Provider } from 'jotai';
+import { createElement, type ReactNode } from 'react';
+
+import { useTriggerEventStreamCreation } from '@/sse-db-event/hooks/useTriggerEventStreamCreation';
+import { useTriggerEventStreamDestroy } from '@/sse-db-event/hooks/useTriggerEventStreamDestroy';
+import { activeQueryListenersState } from '@/sse-db-event/states/activeQueryListenersState';
+import { shouldDestroyEventStreamState } from '@/sse-db-event/states/shouldDestroyEventStreamState';
+import { sseClientState } from '@/sse-db-event/states/sseClientState';
+import { sseEventStreamIdState } from '@/sse-db-event/states/sseEventStreamIdState';
+
+jest.mock(
+ '@/sse-db-event/hooks/useDispatchMetadataEventsFromSseToBrowserEvents',
+ () => ({
+ useDispatchMetadataEventsFromSseToBrowserEvents: () => ({
+ dispatchMetadataEventsFromSseToBrowserEvents: jest.fn(),
+ }),
+ }),
+);
+
+jest.mock(
+ '@/sse-db-event/hooks/useDispatchObjectRecordEventsFromSseToBrowserEvents',
+ () => ({
+ useDispatchObjectRecordEventsFromSseToBrowserEvents: () => ({
+ dispatchObjectRecordEventsFromSseToBrowserEvents: jest.fn(),
+ }),
+ }),
+);
+
+jest.mock(
+ '@/sse-db-event/hooks/useTriggerOptimisticEffectFromSseEvents',
+ () => ({
+ useTriggerOptimisticEffectFromSseEvents: () => ({
+ triggerOptimisticEffectFromSseEvents: jest.fn(),
+ }),
+ }),
+);
+
+const buildSseClientCompletingAfterDispose = () => {
+ const completeSubscriptionCallbacks: (() => void)[] = [];
+
+ const sseClient: Client = {
+ subscribe: (_request, sink) => {
+ completeSubscriptionCallbacks.push(() => sink.complete());
+
+ return () => {
+ void Promise.resolve().then(() => sink.complete());
+ };
+ },
+ iterate: async function* () {},
+ dispose: jest.fn(),
+ };
+
+ return { sseClient, completeSubscriptionCallbacks };
+};
+
+const setup = () => {
+ const store = createStore();
+ const { sseClient, completeSubscriptionCallbacks } =
+ buildSseClientCompletingAfterDispose();
+
+ store.set(sseClientState.atom, sseClient);
+
+ const wrapper = ({ children }: { children: ReactNode }) =>
+ createElement(Provider, { store }, children);
+
+ const { result } = renderHook(
+ () => ({
+ ...useTriggerEventStreamCreation(),
+ ...useTriggerEventStreamDestroy(),
+ }),
+ { wrapper },
+ );
+
+ return { store, completeSubscriptionCallbacks, result };
+};
+
+describe('useTriggerEventStreamCreation', () => {
+ it('should let a new stream be created after destroying a live one', async () => {
+ const { store, completeSubscriptionCallbacks, result } = setup();
+
+ act(() => {
+ result.current.triggerEventStreamCreation();
+ });
+
+ const firstEventStreamId = store.get(sseEventStreamIdState.atom);
+
+ await act(async () => {
+ result.current.triggerEventStreamDestroy();
+ await Promise.resolve();
+ });
+
+ expect(store.get(shouldDestroyEventStreamState.atom)).toBe(false);
+ expect(store.get(sseEventStreamIdState.atom)).toBeNull();
+
+ act(() => {
+ result.current.triggerEventStreamCreation();
+ });
+
+ expect(completeSubscriptionCallbacks).toHaveLength(2);
+ expect(store.get(sseEventStreamIdState.atom)).not.toBe(firstEventStreamId);
+ });
+
+ it('should clear the active listeners when destroying the stream', () => {
+ const { store, result } = setup();
+
+ act(() => {
+ result.current.triggerEventStreamCreation();
+ });
+
+ store.set(activeQueryListenersState.atom, [
+ {
+ queryId: 'record-table-virtualized-company',
+ operationSignature: { objectNameSingular: 'company', variables: {} },
+ },
+ ]);
+
+ act(() => {
+ result.current.triggerEventStreamDestroy();
+ });
+
+ expect(store.get(activeQueryListenersState.atom)).toEqual([]);
+ });
+
+ it('should request a destroy when the current stream completes', () => {
+ const { store, completeSubscriptionCallbacks, result } = setup();
+
+ act(() => {
+ result.current.triggerEventStreamCreation();
+ });
+
+ act(() => {
+ completeSubscriptionCallbacks[0]();
+ });
+
+ expect(store.get(shouldDestroyEventStreamState.atom)).toBe(true);
+ });
+});
diff --git a/packages/twenty-front/src/modules/sse-db-event/hooks/useTriggerEventStreamCreation.ts b/packages/twenty-front/src/modules/sse-db-event/hooks/useTriggerEventStreamCreation.ts
index b0e6cb0ee3a..867d8db236d 100644
--- a/packages/twenty-front/src/modules/sse-db-event/hooks/useTriggerEventStreamCreation.ts
+++ b/packages/twenty-front/src/modules/sse-db-event/hooks/useTriggerEventStreamCreation.ts
@@ -13,6 +13,7 @@ import { shouldDestroyEventStreamState } from '@/sse-db-event/states/shouldDestr
import { sseClientState } from '@/sse-db-event/states/sseClientState';
import { sseEventStreamIdState } from '@/sse-db-event/states/sseEventStreamIdState';
import { sseEventStreamReadyState } from '@/sse-db-event/states/sseEventStreamReadyState';
+import { isCurrentEventStream } from '@/sse-db-event/utils/isCurrentEventStream';
import { isGracefullyHandledEventStreamError } from '@/sse-db-event/utils/isGracefullyHandledEventStreamError';
import { useSetAtomState } from '@/ui/utilities/state/jotai/hooks/useSetAtomState';
import { captureException } from '@sentry/react';
@@ -168,6 +169,12 @@ export const useTriggerEventStreamCreation = () => {
store.set(shouldDestroyEventStreamState.atom, true);
},
complete: () => {
+ if (
+ !isCurrentEventStream({ store, eventStreamId: newSseEventStreamId })
+ ) {
+ return;
+ }
+
store.set(shouldDestroyEventStreamState.atom, true);
},
},
diff --git a/packages/twenty-front/src/modules/sse-db-event/hooks/useTriggerEventStreamDestroy.ts b/packages/twenty-front/src/modules/sse-db-event/hooks/useTriggerEventStreamDestroy.ts
index f3d836f3086..78f000087d1 100644
--- a/packages/twenty-front/src/modules/sse-db-event/hooks/useTriggerEventStreamDestroy.ts
+++ b/packages/twenty-front/src/modules/sse-db-event/hooks/useTriggerEventStreamDestroy.ts
@@ -1,3 +1,4 @@
+import { activeQueryListenersState } from '@/sse-db-event/states/activeQueryListenersState';
import { disposeFunctionForEventStreamState } from '@/sse-db-event/states/disposeFunctionByEventStreamMapState';
import { isCreatingSseEventStreamState } from '@/sse-db-event/states/isCreatingSseEventStreamState';
import { isDestroyingEventStreamState } from '@/sse-db-event/states/isDestroyingEventStreamState';
@@ -40,6 +41,7 @@ export const useTriggerEventStreamDestroy = () => {
disposeFunctionForEventStream?.dispose();
store.set(sseEventStreamIdState.atom, null);
+ store.set(activeQueryListenersState.atom, []);
store.set(sseEventStreamReadyState.atom, false);
store.set(disposeFunctionForEventStreamState.atom, null);
store.set(shouldDestroyEventStreamState.atom, false);
diff --git a/packages/twenty-front/src/modules/sse-db-event/utils/__tests__/createSerialTaskQueuesByKey.test.ts b/packages/twenty-front/src/modules/sse-db-event/utils/__tests__/createSerialTaskQueuesByKey.test.ts
new file mode 100644
index 00000000000..7cc7369660b
--- /dev/null
+++ b/packages/twenty-front/src/modules/sse-db-event/utils/__tests__/createSerialTaskQueuesByKey.test.ts
@@ -0,0 +1,82 @@
+import { createSerialTaskQueuesByKey } from '@/sse-db-event/utils/createSerialTaskQueuesByKey';
+
+const createDeferred = () => {
+ let resolve: () => void = () => {};
+ let reject: (error: Error) => void = () => {};
+
+ const promise = new Promise<void>((resolvePromise, rejectPromise) => {
+ resolve = resolvePromise;
+ reject = rejectPromise;
+ });
+
+ return { promise, resolve, reject };
+};
+
+describe('createSerialTaskQueuesByKey', () => {
+ it('should start a task only once the previous one with the same key has settled', async () => {
+ const queues = createSerialTaskQueuesByKey();
+ const firstTask = createDeferred();
+ const startedTasks: string[] = [];
+
+ void queues.enqueue({
+ key: 'event-stream-1',
+ task: () => {
+ startedTasks.push('first');
+
+ return firstTask.promise;
+ },
+ });
+
+ const secondTaskDone = queues.enqueue({
+ key: 'event-stream-1',
+ task: async () => {
+ startedTasks.push('second');
+ },
+ });
+
+ await Promise.resolve();
+
+ expect(startedTasks).toEqual(['first']);
+
+ firstTask.resolve();
+ await secondTaskDone;
+
+ expect(startedTasks).toEqual(['first', 'second']);
+ });
+
+ it('should not make a task wait for a pending task with another key', async () => {
+ const queues = createSerialTaskQueuesByKey();
+ const pendingTask = createDeferred();
+ const otherKeyTask = jest.fn(async () => {});
+
+ void queues.enqueue({
+ key: 'event-stream-1',
+ task: () => pendingTask.promise,
+ });
+ await queues.enqueue({ key: 'event-stream-2', task: otherKeyTask });
+
+ expect(otherKeyTask).toHaveBeenCalledTimes(1);
+ });
+
+ it('should keep running tasks after one fails', async () => {
+ const queues = createSerialTaskQueuesByKey();
+ const failingTask = createDeferred();
+ const nextTask = jest.fn(async () => {});
+
+ const failingTaskDone = queues.enqueue({
+ key: 'event-stream-1',
+ task: () => failingTask.promise,
+ });
+ const nextTaskDone = queues.enqueue({
+ key: 'event-stream-1',
+ task: nextTask,
+ });
+
+ failingTask.reject(new Error('Network error'));
+
+ await expect(failingTaskDone).rejects.toThrow('Network error');
+ await nextTaskDone;
+
+ expect(nextTask).toHaveBeenCalledTimes(1);
+ });
+});
diff --git a/packages/twenty-front/src/modules/sse-db-event/utils/createSerialTaskQueuesByKey.ts b/packages/twenty-front/src/modules/sse-db-event/utils/createSerialTaskQueuesByKey.ts
new file mode 100644
index 00000000000..3c53e09a641
--- /dev/null
+++ b/packages/twenty-front/src/modules/sse-db-event/utils/createSerialTaskQueuesByKey.ts
@@ -0,0 +1,26 @@
+export const createSerialTaskQueuesByKey = () => {
+ const lastTaskByKey = new Map<string, Promise<void>>();
+
+ const enqueue = ({
+ key,
+ task,
+ }: {
+ key: string;
+ task: () => Promise<void>;
+ }) => {
+ const nextTask = (lastTaskByKey.get(key) ?? Promise.resolve()).then(task);
+ const settledTask = nextTask.catch(() => undefined);
+
+ lastTaskByKey.set(key, settledTask);
+
+ void settledTask.then(() => {
+ if (lastTaskByKey.get(key) === settledTask) {
+ lastTaskByKey.delete(key);
+ }
+ });
+
+ return nextTask;
+ };
+
+ return { enqueue };
+};
diff --git a/packages/twenty-front/src/modules/sse-db-event/utils/isCurrentEventStream.ts b/packages/twenty-front/src/modules/sse-db-event/utils/isCurrentEventStream.ts
new file mode 100644
index 00000000000..9b0b8977084
--- /dev/null
+++ b/packages/twenty-front/src/modules/sse-db-event/utils/isCurrentEventStream.ts
@@ -0,0 +1,11 @@
+import { type Store } from 'jotai/vanilla/store';
+
+import { sseEventStreamIdState } from '@/sse-db-event/states/sseEventStreamIdState';
+
+export const isCurrentEventStream = ({
+ store,
+ eventStreamId,
+}: {
+ store: Store;
+ eventStreamId: string;
+}) => store.get(sseEventStreamIdState.atom) === eventStreamId;