The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
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.tsxindex 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.tsxindex 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/requiredQueryimport { 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsindex 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/shouldDestrimport { 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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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;