Skip to content

The open alternative to Salesforce, designed for AI.

Fix stale metadata in SSE events (#27604)

Raphaël Bosi92dcb712518a
diff --git a/packages/twenty-front/src/modules/sse-db-event/components/SSEEventStreamEffect.tsx b/packages/twenty-front/src/modules/sse-db-event/components/SSEEventStreamEffect.tsx
index dda08d36b77..a5586e26ab9 100644
--- a/packages/twenty-front/src/modules/sse-db-event/components/SSEEventStreamEffect.tsx
+++ b/packages/twenty-front/src/modules/sse-db-event/components/SSEEventStreamEffect.tsx
@@ -1,5 +1,6 @@
import { useIsLogged } from '@/auth/hooks/useIsLogged';
import { currentUserState } from '@/auth/states/currentUserState';
+import { isMinimalMetadataReadyState } from '@/metadata-store/states/isMinimalMetadataReadyState';
import { objectMetadataItemsSelector } from '@/object-metadata/states/objectMetadataItemsSelector';
import { useTriggerEventStreamCreation } from '@/sse-db-event/hooks/useTriggerEventStreamCreation';
import { useTriggerEventStreamDestroy } from '@/sse-db-event/hooks/useTriggerEventStreamDestroy';
@@ -15,6 +16,7 @@ import { OnboardingStatus } from '~/generated-metadata/graphql';
export const SSEEventStreamEffect = () => {
const objectMetadataItems = useAtomStateValue(objectMetadataItemsSelector);
+ const isMinimalMetadataReady = useAtomStateValue(isMinimalMetadataReadyState);
const sseEventStreamId = useAtomStateValue(sseEventStreamIdState);
const isCreatingSseEventStream = useAtomStateValue(
@@ -42,6 +44,7 @@ export const SSEEventStreamEffect = () => {
isLogged &&
isDefined(currentUser) &&
currentUser.onboardingStatus === OnboardingStatus.COMPLETED &&
+ isMinimalMetadataReady &&
!shouldDestroyEventStream &&
!isNonEmptyString(sseEventStreamId) &&
isNonEmptyArray(objectMetadataItems);
@@ -66,6 +69,7 @@ export const SSEEventStreamEffect = () => {
shouldDestroyEventStream,
sseEventStreamId,
objectMetadataItems,
+ isMinimalMetadataReady,
]);
return null;
diff --git a/packages/twenty-front/src/modules/sse-db-event/components/__stories__/SSEProvider.stories.tsx b/packages/twenty-front/src/modules/sse-db-event/components/__stories__/SSEProvider.stories.tsx
new file mode 100644
index 00000000000..e1b97e795fc
--- /dev/null
+++ b/packages/twenty-front/src/modules/sse-db-event/components/__stories__/SSEProvider.stories.tsx
@@ -0,0 +1,142 @@
+import { currentUserState } from '@/auth/states/currentUserState';
+import { currentWorkspaceState } from '@/auth/states/currentWorkspaceState';
+import { isCookieAuthActiveState } from '@/auth/states/isCookieAuthActiveState';
+import { IsMinimalMetadataReadyEffect } from '@/metadata-store/effect-components/IsMinimalMetadataReadyEffect';
+import { isMinimalMetadataReadyState } from '@/metadata-store/states/isMinimalMetadataReadyState';
+import { metadataStoreState } from '@/metadata-store/states/metadataStoreState';
+import { SSEProvider } from '@/sse-db-event/components/SSEProvider';
+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 { useAtomStateValue } from '@/ui/utilities/state/jotai/hooks/useAtomStateValue';
+import { jotaiStore } from '@/ui/utilities/state/jotai/jotaiStore';
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import { isNonEmptyString } from '@sniptt/guards';
+import { useStore } from 'jotai';
+import { http, HttpResponse } from 'msw';
+import { expect, userEvent, within } from 'storybook/test';
+import { Button } from 'twenty-ui/primitives/input';
+import { CatalogDecorator } from 'twenty-ui/testing';
+import { REACT_APP_SERVER_BASE_URL } from '~/config';
+import {
+ mockCurrentWorkspace,
+ mockedUserData,
+} from '~/testing/mock-data/users';
+import { getTestEnrichedObjectMetadataItemsMock } from '~/testing/utils/getTestEnrichedObjectMetadataItemsMock';
+import { setTestObjectMetadataItemsInMetadataStore } from '~/testing/utils/setTestObjectMetadataItemsInMetadataStore';
+import { setTestViewsInMetadataStore } from '~/testing/utils/setTestViewsInMetadataStore';
+
+const ConnectionStatus = () => {
+ const store = useStore();
+ const isMinimalMetadataReady = useAtomStateValue(isMinimalMetadataReadyState);
+ const sseEventStreamId = useAtomStateValue(sseEventStreamIdState);
+ const sseEventStreamReady = useAtomStateValue(sseEventStreamReadyState);
+ const connectionStatus = sseEventStreamReady ? 'Connected' : 'Connecting';
+
+ return (
+ <>
+ <Button
+ disabled={isMinimalMetadataReady}
+ onClick={() =>
+ setTestObjectMetadataItemsInMetadataStore(
+ store,
+ getTestEnrichedObjectMetadataItemsMock(),
+ )
+ }
+ >
+ Load field metadata
+ </Button>
+ <div role="status">
+ {isNonEmptyString(sseEventStreamId)
+ ? connectionStatus
+ : 'Waiting for field metadata'}
+ </div>
+ </>
+ );
+};
+
+const meta: Meta<typeof SSEProvider> = {
+ title: 'Modules/SseDbEvent/SSEProvider',
+ component: SSEProvider,
+ decorators: [
+ CatalogDecorator,
+ (Story) => (
+ <>
+ <IsMinimalMetadataReadyEffect />
+ <Story />
+ </>
+ ),
+ ],
+ args: { children: <ConnectionStatus /> },
+ beforeEach: () => {
+ const store = jotaiStore;
+
+ store.set(currentUserState.atom, mockedUserData);
+ store.set(currentWorkspaceState.atom, mockCurrentWorkspace);
+ store.set(isCookieAuthActiveState.atom, true);
+ setTestObjectMetadataItemsInMetadataStore(
+ store,
+ getTestEnrichedObjectMetadataItemsMock().map((objectMetadataItem) => ({
+ ...objectMetadataItem,
+ fields: [],
+ })),
+ );
+ store.set(metadataStoreState.atomFamily('fieldMetadataItems'), {
+ current: [],
+ draft: [],
+ status: 'empty',
+ });
+ setTestViewsInMetadataStore(store, []);
+
+ return () => store.get(sseClientState.atom)?.dispose();
+ },
+ parameters: {
+ msw: {
+ handlers: [
+ http.post(`${REACT_APP_SERVER_BASE_URL}/metadata`, () => {
+ const body = new ReadableStream({
+ start(controller) {
+ controller.enqueue(
+ new TextEncoder().encode(
+ `event: next\ndata: ${JSON.stringify({
+ data: {
+ onEventSubscription: {
+ metadataEvents: [],
+ objectRecordEventsWithQueryIds: [],
+ queueJobEvents: [],
+ },
+ },
+ })}\n\n`,
+ ),
+ );
+ },
+ });
+
+ return new HttpResponse(body, {
+ headers: { 'Content-Type': 'text/event-stream' },
+ });
+ }),
+ ],
+ },
+ },
+};
+
+export default meta;
+type Story = StoryObj<typeof SSEProvider>;
+
+export const WaitsForFieldMetadata: Story = {
+ play: async ({ canvasElement }) => {
+ const canvas = within(canvasElement);
+
+ expect(canvas.getByRole('status')).toHaveTextContent(
+ 'Waiting for field metadata',
+ );
+ await userEvent.click(
+ canvas.getByRole('button', { name: 'Load field metadata' }),
+ );
+ await canvas.findByText('Connected');
+ expect(
+ canvas.getByRole('button', { name: 'Load field metadata' }),
+ ).toBeDisabled();
+ },
+};
diff --git a/packages/twenty-front/src/modules/sse-db-event/hooks/__tests__/useTriggerOptimisticEffectFromSseEvents.test.tsx b/packages/twenty-front/src/modules/sse-db-event/hooks/__tests__/useTriggerOptimisticEffectFromSseEvents.test.tsx
new file mode 100644
index 00000000000..284bf0fa382
--- /dev/null
+++ b/packages/twenty-front/src/modules/sse-db-event/hooks/__tests__/useTriggerOptimisticEffectFromSseEvents.test.tsx
@@ -0,0 +1,322 @@
+import { ApolloClient, ApolloLink, gql, InMemoryCache } from '@apollo/client';
+import { ApolloProvider } from '@apollo/client/react';
+import { act, renderHook } from '@testing-library/react';
+import { createStore, Provider as JotaiProvider } from 'jotai';
+import { type ReactNode } from 'react';
+
+import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
+import { useTriggerOptimisticEffectFromSseEvents } from '@/sse-db-event/hooks/useTriggerOptimisticEffectFromSseEvents';
+import { DatabaseEventAction } from '~/generated-metadata/graphql';
+import { getTestEnrichedObjectMetadataItemsMock } from '~/testing/utils/getTestEnrichedObjectMetadataItemsMock';
+import { setTestObjectMetadataItemsInMetadataStore } from '~/testing/utils/setTestObjectMetadataItemsInMetadataStore';
+
+jest.mock('@/object-record/hooks/useObjectPermissions', () => ({
+ useObjectPermissions: () => ({ objectPermissionsByObjectMetadataId: {} }),
+}));
+
+jest.mock(
+ '@/object-record/hooks/useRefetchAggregateQueriesForObjectMetadataItem',
+ () => ({
+ useRefetchAggregateQueriesForObjectMetadataItem: () => ({
+ refetchAggregateQueriesForObjectMetadataItem: jest.fn(),
+ }),
+ }),
+);
+
+jest.mock('@/object-record/record-store/hooks/useUpsertRecordsInStore', () => ({
+ useUpsertRecordsInStore: () => ({ upsertRecordsInStore: jest.fn() }),
+}));
+
+jest.mock(
+ '@/sse-db-event/hooks/useTriggerOptimisticEffectFromSseUpdateEvents',
+ () => ({
+ useTriggerOptimisticEffectFromSseUpdateEvents: () => ({
+ triggerOptimisticEffectFromSseUpdateEvents: jest.fn(),
+ }),
+ }),
+);
+
+jest.mock(
+ '@/sse-db-event/hooks/useTriggerOptimisticEffectFromSseDeleteEvents',
+ () => ({
+ useTriggerOptimisticEffectFromSseDeleteEvents: () => ({
+ triggerOptimisticEffectFromSseDeleteEvents: jest.fn(),
+ }),
+ }),
+);
+
+jest.mock(
+ '@/sse-db-event/hooks/useTriggerOptimisticEffectFromSseRestoreEvents',
+ () => ({
+ useTriggerOptimisticEffectFromSseRestoreEvents: () => ({
+ triggerOptimisticEffectFromSseRestoreEvents: jest.fn(),
+ }),
+ }),
+);
+
+const taskObjectMetadataItem = getTestEnrichedObjectMetadataItemsMock().find(
+ ({ nameSingular }) => nameSingular === 'task',
+)!;
+
+const actionItemObjectMetadataItem: EnrichedObjectMetadataItem = {
+ ...taskObjectMetadataItem,
+ nameSingular: 'actionItem',
+ namePlural: 'actionItems',
+ fields: taskObjectMetadataItem.fields.filter(
+ ({ name }) => name === 'id' || name === 'status',
+ ),
+};
+
+const ACTION_ITEMS_QUERY = gql`
+ query ActionItems($filter: ActionItemFilterInput) {
+ actionItems(filter: $filter) {
+ __typename
+ edges {
+ __typename
+ node {
+ __typename
+ id
+ }
+ cursor
+ }
+ totalCount
+ pageInfo {
+ startCursor
+ endCursor
+ hasNextPage
+ hasPreviousPage
+ }
+ }
+ }
+`;
+
+const CREATED_ACTION_ITEM = {
+ __typename: 'ActionItem',
+ id: '20202020-0000-4000-8000-000000000001',
+ status: 'TODO',
+};
+
+describe('useTriggerOptimisticEffectFromSseEvents', () => {
+ it.each([
+ {
+ name: 'uses current field metadata when a retained subscription callback receives a create event',
+ initialObjectMetadataItems: [
+ {
+ ...actionItemObjectMetadataItem,
+ fields: actionItemObjectMetadataItem.fields.filter(
+ ({ name }) => name === 'id',
+ ),
+ },
+ ],
+ },
+ {
+ name: 'processes create events for objects loaded after the subscription callback was retained',
+ initialObjectMetadataItems: [],
+ },
+ ])('$name', ({ initialObjectMetadataItems }) => {
+ const store = createStore();
+ const cache = new InMemoryCache();
+ const client = new ApolloClient({ cache, link: ApolloLink.empty() });
+ const queryVariables = { filter: { status: { eq: 'TODO' } } };
+
+ setTestObjectMetadataItemsInMetadataStore(
+ store,
+ initialObjectMetadataItems,
+ );
+
+ cache.writeQuery({
+ query: ACTION_ITEMS_QUERY,
+ variables: queryVariables,
+ data: {
+ actionItems: {
+ __typename: 'ActionItemConnection',
+ edges: [],
+ totalCount: 0,
+ pageInfo: {
+ startCursor: null,
+ endCursor: null,
+ hasNextPage: false,
+ hasPreviousPage: false,
+ },
+ },
+ },
+ });
+
+ cache.writeFragment({
+ fragment: gql`
+ fragment CreatedActionItem on ActionItem {
+ id
+ status
+ }
+ `,
+ data: CREATED_ACTION_ITEM,
+ });
+
+ const Wrapper = ({ children }: { children: ReactNode }) => (
+ <JotaiProvider store={store}>
+ <ApolloProvider client={client}>{children}</ApolloProvider>
+ </JotaiProvider>
+ );
+
+ const { result } = renderHook(
+ () => useTriggerOptimisticEffectFromSseEvents(),
+ {
+ wrapper: Wrapper,
+ },
+ );
+
+ const retainedSubscriptionCallback =
+ result.current.triggerOptimisticEffectFromSseEvents;
+
+ act(() => {
+ setTestObjectMetadataItemsInMetadataStore(store, [
+ actionItemObjectMetadataItem,
+ ]);
+ });
+
+ expect(() =>
+ retainedSubscriptionCallback({
+ objectRecordEvents: [
+ {
+ action: DatabaseEventAction.CREATED,
+ objectNameSingular: 'actionItem',
+ recordId: CREATED_ACTION_ITEM.id,
+ properties: { after: CREATED_ACTION_ITEM },
+ },
+ ],
+ }),
+ ).not.toThrow();
+
+ expect(
+ cache.readQuery({
+ query: ACTION_ITEMS_QUERY,
+ variables: queryVariables,
+ }),
+ ).toMatchObject({
+ actionItems: {
+ edges: [{ node: { id: CREATED_ACTION_ITEM.id } }],
+ totalCount: 1,
+ },
+ });
+ });
+
+ it('uses current related object metadata when a retained subscription callback receives a create event', () => {
+ const opportunityMetadata = getTestEnrichedObjectMetadataItemsMock().find(
+ ({ nameSingular }) => nameSingular === 'opportunity',
+ )!;
+ const personMetadata = getTestEnrichedObjectMetadataItemsMock().find(
+ ({ nameSingular }) => nameSingular === 'person',
+ )!;
+ const opportunityObjectMetadataItem = {
+ ...opportunityMetadata,
+ fields: opportunityMetadata.fields.filter(
+ ({ name }) => name === 'id' || name === 'pointOfContact',
+ ),
+ };
+ const personObjectMetadataItem = {
+ ...personMetadata,
+ fields: personMetadata.fields.filter(
+ ({ name }) =>
+ name === 'id' || name === 'pointOfContactForOpportunities',
+ ),
+ };
+ const store = createStore();
+ const cache = new InMemoryCache();
+ const client = new ApolloClient({ cache, link: ApolloLink.empty() });
+ const personId = '20202020-0000-4000-8000-000000000002';
+ const opportunity = {
+ __typename: 'Opportunity',
+ id: '20202020-0000-4000-8000-000000000003',
+ pointOfContact: { __typename: 'Person', id: personId },
+ };
+ const queryVariables = {
+ filter: { pointOfContact: { id: { eq: personId } } },
+ };
+ const OPPORTUNITIES_QUERY = gql`
+ query Opportunities($filter: OpportunityFilterInput) {
+ opportunities(filter: $filter) {
+ __typename
+ edges {
+ __typename
+ node {
+ __typename
+ id
+ }
+ cursor
+ }
+ totalCount
+ }
+ }
+ `;
+
+ setTestObjectMetadataItemsInMetadataStore(store, [
+ opportunityObjectMetadataItem,
+ ]);
+
+ cache.writeQuery({
+ query: OPPORTUNITIES_QUERY,
+ variables: queryVariables,
+ data: {
+ opportunities: {
+ __typename: 'OpportunityConnection',
+ edges: [],
+ totalCount: 0,
+ },
+ },
+ });
+
+ cache.writeFragment({
+ fragment: gql`
+ fragment CreatedOpportunity on Opportunity {
+ id
+ }
+ `,
+ data: opportunity,
+ });
+
+ const Wrapper = ({ children }: { children: ReactNode }) => (
+ <JotaiProvider store={store}>
+ <ApolloProvider client={client}>{children}</ApolloProvider>
+ </JotaiProvider>
+ );
+
+ const { result } = renderHook(
+ () => useTriggerOptimisticEffectFromSseEvents(),
+ { wrapper: Wrapper },
+ );
+ const retainedSubscriptionCallback =
+ result.current.triggerOptimisticEffectFromSseEvents;
+
+ act(() => {
+ setTestObjectMetadataItemsInMetadataStore(store, [
+ opportunityObjectMetadataItem,
+ personObjectMetadataItem,
+ ]);
+ });
+
+ expect(() =>
+ retainedSubscriptionCallback({
+ objectRecordEvents: [
+ {
+ action: DatabaseEventAction.CREATED,
+ objectNameSingular: 'opportunity',
+ recordId: opportunity.id,
+ properties: { after: opportunity },
+ },
+ ],
+ }),
+ ).not.toThrow();
+
+ expect(
+ cache.readQuery({
+ query: OPPORTUNITIES_QUERY,
+ variables: queryVariables,
+ }),
+ ).toMatchObject({
+ opportunities: {
+ edges: [{ node: { id: opportunity.id } }],
+ totalCount: 1,
+ },
+ });
+ });
+});
diff --git a/packages/twenty-front/src/modules/sse-db-event/hooks/useTriggerOptimisticEffectFromSseCreateEvents.ts b/packages/twenty-front/src/modules/sse-db-event/hooks/useTriggerOptimisticEffectFromSseCreateEvents.ts
index 38f9cd0109f..401c3851eee 100644
--- a/packages/twenty-front/src/modules/sse-db-event/hooks/useTriggerOptimisticEffectFromSseCreateEvents.ts
+++ b/packages/twenty-front/src/modules/sse-db-event/hooks/useTriggerOptimisticEffectFromSseCreateEvents.ts
@@ -1,12 +1,13 @@
import { triggerCreateRecordsOptimisticEffect } from '@/apollo/optimistic-effect/utils/triggerCreateRecordsOptimisticEffect';
import { useApolloCoreClient } from '@/object-metadata/hooks/useApolloCoreClient';
-import { useObjectMetadataItems } from '@/object-metadata/hooks/useObjectMetadataItems';
+import { objectMetadataItemsWithFieldsSelector } from '@/object-metadata/states/objectMetadataItemsWithFieldsSelector';
import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
import { getObjectTypename } from '@/object-record/cache/utils/getObjectTypename';
import { type RecordGqlNode } from '@/object-record/graphql/types/RecordGqlNode';
import { useObjectPermissions } from '@/object-record/hooks/useObjectPermissions';
import { useRefetchAggregateQueriesForObjectMetadataItem } from '@/object-record/hooks/useRefetchAggregateQueriesForObjectMetadataItem';
import { useUpsertRecordsInStore } from '@/object-record/record-store/hooks/useUpsertRecordsInStore';
+import { useStore } from 'jotai';
import { useCallback } from 'react';
import { useDebouncedCallback } from 'use-debounce';
import {
@@ -15,8 +16,8 @@ import {
} from '~/generated-metadata/graphql';
export const useTriggerOptimisticEffectFromSseCreateEvents = () => {
+ const store = useStore();
const apolloCoreClient = useApolloCoreClient();
- const { objectMetadataItems } = useObjectMetadataItems();
const { objectPermissionsByObjectMetadataId } = useObjectPermissions();
const { refetchAggregateQueriesForObjectMetadataItem } =
useRefetchAggregateQueriesForObjectMetadataItem();
@@ -33,6 +34,10 @@ export const useTriggerOptimisticEffectFromSseCreateEvents = () => {
objectRecordEvents: ObjectRecordEvent[];
objectMetadataItem: EnrichedObjectMetadataItem;
}) => {
+ const objectMetadataItems = store.get(
+ objectMetadataItemsWithFieldsSelector.atom,
+ );
+
const createEvents = objectRecordEvents.filter((objectRecordEvent) => {
return objectRecordEvent.action === DatabaseEventAction.CREATED;
});
@@ -63,7 +68,7 @@ export const useTriggerOptimisticEffectFromSseCreateEvents = () => {
},
[
apolloCoreClient.cache,
- objectMetadataItems,
+ store,
objectPermissionsByObjectMetadataId,
upsertRecordsInStore,
debouncedRefetchAggregateQueriesForObjectMetadataItem,
diff --git a/packages/twenty-front/src/modules/sse-db-event/hooks/useTriggerOptimisticEffectFromSseDeleteEvents.ts b/packages/twenty-front/src/modules/sse-db-event/hooks/useTriggerOptimisticEffectFromSseDeleteEvents.ts
index 22eb5acfc29..5247ceb82a8 100644
--- a/packages/twenty-front/src/modules/sse-db-event/hooks/useTriggerOptimisticEffectFromSseDeleteEvents.ts
+++ b/packages/twenty-front/src/modules/sse-db-event/hooks/useTriggerOptimisticEffectFromSseDeleteEvents.ts
@@ -1,6 +1,6 @@
import { triggerUpdateRecordOptimisticEffectByBatch } from '@/apollo/optimistic-effect/utils/triggerUpdateRecordOptimisticEffectByBatch';
import { useApolloCoreClient } from '@/object-metadata/hooks/useApolloCoreClient';
-import { useObjectMetadataItems } from '@/object-metadata/hooks/useObjectMetadataItems';
+import { objectMetadataItemsWithFieldsSelector } from '@/object-metadata/states/objectMetadataItemsWithFieldsSelector';
import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
import { getObjectTypename } from '@/object-record/cache/utils/getObjectTypename';
import { updateRecordFromCache } from '@/object-record/cache/utils/updateRecordFromCache';
@@ -8,6 +8,7 @@ import { type RecordGqlNode } from '@/object-record/graphql/types/RecordGqlNode'
import { useObjectPermissions } from '@/object-record/hooks/useObjectPermissions';
import { useRefetchAggregateQueriesForObjectMetadataItem } from '@/object-record/hooks/useRefetchAggregateQueriesForObjectMetadataItem';
import { useUpsertRecordsInStore } from '@/object-record/record-store/hooks/useUpsertRecordsInStore';
+import { useStore } from 'jotai';
import { useCallback } from 'react';
import { useDebouncedCallback } from 'use-debounce';
import {
@@ -16,8 +17,8 @@ import {
} from '~/generated-metadata/graphql';
export const useTriggerOptimisticEffectFromSseDeleteEvents = () => {
+ const store = useStore();
const apolloCoreClient = useApolloCoreClient();
- const { objectMetadataItems } = useObjectMetadataItems();
const { objectPermissionsByObjectMetadataId } = useObjectPermissions();
const { refetchAggregateQueriesForObjectMetadataItem } =
useRefetchAggregateQueriesForObjectMetadataItem();
@@ -34,6 +35,10 @@ export const useTriggerOptimisticEffectFromSseDeleteEvents = () => {
objectRecordEvents: ObjectRecordEvent[];
objectMetadataItem: EnrichedObjectMetadataItem;
}) => {
+ const objectMetadataItems = store.get(
+ objectMetadataItemsWithFieldsSelector.atom,
+ );
+
const deleteEvents = objectRecordEvents.filter((objectRecordEvent) => {
return objectRecordEvent.action === DatabaseEventAction.DELETED;
});
@@ -93,7 +98,7 @@ export const useTriggerOptimisticEffectFromSseDeleteEvents = () => {
},
[
apolloCoreClient,
- objectMetadataItems,
+ store,
objectPermissionsByObjectMetadataId,
debouncedRefetchAggregateQueriesForObjectMetadataItem,
upsertRecordsInStore,
diff --git a/packages/twenty-front/src/modules/sse-db-event/hooks/useTriggerOptimisticEffectFromSseEvents.ts b/packages/twenty-front/src/modules/sse-db-event/hooks/useTriggerOptimisticEffectFromSseEvents.ts
index c4aa80ef908..16a22bc2098 100644
--- a/packages/twenty-front/src/modules/sse-db-event/hooks/useTriggerOptimisticEffectFromSseEvents.ts
+++ b/packages/twenty-front/src/modules/sse-db-event/hooks/useTriggerOptimisticEffectFromSseEvents.ts
@@ -1,10 +1,11 @@
-import { useObjectMetadataItems } from '@/object-metadata/hooks/useObjectMetadataItems';
+import { objectMetadataItemsWithFieldsSelector } from '@/object-metadata/states/objectMetadataItemsWithFieldsSelector';
import { useTriggerOptimisticEffectFromSseCreateEvents } from '@/sse-db-event/hooks/useTriggerOptimisticEffectFromSseCreateEvents';
import { useTriggerOptimisticEffectFromSseDeleteEvents } from '@/sse-db-event/hooks/useTriggerOptimisticEffectFromSseDeleteEvents';
import { useTriggerOptimisticEffectFromSseRestoreEvents } from '@/sse-db-event/hooks/useTriggerOptimisticEffectFromSseRestoreEvents';
import { useTriggerOptimisticEffectFromSseUpdateEvents } from '@/sse-db-event/hooks/useTriggerOptimisticEffectFromSseUpdateEvents';
import { groupObjectRecordSseEventsByEventType } from '@/sse-db-event/utils/groupObjectRecordSseEventsByEventType';
import { groupObjectRecordSseEventsByObjectMetadataItemNameSingular } from '@/sse-db-event/utils/groupObjectRecordSseEventsByObjectMetadataItemNameSingular';
+import { useStore } from 'jotai';
import { useCallback } from 'react';
import { isDefined } from 'twenty-shared/utils';
import {
@@ -13,7 +14,7 @@ import {
} from '~/generated-metadata/graphql';
export const useTriggerOptimisticEffectFromSseEvents = () => {
- const { objectMetadataItems } = useObjectMetadataItems();
+ const store = useStore();
const { triggerOptimisticEffectFromSseUpdateEvents } =
useTriggerOptimisticEffectFromSseUpdateEvents();
@@ -29,6 +30,10 @@ export const useTriggerOptimisticEffectFromSseEvents = () => {
const triggerOptimisticEffectFromSseEvents = useCallback(
({ objectRecordEvents }: { objectRecordEvents: ObjectRecordEvent[] }) => {
+ const objectMetadataItems = store.get(
+ objectMetadataItemsWithFieldsSelector.atom,
+ );
+
const objectRecordEventsByObjectMetadataItemNameSingular =
groupObjectRecordSseEventsByObjectMetadataItemNameSingular({
objectRecordEvents,
@@ -93,7 +98,7 @@ export const useTriggerOptimisticEffectFromSseEvents = () => {
}
},
[
- objectMetadataItems,
+ store,
triggerOptimisticEffectFromSseUpdateEvents,
triggerOptimisticEffectFromSseCreateEvents,
triggerOptimisticEffectFromSseDeleteEvents,
diff --git a/packages/twenty-front/src/modules/sse-db-event/hooks/useTriggerOptimisticEffectFromSseRestoreEvents.ts b/packages/twenty-front/src/modules/sse-db-event/hooks/useTriggerOptimisticEffectFromSseRestoreEvents.ts
index d09777fa8fa..e9f4e06accc 100644
--- a/packages/twenty-front/src/modules/sse-db-event/hooks/useTriggerOptimisticEffectFromSseRestoreEvents.ts
+++ b/packages/twenty-front/src/modules/sse-db-event/hooks/useTriggerOptimisticEffectFromSseRestoreEvents.ts
@@ -1,6 +1,6 @@
import { triggerUpdateRecordOptimisticEffectByBatch } from '@/apollo/optimistic-effect/utils/triggerUpdateRecordOptimisticEffectByBatch';
import { useApolloCoreClient } from '@/object-metadata/hooks/useApolloCoreClient';
-import { useObjectMetadataItems } from '@/object-metadata/hooks/useObjectMetadataItems';
+import { objectMetadataItemsWithFieldsSelector } from '@/object-metadata/states/objectMetadataItemsWithFieldsSelector';
import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
import { getObjectTypename } from '@/object-record/cache/utils/getObjectTypename';
import { updateRecordFromCache } from '@/object-record/cache/utils/updateRecordFromCache';
@@ -8,6 +8,7 @@ import { type RecordGqlNode } from '@/object-record/graphql/types/RecordGqlNode'
import { useObjectPermissions } from '@/object-record/hooks/useObjectPermissions';
import { useRefetchAggregateQueriesForObjectMetadataItem } from '@/object-record/hooks/useRefetchAggregateQueriesForObjectMetadataItem';
import { useUpsertRecordsInStore } from '@/object-record/record-store/hooks/useUpsertRecordsInStore';
+import { useStore } from 'jotai';
import { useCallback } from 'react';
import { useDebouncedCallback } from 'use-debounce';
import {
@@ -16,8 +17,8 @@ import {
} from '~/generated-metadata/graphql';
export const useTriggerOptimisticEffectFromSseRestoreEvents = () => {
+ const store = useStore();
const apolloCoreClient = useApolloCoreClient();
- const { objectMetadataItems } = useObjectMetadataItems();
const { objectPermissionsByObjectMetadataId } = useObjectPermissions();
const { refetchAggregateQueriesForObjectMetadataItem } =
useRefetchAggregateQueriesForObjectMetadataItem();
@@ -34,6 +35,10 @@ export const useTriggerOptimisticEffectFromSseRestoreEvents = () => {
objectRecordEvents: ObjectRecordEvent[];
objectMetadataItem: EnrichedObjectMetadataItem;
}) => {
+ const objectMetadataItems = store.get(
+ objectMetadataItemsWithFieldsSelector.atom,
+ );
+
const restoreEvents = objectRecordEvents.filter((objectRecordEvent) => {
return objectRecordEvent.action === DatabaseEventAction.RESTORED;
});
@@ -91,7 +96,7 @@ export const useTriggerOptimisticEffectFromSseRestoreEvents = () => {
},
[
apolloCoreClient,
- objectMetadataItems,
+ store,
objectPermissionsByObjectMetadataId,
debouncedRefetchAggregateQueriesForObjectMetadataItem,
upsertRecordsInStore,