Skip to content

The open alternative to Salesforce, designed for AI.

Keep the front metadata store consistent across out-of-order updates (#28711)

Charles Bochetd57791cb1c06
diff --git a/packages/twenty-front/src/modules/metadata-store/effect-components/MetadataStoreSSEEffect.tsx b/packages/twenty-front/src/modules/metadata-store/effect-components/MetadataStoreSSEEffect.tsx
index 419303c6e46..2671546ea4b 100644
--- a/packages/twenty-front/src/modules/metadata-store/effect-components/MetadataStoreSSEEffect.tsx
+++ b/packages/twenty-front/src/modules/metadata-store/effect-components/MetadataStoreSSEEffect.tsx
@@ -1,5 +1,4 @@
import { useListenToMetadataOperationBrowserEvent } from '@/browser-event/hooks/useListenToMetadataOperationBrowserEvent';
-import { useCleanMorphRelationsTargetingObjectMetadataId } from '@/metadata-store/hooks/useCleanMorphRelationsTargetingObjectMetadataId';
import { useUpdateMetadataStoreDraft } from '@/metadata-store/hooks/useUpdateMetadataStoreDraft';
import { type MetadataEntityKey } from '@/metadata-store/states/metadataStoreState';
import { type FlatPageLayoutWidget } from '@/metadata-store/types/FlatPageLayoutWidget';
@@ -23,8 +22,6 @@ const toMetadataStoreItem = (
export const MetadataStoreSSEEffect = () => {
const { addToDraft, removeFromDraft, applyChanges } =
useUpdateMetadataStoreDraft();
- const { cleanMorphRelations } =
- useCleanMorphRelationsTargetingObjectMetadataId();
useListenToMetadataOperationBrowserEvent({
onMetadataOperationBrowserEvent: (eventDetail) => {
@@ -69,10 +66,6 @@ export const MetadataStoreSSEEffect = () => {
itemIds: [eventDetail.operation.deletedRecordId],
collectionHash,
});
-
- if (entityKey === 'objectMetadataItems') {
- cleanMorphRelations(eventDetail.operation.deletedRecordId);
- }
break;
}
}
diff --git a/packages/twenty-front/src/modules/metadata-store/hooks/useCleanMorphRelationsTargetingObjectMetadataId.ts b/packages/twenty-front/src/modules/metadata-store/hooks/useCleanMorphRelationsTargetingObjectMetadataId.ts
deleted file mode 100644
index 113af6db518..00000000000
--- a/packages/twenty-front/src/modules/metadata-store/hooks/useCleanMorphRelationsTargetingObjectMetadataId.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import { useUpdateMetadataStoreDraft } from '@/metadata-store/hooks/useUpdateMetadataStoreDraft';
-import { metadataStoreState } from '@/metadata-store/states/metadataStoreState';
-import { type FlatFieldMetadataItem } from '@/metadata-store/types/FlatFieldMetadataItem';
-import { cleanMorphRelationsTargetingObjectMetadataId } from '@/metadata-store/utils/cleanMorphRelationsTargetingObjectMetadataId';
-import { useStore } from 'jotai';
-import { useCallback } from 'react';
-
-export const useCleanMorphRelationsTargetingObjectMetadataId = () => {
- const store = useStore();
- const { updateInDraft } = useUpdateMetadataStoreDraft();
-
- const cleanMorphRelations = useCallback(
- (deletedObjectMetadataId: string) => {
- const entry = store.get(
- metadataStoreState.atomFamily('fieldMetadataItems'),
- );
-
- const baseFieldMetadataItems = (
- entry.status === 'draft-pending' ? entry.draft : entry.current
- ) as FlatFieldMetadataItem[];
-
- const cleanedFieldMetadataItems =
- cleanMorphRelationsTargetingObjectMetadataId(
- baseFieldMetadataItems,
- deletedObjectMetadataId,
- );
-
- if (cleanedFieldMetadataItems.length === 0) {
- return;
- }
-
- updateInDraft('fieldMetadataItems', cleanedFieldMetadataItems);
- },
- [store, updateInDraft],
- );
-
- return { cleanMorphRelations };
-};
diff --git a/packages/twenty-front/src/modules/metadata-store/hooks/useUpdateMetadataStoreDraft.ts b/packages/twenty-front/src/modules/metadata-store/hooks/useUpdateMetadataStoreDraft.ts
index 070373d3572..bdc8aa330cf 100644
--- a/packages/twenty-front/src/modules/metadata-store/hooks/useUpdateMetadataStoreDraft.ts
+++ b/packages/twenty-front/src/modules/metadata-store/hooks/useUpdateMetadataStoreDraft.ts
@@ -6,6 +6,8 @@ import {
type MetadataStoreItem,
} from '@/metadata-store/states/metadataStoreState';
import { type MetadataEntityTypeMap } from '@/metadata-store/types/MetadataEntityTypeMap';
+import { getDraftOrCurrentMetadataItems } from '@/metadata-store/utils/getDraftOrCurrentMetadataItems';
+import { isMetadataStoreDraftConsistent } from '@/metadata-store/utils/isMetadataStoreDraftConsistent';
import { useStore, type createStore } from 'jotai';
import { useCallback } from 'react';
import { isDefined } from 'twenty-shared/utils';
@@ -19,19 +21,6 @@ const EMPTY_ENTRY: MetadataStoreItem = {
status: 'empty',
};
-const areViewsConsistentWithObjects = (
- viewsDraft: object[],
- objectsCurrent: object[],
-): boolean => {
- const objectIds = new Set(
- objectsCurrent.map((item) => (item as { id: string }).id),
- );
-
- return viewsDraft.every((view) =>
- objectIds.has((view as { objectMetadataId: string }).objectMetadataId),
- );
-};
-
export const resetMetadataStore = (store: JotaiStore) => {
for (const key of ALL_METADATA_ENTITY_KEYS) {
store.set(metadataStoreState.atomFamily(key), EMPTY_ENTRY);
@@ -89,13 +78,13 @@ export const useUpdateMetadataStoreDraft = () => {
const applyChanges = useCallback((): {
hasPersistedAnyMetadataEntity: boolean;
} => {
+ if (!isMetadataStoreDraftConsistent(store)) {
+ return { hasPersistedAnyMetadataEntity: false };
+ }
+
let hasPersistedAnyMetadataEntity = false;
for (const metadataEntityKey of ALL_METADATA_ENTITY_KEYS) {
- if (metadataEntityKey === 'views') {
- continue;
- }
-
const metadataStoreEntityEntry = store.get(
metadataStoreState.atomFamily(metadataEntityKey),
);
@@ -106,21 +95,6 @@ export const useUpdateMetadataStoreDraft = () => {
}
}
- const viewsEntry = store.get(metadataStoreState.atomFamily('views'));
-
- if (viewsEntry.status === 'draft-pending') {
- const objectsEntry = store.get(
- metadataStoreState.atomFamily('objectMetadataItems'),
- );
-
- if (
- areViewsConsistentWithObjects(viewsEntry.draft, objectsEntry.current)
- ) {
- changeMetadataEntityAsUpToDate(store, 'views');
- hasPersistedAnyMetadataEntity = true;
- }
- }
-
return { hasPersistedAnyMetadataEntity };
}, [store]);
@@ -139,24 +113,24 @@ export const useUpdateMetadataStoreDraft = () => {
}
const entry = store.get(metadataStoreState.atomFamily(key));
- const baseItems = (
- entry.status === 'draft-pending' ? entry.draft : entry.current
- ) as Array<{ id: string }>;
+ const baseItems = getDraftOrCurrentMetadataItems({
+ store,
+ metadataEntityKey: key,
+ });
let newItems = [...baseItems];
for (const item of items) {
- const newItem = item as unknown as { id: string };
const existingIndex = newItems.findIndex(
- (existing) => existing.id === newItem.id,
+ (existing) => existing.id === item.id,
);
if (existingIndex >= 0) {
- if (!isDeeplyEqual(newItems[existingIndex], newItem)) {
- newItems[existingIndex] = newItem;
+ if (!isDeeplyEqual(newItems[existingIndex], item)) {
+ newItems[existingIndex] = item;
}
} else {
- newItems = [...newItems, newItem];
+ newItems = [...newItems, item];
}
}
@@ -183,15 +157,14 @@ export const useUpdateMetadataStoreDraft = () => {
}
const entry = store.get(metadataStoreState.atomFamily(key));
- const baseItems = (
- entry.status === 'draft-pending' ? entry.draft : entry.current
- ) as Array<{ id: string }>;
+ const baseItems = getDraftOrCurrentMetadataItems({
+ store,
+ metadataEntityKey: key,
+ });
let hasChanged = false;
const newItems = baseItems.map((existing) => {
- const updatedItem = (items as unknown as Array<{ id: string }>).find(
- (item) => item.id === existing.id,
- );
+ const updatedItem = items.find((item) => item.id === existing.id);
if (!isDefined(updatedItem)) {
return existing;
@@ -239,9 +212,10 @@ export const useUpdateMetadataStoreDraft = () => {
}
const entry = store.get(metadataStoreState.atomFamily(key));
- const baseItems = (
- entry.status === 'draft-pending' ? entry.draft : entry.current
- ) as Array<{ id: string }>;
+ const baseItems = getDraftOrCurrentMetadataItems({
+ store,
+ metadataEntityKey: key,
+ });
const idsToDelete = new Set(itemIds);
const newItems = baseItems.filter(
diff --git a/packages/twenty-front/src/modules/metadata-store/utils/__tests__/cleanMorphRelationsTargetingObjectMetadataId.test.ts b/packages/twenty-front/src/modules/metadata-store/utils/__tests__/cleanMorphRelationsTargetingObjectMetadataId.test.ts
deleted file mode 100644
index 2dce0e4cf39..00000000000
--- a/packages/twenty-front/src/modules/metadata-store/utils/__tests__/cleanMorphRelationsTargetingObjectMetadataId.test.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-import { type FlatFieldMetadataItem } from '@/metadata-store/types/FlatFieldMetadataItem';
-import { cleanMorphRelationsTargetingObjectMetadataId } from '@/metadata-store/utils/cleanMorphRelationsTargetingObjectMetadataId';
-
-const buildMorphRelation = (targetObjectMetadataId: string) =>
- ({
- targetObjectMetadata: {
- id: targetObjectMetadataId,
- nameSingular: targetObjectMetadataId,
- namePlural: `${targetObjectMetadataId}s`,
- },
- }) as unknown as NonNullable<FlatFieldMetadataItem['morphRelations']>[number];
-
-const buildField = (
- id: string,
- morphRelations: FlatFieldMetadataItem['morphRelations'],
-): FlatFieldMetadataItem =>
- ({
- id,
- name: id,
- objectMetadataId: 'source-object',
- morphRelations,
- }) as unknown as FlatFieldMetadataItem;
-
-describe('cleanMorphRelationsTargetingObjectMetadataId', () => {
- it('should remove morph relations targeting the deleted object and return only changed fields', () => {
- const morphField = buildField('morph-field', [
- buildMorphRelation('company-id'),
- buildMorphRelation('meeting-id'),
- ]);
- const untouchedField = buildField('other-morph-field', [
- buildMorphRelation('company-id'),
- ]);
- const nonMorphField = buildField('text-field', null);
-
- const result = cleanMorphRelationsTargetingObjectMetadataId(
- [morphField, untouchedField, nonMorphField],
- 'meeting-id',
- );
-
- expect(result).toHaveLength(1);
- expect(result[0].id).toBe('morph-field');
- expect(result[0].morphRelations).toEqual([
- buildMorphRelation('company-id'),
- ]);
- });
-
- it('should keep a morph field with an empty morphRelations array when all its targets are deleted', () => {
- const result = cleanMorphRelationsTargetingObjectMetadataId(
- [buildField('exclusive-morph', [buildMorphRelation('meeting-id')])],
- 'meeting-id',
- );
-
- expect(result).toHaveLength(1);
- expect(result[0].id).toBe('exclusive-morph');
- expect(result[0].morphRelations).toEqual([]);
- });
-
- it('should return an empty array when no morph relation targets the deleted object', () => {
- const result = cleanMorphRelationsTargetingObjectMetadataId(
- [buildField('morph-field', [buildMorphRelation('company-id')])],
- 'meeting-id',
- );
-
- expect(result).toEqual([]);
- });
-});
diff --git a/packages/twenty-front/src/modules/metadata-store/utils/__tests__/isMetadataStoreSnapshotConsistent.test.ts b/packages/twenty-front/src/modules/metadata-store/utils/__tests__/isMetadataStoreSnapshotConsistent.test.ts
new file mode 100644
index 00000000000..53eee8816cf
--- /dev/null
+++ b/packages/twenty-front/src/modules/metadata-store/utils/__tests__/isMetadataStoreSnapshotConsistent.test.ts
@@ -0,0 +1,86 @@
+import {
+ isMetadataStoreSnapshotConsistent,
+ type MetadataStoreSnapshot,
+} from '@/metadata-store/utils/isMetadataStoreSnapshotConsistent';
+
+const buildTarget = (targetObjectMetadataId: string) => ({
+ targetObjectMetadata: { id: targetObjectMetadataId },
+});
+
+const buildSnapshot = (
+ overrides: Partial<MetadataStoreSnapshot>,
+): MetadataStoreSnapshot => ({
+ objectMetadataItems: [{ id: 'note-target' }, { id: 'company' }],
+ fieldMetadataItems: [],
+ indexMetadataItems: [],
+ views: [],
+ ...overrides,
+});
+
+describe('isMetadataStoreSnapshotConsistent', () => {
+ it('accepts a snapshot where every reference points to an existing object', () => {
+ expect(
+ isMetadataStoreSnapshotConsistent(
+ buildSnapshot({
+ fieldMetadataItems: [
+ {
+ objectMetadataId: 'note-target',
+ relation: buildTarget('company'),
+ morphRelations: [buildTarget('company')],
+ },
+ ],
+ indexMetadataItems: [{ objectMetadataId: 'company' }],
+ views: [{ objectMetadataId: 'company' }],
+ }),
+ ),
+ ).toBe(true);
+ });
+
+ it('rejects a morph relation targeting a removed object', () => {
+ expect(
+ isMetadataStoreSnapshotConsistent(
+ buildSnapshot({
+ fieldMetadataItems: [
+ {
+ objectMetadataId: 'note-target',
+ morphRelations: [buildTarget('company'), buildTarget('garden')],
+ },
+ ],
+ }),
+ ),
+ ).toBe(false);
+ });
+
+ it('rejects a relation targeting a removed object', () => {
+ expect(
+ isMetadataStoreSnapshotConsistent(
+ buildSnapshot({
+ fieldMetadataItems: [
+ {
+ objectMetadataId: 'company',
+ relation: buildTarget('garden'),
+ },
+ ],
+ }),
+ ),
+ ).toBe(false);
+ });
+
+ it('rejects a field, index or view whose object is missing', () => {
+ expect(
+ isMetadataStoreSnapshotConsistent(
+ buildSnapshot({ fieldMetadataItems: [{ objectMetadataId: 'garden' }] }),
+ ),
+ ).toBe(false);
+ expect(
+ isMetadataStoreSnapshotConsistent(
+ buildSnapshot({ indexMetadataItems: [{ objectMetadataId: 'garden' }] }),
+ ),
+ ).toBe(false);
+ expect(
+ isMetadataStoreSnapshotConsistent(
+ buildSnapshot({ views: [{ objectMetadataId: 'garden' }] }),
+ ),
+ ).toBe(false);
+ });
+});
diff --git a/packages/twenty-front/src/modules/metadata-store/utils/cleanMorphRelationsTargetingObjectMetadataId.ts b/packages/twenty-front/src/modules/metadata-store/utils/cleanMorphRelationsTargetingObjectMetadataId.ts
deleted file mode 100644
index f7a02380611..00000000000
--- a/packages/twenty-front/src/modules/metadata-store/utils/cleanMorphRelationsTargetingObjectMetadataId.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import { type FlatFieldMetadataItem } from '@/metadata-store/types/FlatFieldMetadataItem';
-import { isDefined } from 'twenty-shared/utils';
-
-export const cleanMorphRelationsTargetingObjectMetadataId = (
- fieldMetadataItems: FlatFieldMetadataItem[],
- deletedObjectMetadataId: string,
-): FlatFieldMetadataItem[] => {
- const cleanedFieldMetadataItems: FlatFieldMetadataItem[] = [];
-
- for (const fieldMetadataItem of fieldMetadataItems) {
- const morphRelations = fieldMetadataItem.morphRelations;
-
- if (
- !isDefined(morphRelations) ||
- !morphRelations.some(
- (morphRelation) =>
- morphRelation.targetObjectMetadata.id === deletedObjectMetadataId,
- )
- ) {
- continue;
- }
-
- cleanedFieldMetadataItems.push({
- ...fieldMetadataItem,
- morphRelations: morphRelations.filter(
- (morphRelation) =>
- morphRelation.targetObjectMetadata.id !== deletedObjectMetadataId,
- ),
- });
- }
-
- return cleanedFieldMetadataItems;
-};
diff --git a/packages/twenty-front/src/modules/metadata-store/utils/getDraftOrCurrentMetadataItems.ts b/packages/twenty-front/src/modules/metadata-store/utils/getDraftOrCurrentMetadataItems.ts
new file mode 100644
index 00000000000..0b78a94b45b
--- /dev/null
+++ b/packages/twenty-front/src/modules/metadata-store/utils/getDraftOrCurrentMetadataItems.ts
@@ -0,0 +1,22 @@
+import {
+ metadataStoreState,
+ type MetadataEntityKey,
+} from '@/metadata-store/states/metadataStoreState';
+import { type MetadataEntityTypeMap } from '@/metadata-store/types/MetadataEntityTypeMap';
+import { type createStore } from 'jotai';
+
+export const getDraftOrCurrentMetadataItems = <
+ TMetadataEntityKey extends MetadataEntityKey,
+>({
+ store,
+ metadataEntityKey,
+}: {
+ store: ReturnType<typeof createStore>;
+ metadataEntityKey: TMetadataEntityKey;
+}): MetadataEntityTypeMap[TMetadataEntityKey][] => {
+ const entry = store.get(metadataStoreState.atomFamily(metadataEntityKey));
+
+ return (
+ entry.status === 'draft-pending' ? entry.draft : entry.current
+ ) as MetadataEntityTypeMap[TMetadataEntityKey][];
+};
diff --git a/packages/twenty-front/src/modules/metadata-store/utils/isMetadataStoreDraftConsistent.ts b/packages/twenty-front/src/modules/metadata-store/utils/isMetadataStoreDraftConsistent.ts
new file mode 100644
index 00000000000..90e68c21696
--- /dev/null
+++ b/packages/twenty-front/src/modules/metadata-store/utils/isMetadataStoreDraftConsistent.ts
@@ -0,0 +1,25 @@
+import { getDraftOrCurrentMetadataItems } from '@/metadata-store/utils/getDraftOrCurrentMetadataItems';
+import { isMetadataStoreSnapshotConsistent } from '@/metadata-store/utils/isMetadataStoreSnapshotConsistent';
+import { type createStore } from 'jotai';
+
+export const isMetadataStoreDraftConsistent = (
+ store: ReturnType<typeof createStore>,
+) =>
+ isMetadataStoreSnapshotConsistent({
+ objectMetadataItems: getDraftOrCurrentMetadataItems({
+ store,
+ metadataEntityKey: 'objectMetadataItems',
+ }),
+ fieldMetadataItems: getDraftOrCurrentMetadataItems({
+ store,
+ metadataEntityKey: 'fieldMetadataItems',
+ }),
+ indexMetadataItems: getDraftOrCurrentMetadataItems({
+ store,
+ metadataEntityKey: 'indexMetadataItems',
+ }),
+ views: getDraftOrCurrentMetadataItems({
+ store,
+ metadataEntityKey: 'views',
+ }),
+ });
diff --git a/packages/twenty-front/src/modules/metadata-store/utils/isMetadataStoreSnapshotConsistent.ts b/packages/twenty-front/src/modules/metadata-store/utils/isMetadataStoreSnapshotConsistent.ts
new file mode 100644
index 00000000000..0cb32179bbc
--- /dev/null
+++ b/packages/twenty-front/src/modules/metadata-store/utils/isMetadataStoreSnapshotConsistent.ts
@@ -0,0 +1,45 @@
+import { isDefined } from 'twenty-shared/utils';
+
+type ObjectMetadataReference = { targetObjectMetadata: { id: string } };
+
+export type MetadataStoreSnapshot = {
+ objectMetadataItems: { id: string }[];
+ fieldMetadataItems: {
+ objectMetadataId: string;
+ relation?: ObjectMetadataReference | null;
+ morphRelations?: ObjectMetadataReference[] | null;
+ }[];
+ indexMetadataItems: { objectMetadataId: string }[];
+ views: { objectMetadataId: string }[];
+};
+
+export const isMetadataStoreSnapshotConsistent = ({
+ objectMetadataItems,
+ fieldMetadataItems,
+ indexMetadataItems,
+ views,
+}: MetadataStoreSnapshot): boolean => {
+ const objectMetadataIds = new Set(
+ objectMetadataItems.map((objectMetadataItem) => objectMetadataItem.id),
+ );
+
+ const areFieldsConsistent = fieldMetadataItems.every(
+ (fieldMetadataItem) =>
+ objectMetadataIds.has(fieldMetadataItem.objectMetadataId) &&
+ (!isDefined(fieldMetadataItem.relation) ||
+ objectMetadataIds.has(
+ fieldMetadataItem.relation.targetObjectMetadata.id,
+ )) &&
+ (fieldMetadataItem.morphRelations ?? []).every((morphRelation) =>
+ objectMetadataIds.has(morphRelation.targetObjectMetadata.id),
+ ),
+ );
+
+ return (
+ areFieldsConsistent &&
+ indexMetadataItems.every((indexMetadataItem) =>
+ objectMetadataIds.has(indexMetadataItem.objectMetadataId),
+ ) &&
+ views.every((view) => objectMetadataIds.has(view.objectMetadataId))
+ );
+};
diff --git a/packages/twenty-front/src/modules/object-metadata/hooks/useDeleteOneObjectMetadataItem.ts b/packages/twenty-front/src/modules/object-metadata/hooks/useDeleteOneObjectMetadataItem.ts
index 90bfffe26bd..57e7f69e9fc 100644
--- a/packages/twenty-front/src/modules/object-metadata/hooks/useDeleteOneObjectMetadataItem.ts
+++ b/packages/twenty-front/src/modules/object-metadata/hooks/useDeleteOneObjectMetadataItem.ts
@@ -2,9 +2,7 @@ import { useMutation } from '@apollo/client/react';
import { DeleteOneObjectMetadataItemDocument } from '~/generated-metadata/graphql';
import { useMetadataErrorHandler } from '@/metadata-error-handler/hooks/useMetadataErrorHandler';
-import { useCleanMorphRelationsTargetingObjectMetadataId } from '@/metadata-store/hooks/useCleanMorphRelationsTargetingObjectMetadataId';
import { useInvalidateMetadataStore } from '@/metadata-store/hooks/useInvalidateMetadataStore';
-import { useUpdateMetadataStoreDraft } from '@/metadata-store/hooks/useUpdateMetadataStoreDraft';
import { type MetadataRequestResult } from '@/object-metadata/types/MetadataRequestResult';
import { CombinedGraphQLErrors } from '@apollo/client/errors';
import { t } from '@lingui/core/macro';
@@ -18,10 +16,7 @@ export const useDeleteOneObjectMetadataItem = () => {
const { handleMetadataError } = useMetadataErrorHandler();
const { enqueueToast } = useToast();
- const { removeFromDraft, applyChanges } = useUpdateMetadataStoreDraft();
const { invalidateMetadataStore } = useInvalidateMetadataStore();
- const { cleanMorphRelations } =
- useCleanMorphRelationsTargetingObjectMetadataId();
const deleteOneObjectMetadataItem = async (
idToDelete: string,
@@ -37,10 +32,6 @@ export const useDeleteOneObjectMetadataItem = () => {
},
});
- removeFromDraft({ key: 'objectMetadataItems', itemIds: [idToDelete] });
- cleanMorphRelations(idToDelete);
- applyChanges();
-
invalidateMetadataStore();
return {
diff --git a/packages/twenty-front/src/modules/ui/utilities/state/jotai/utils/__tests__/createIndexedDbBackedJotaiStorage.test.ts b/packages/twenty-front/src/modules/ui/utilities/state/jotai/utils/__tests__/createIndexedDbBackedJotaiStorage.test.ts
index 50d0f84aca1..c13053a0454 100644
--- a/packages/twenty-front/src/modules/ui/utilities/state/jotai/utils/__tests__/createIndexedDbBackedJotaiStorage.test.ts
+++ b/packages/twenty-front/src/modules/ui/utilities/state/jotai/utils/__tests__/createIndexedDbBackedJotaiStorage.test.ts
@@ -1,4 +1,5 @@
import { clear, createStore, del, entries, set } from 'idb-keyval';
+import { BroadcastChannel as NodeBroadcastChannel } from 'worker_threads';
import { createIndexedDbBackedJotaiStorage } from '@/ui/utilities/state/jotai/utils/createIndexedDbBackedJotaiStorage';
import { isIndexedDbAvailable } from '@/ui/utilities/state/jotai/utils/isIndexedDbAvailable';
@@ -134,6 +135,49 @@ describe('createIndexedDbBackedJotaiStorage', () => {
expect(mockedLogError).toHaveBeenCalled();
});
+ describe('across tabs', () => {
+ class UnrefBroadcastChannel extends NodeBroadcastChannel {
+ constructor(name: string) {
+ super(name);
+ this.unref();
+ }
+ }
+
+ beforeAll(() => {
+ Object.defineProperty(globalThis, 'BroadcastChannel', {
+ value: UnrefBroadcastChannel,
+ configurable: true,
+ writable: true,
+ });
+ });
+
+ afterAll(() => {
+ Reflect.deleteProperty(globalThis, 'BroadcastChannel');
+ });
+
+ it('should deliver the writes of one synchronous run to other tabs together', async () => {
+ const { storage: senderStorage } =
+ createIndexedDbBackedJotaiStorage<Item>('cross-tab');
+ const { storage: receiverStorage } =
+ createIndexedDbBackedJotaiStorage<Item>('cross-tab');
+
+ const secondValueSeenByFirstSubscriber = new Promise<Item>((resolve) => {
+ receiverStorage.subscribe?.(
+ 'first',
+ () => resolve(receiverStorage.getItem('second', INITIAL)),
+ INITIAL,
+ );
+ });
+
+ senderStorage.setItem('first', { value: 1 });
+ senderStorage.setItem('second', { value: 2 });
+
+ await expect(secondValueSeenByFirstSubscriber).resolves.toEqual({
+ value: 2,
+ });
+ });
+ });
+
describe('when IndexedDB is unavailable', () => {
beforeEach(() => {
mockedIsIndexedDbAvailable.mockReturnValue(false);
diff --git a/packages/twenty-front/src/modules/ui/utilities/state/jotai/utils/createIndexedDbBackedJotaiStorage.ts b/packages/twenty-front/src/modules/ui/utilities/state/jotai/utils/createIndexedDbBackedJotaiStorage.ts
index d70bdfefbf6..20da24bf931 100644
--- a/packages/twenty-front/src/modules/ui/utilities/state/jotai/utils/createIndexedDbBackedJotaiStorage.ts
+++ b/packages/twenty-front/src/modules/ui/utilities/state/jotai/utils/createIndexedDbBackedJotaiStorage.ts
@@ -58,19 +58,27 @@ export const createIndexedDbBackedJotaiStorage = <ValueType>(
if (broadcastChannel !== null) {
broadcastChannel.onmessage = (
- event: MessageEvent<CrossTabMessage<ValueType>>,
+ event: MessageEvent<
+ CrossTabMessage<ValueType>[] | CrossTabMessage<ValueType>
+ >,
) => {
- const message = event.data;
+ const messages = Array.isArray(event.data) ? event.data : [event.data];
- if (message.type === 'set') {
- memoryMap.set(message.key, message.value);
- } else {
- memoryMap.delete(message.key);
+ for (const message of messages) {
+ if (message.type === 'set') {
+ memoryMap.set(message.key, message.value);
+ } else {
+ memoryMap.delete(message.key);
+ }
}
- const keySubscribers = subscribers.get(message.key);
+ for (const message of messages) {
+ const keySubscribers = subscribers.get(message.key);
+
+ if (!isDefined(keySubscribers)) {
+ continue;
+ }
- if (isDefined(keySubscribers)) {
for (const subscriber of keySubscribers) {
subscriber.callback(
message.type === 'set' ? message.value : subscriber.initialValue,
@@ -80,14 +88,32 @@ export const createIndexedDbBackedJotaiStorage = <ValueType>(
};
}
- const broadcast = (message: CrossTabMessage<ValueType>): void => {
+ let pendingMessages: CrossTabMessage<ValueType>[] = [];
+
+ const flushPendingMessages = (): void => {
+ const messages = pendingMessages;
+
+ pendingMessages = [];
+
try {
- broadcastChannel?.postMessage(message);
+ broadcastChannel?.postMessage(messages);
} catch (error) {
logError(error);
}
};
+ const broadcast = (message: CrossTabMessage<ValueType>): void => {
+ if (!isDefined(broadcastChannel)) {
+ return;
+ }
+
+ if (pendingMessages.length === 0) {
+ queueMicrotask(flushPendingMessages);
+ }
+
+ pendingMessages.push(message);
+ };
+
const storage: JotaiSyncStorage<ValueType> = {
getItem: (key, initialValue) =>
memoryMap.has(key) ? (memoryMap.get(key) as ValueType) : initialValue,
diff --git a/packages/twenty-front/src/testing/hooks/useLoadMockedMetadata.ts b/packages/twenty-front/src/testing/hooks/useLoadMockedMetadata.ts
index 4d87c948785..a453ab53b8c 100644
--- a/packages/twenty-front/src/testing/hooks/useLoadMockedMetadata.ts
+++ b/packages/twenty-front/src/testing/hooks/useLoadMockedMetadata.ts
@@ -33,7 +33,17 @@ export const useLoadMockedMetadata = () => {
data.flatIndexes,
MOCKED_COLLECTION_HASH,
);
- replaceDraft('views', data.flatViews, MOCKED_COLLECTION_HASH);
+ const mockedObjectMetadataIds = new Set(
+ data.flatObjects.map((flatObject) => flatObject.id),
+ );
+
+ replaceDraft(
+ 'views',
+ data.flatViews.filter((flatView) =>
+ mockedObjectMetadataIds.has(flatView.objectMetadataId),
+ ),
+ MOCKED_COLLECTION_HASH,
+ );
replaceDraft('viewFields', data.flatViewFields, MOCKED_COLLECTION_HASH);
replaceDraft('viewFilters', data.flatViewFilters, MOCKED_COLLECTION_HASH);
replaceDraft('viewSorts', data.flatViewSorts, MOCKED_COLLECTION_HASH);
diff --git a/packages/twenty-front/src/testing/jest/JestObjectMetadataItemSetter.tsx b/packages/twenty-front/src/testing/jest/JestObjectMetadataItemSetter.tsx
index 0c34453e72e..df02fabe753 100644
--- a/packages/twenty-front/src/testing/jest/JestObjectMetadataItemSetter.tsx
+++ b/packages/twenty-front/src/testing/jest/JestObjectMetadataItemSetter.tsx
@@ -1,9 +1,9 @@
import { type ReactNode, useEffect, useState } from 'react';
-import { useUpdateMetadataStoreDraft } from '@/metadata-store/hooks/useUpdateMetadataStoreDraft';
-import { splitCompositeObjectMetadataItems } from '@/metadata-store/utils/splitCompositeObjectMetadataItems';
import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
+import { useStore } from 'jotai';
import { getTestEnrichedObjectMetadataItemsMock } from '~/testing/utils/getTestEnrichedObjectMetadataItemsMock';
+import { setTestObjectMetadataItemsInMetadataStore } from '~/testing/utils/setTestObjectMetadataItemsInMetadataStore';
export const JestObjectMetadataItemSetter = ({
children,
@@ -12,21 +12,16 @@ export const JestObjectMetadataItemSetter = ({
children: ReactNode;
objectMetadataItems?: EnrichedObjectMetadataItem[];
}) => {
- const { replaceDraft, applyChanges } = useUpdateMetadataStoreDraft();
+ const store = useStore();
const [isLoaded, setIsLoaded] = useState(false);
useEffect(() => {
- const items =
- objectMetadataItems ?? getTestEnrichedObjectMetadataItemsMock();
- const { flatObjects, flatFields, flatIndexes } =
- splitCompositeObjectMetadataItems(items);
-
- replaceDraft('objectMetadataItems', flatObjects);
- replaceDraft('fieldMetadataItems', flatFields);
- replaceDraft('indexMetadataItems', flatIndexes);
- applyChanges();
+ setTestObjectMetadataItemsInMetadataStore(
+ store,
+ objectMetadataItems ?? getTestEnrichedObjectMetadataItemsMock(),
+ );
setIsLoaded(true);
- }, [objectMetadataItems, replaceDraft, applyChanges]);
+ }, [objectMetadataItems, store]);
return isLoaded ? <>{children}</> : null;
};
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-object-metadata/utils/from-delete-object-input-to-flat-field-metadatas-to-delete.util.ts b/packages/twenty-server/src/engine/metadata-modules/flat-object-metadata/utils/from-delete-object-input-to-flat-field-metadatas-to-delete.util.ts
index 514545351b3..7134435d913 100644
--- a/packages/twenty-server/src/engine/metadata-modules/flat-object-metadata/utils/from-delete-object-input-to-flat-field-metadatas-to-delete.util.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-object-metadata/utils/from-delete-object-input-to-flat-field-metadatas-to-delete.util.ts
@@ -9,6 +9,7 @@ import { findManyFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metada
import { findRelationFlatFieldMetadataTargetFlatFieldMetadataOrThrow } from 'src/engine/metadata-modules/flat-field-metadata/utils/find-relation-flat-field-metadatas-target-flat-field-metadata-or-throw.util';
import { isMorphOrRelationFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-morph-or-relation-flat-field-metadata.util';
import { type FlatIndexMetadata } from 'src/engine/metadata-modules/flat-index-metadata/types/flat-index-metadata.type';
+import { type FlatView } from 'src/engine/metadata-modules/flat-view/types/flat-view.type';
import { type DeleteOneObjectInput } from 'src/engine/metadata-modules/object-metadata/dtos/delete-object.input';
import {
ObjectMetadataException,
@@ -21,18 +22,23 @@ type FromDeleteObjectInputToFlatFieldMetadatasToDeleteArgs = {
deleteObjectInput: DeleteOneObjectInput;
} & Pick<
AllFlatEntityMaps,
- 'flatFieldMetadataMaps' | 'flatObjectMetadataMaps' | 'flatIndexMaps'
+ | 'flatFieldMetadataMaps'
+ | 'flatObjectMetadataMaps'
+ | 'flatIndexMaps'
+ | 'flatViewMaps'
>;
export const fromDeleteObjectInputToFlatFieldMetadatasToDelete = ({
deleteObjectInput: rawDeleteObjectInput,
flatFieldMetadataMaps,
flatObjectMetadataMaps,
flatIndexMaps,
+ flatViewMaps,
// This should return an AllFlatEntityMaps
}: FromDeleteObjectInputToFlatFieldMetadatasToDeleteArgs): {
flatFieldMetadatasToDelete: UniversalFlatFieldMetadata[];
flatObjectMetadataToDelete: UniversalFlatObjectMetadata;
flatIndexToDelete: FlatIndexMetadata[];
+ flatViewToDelete: FlatView[];
} => {
const { id: objectMetadataToDeleteId } =
trimAndRemoveDuplicatedWhitespacesFromObjectStringProperties(
@@ -101,9 +107,15 @@ export const fromDeleteObjectInputToFlatFieldMetadatasToDelete = ({
)),
);
+ const flatViewToDelete = findManyFlatEntityByIdInFlatEntityMapsOrThrow({
+ flatEntityMaps: flatViewMaps,
+ flatEntityIds: flatObjectMetadataToDelete.viewIds,
+ }).filter((flatView) => !flatView.isSystemSideEffect);
+
return {
flatFieldMetadatasToDelete,
flatObjectMetadataToDelete,
flatIndexToDelete: flatIndexMetadataToDelete,
+ flatViewToDelete,
};
};
diff --git a/packages/twenty-server/src/engine/metadata-modules/object-metadata/object-metadata.service.ts b/packages/twenty-server/src/engine/metadata-modules/object-metadata/object-metadata.service.ts
index 80db0e9c4fe..b386bb6e957 100644
--- a/packages/twenty-server/src/engine/metadata-modules/object-metadata/object-metadata.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/object-metadata/object-metadata.service.ts
@@ -12,6 +12,7 @@ import { findFlatEntityByUniversalIdentifierOrThrow } from 'src/engine/metadata-
import { findFlatEntityByUniversalIdentifier } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-universal-identifier.util';
import { findManyFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-many-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
import { FlatIndexMetadata } from 'src/engine/metadata-modules/flat-index-metadata/types/flat-index-metadata.type';
+import { FlatView } from 'src/engine/metadata-modules/flat-view/types/flat-view.type';
import { computeInitialObjectViewOperationsOnObjectCreation } from 'src/engine/metadata-modules/view/utils/compute-initial-object-view-operations-on-object-creation.util';
import { FlatNavigationMenuItem } from 'src/engine/metadata-modules/flat-navigation-menu-item/types/flat-navigation-menu-item.type';
import { FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
@@ -346,7 +347,12 @@ export class ObjectMetadataService {
)
).workspaceCustomFlatApplication;
- const { flatObjectMetadataMaps, flatFieldMetadataMaps, flatIndexMaps } =
+ const {
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ flatIndexMaps,
+ flatViewMaps,
+ } =
await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
{
workspaceId,
@@ -354,6 +360,7 @@ export class ObjectMetadataService {
'flatObjectMetadataMaps',
'flatIndexMaps',
'flatFieldMetadataMaps',
+ 'flatViewMaps',
],
},
);
@@ -368,25 +375,30 @@ export class ObjectMetadataService {
UniversalFlatObjectMetadata
>;
flatIndexToDeleteByUniversalIdentifier: Record<string, FlatIndexMetadata>;
+ flatViewToDeleteByUniversalIdentifier: Record<string, FlatView>;
} = {
flatFieldMetadatasToDeleteByUniversalIdentifier: {},
flatIndexToDeleteByUniversalIdentifier: {},
flatObjectMetadatasToDeleteByUniversalIdentifier: {},
+ flatViewToDeleteByUniversalIdentifier: {},
};
const {
flatFieldMetadatasToDeleteByUniversalIdentifier,
flatIndexToDeleteByUniversalIdentifier,
flatObjectMetadatasToDeleteByUniversalIdentifier,
+ flatViewToDeleteByUniversalIdentifier,
} = deleteObjectInputs.reduce((accumulator, deleteObjectInput) => {
const {
flatFieldMetadatasToDelete,
flatObjectMetadataToDelete,
flatIndexToDelete,
+ flatViewToDelete,
} = fromDeleteObjectInputToFlatFieldMetadatasToDelete({
flatObjectMetadataMaps,
flatIndexMaps,
flatFieldMetadataMaps,
+ flatViewMaps,
deleteObjectInput,
});
@@ -410,6 +422,13 @@ export class ObjectMetadataService {
[flatObjectMetadataToDelete.universalIdentifier]:
flatObjectMetadataToDelete,
},
+ flatViewToDeleteByUniversalIdentifier: {
+ ...accumulator.flatViewToDeleteByUniversalIdentifier,
+ ...fromArrayToUniqueKeyRecord({
+ array: flatViewToDelete,
+ uniqueKey: 'universalIdentifier',
+ }),
+ },
};
}, initialAccumulator);
@@ -454,6 +473,13 @@ export class ObjectMetadataService {
flatEntityToDelete: flatFieldMetadatasToDelete,
flatEntityToUpdate: [],
},
+ view: {
+ flatEntityToCreate: [],
+ flatEntityToDelete: Object.values(
+ flatViewToDeleteByUniversalIdentifier,
+ ),
+ flatEntityToUpdate: [],
+ },
},
workspaceId,
isSystemBuild,
diff --git a/packages/twenty-server/test/integration/metadata/suites/object-metadata/delete-object-metadata-view-events.integration-spec.ts b/packages/twenty-server/test/integration/metadata/suites/object-metadata/delete-object-metadata-view-events.integration-spec.ts
new file mode 100644
index 00000000000..4d27b2e209d
--- /dev/null
+++ b/packages/twenty-server/test/integration/metadata/suites/object-metadata/delete-object-metadata-view-events.integration-spec.ts
@@ -0,0 +1,88 @@
+import { faker } from '@faker-js/faker';
+import { createOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/create-one-object-metadata.util';
+import { deleteOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/delete-one-object-metadata.util';
+import { updateOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/update-one-object-metadata.util';
+import { createOneView } from 'test/integration/metadata/suites/view/utils/create-one-view.util';
+import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
+import { ViewType } from 'twenty-shared/types';
+
+import { type MetadataEventEmitter } from 'src/engine/subscriptions/metadata-event/metadata-event-emitter';
+import { type MetadataEventPublisher } from 'src/engine/subscriptions/metadata-event/metadata-event-publisher';
+import { type MetadataEventBatch } from 'src/engine/subscriptions/metadata-event/types/metadata-event-batch.type';
+
+const OBJECT_NAME = 'viewDeletionEventTest';
+
+describe('Object deletion view events', () => {
+ let publisher: MetadataEventPublisher;
+ let emitter: MetadataEventEmitter;
+
+ beforeAll(() => {
+ publisher = getAppProviderByClassName('MetadataEventPublisher');
+ emitter = getAppProviderByClassName('MetadataEventEmitter');
+ });
+
+ afterEach(() => {
+ jest.restoreAllMocks();
+ });
+
+ it('publishes a delete event for every view of the deleted object', async () => {
+ const {
+ data: { createOneObject },
+ } = await createOneObjectMetadata({
+ expectToFail: false,
+ input: {
+ nameSingular: OBJECT_NAME,
+ namePlural: `${OBJECT_NAME}s`,
+ labelSingular: 'View deletion event test',
+ labelPlural: 'View deletion event tests',
+ icon: 'IconBox',
+ isLabelSyncedWithName: false,
+ },
+ });
+
+ const {
+ data: { createView: userView },
+ } = await createOneView({
+ expectToFail: false,
+ gqlFields: 'id',
+ input: {
+ id: faker.string.uuid(),
+ icon: 'IconTable',
+ name: 'User table view',
+ objectMetadataId: createOneObject.id,
+ type: ViewType.TABLE,
+ },
+ });
+
+ await updateOneObjectMetadata({
+ expectToFail: false,
+ input: {
+ idToUpdate: createOneObject.id,
+ updatePayload: { isActive: false },
+ },
+ });
+ await emitter.drain();
+
+ const publishedBatches: MetadataEventBatch[] = [];
+ const publish = publisher.publish.bind(publisher);
+
+ jest.spyOn(publisher, 'publish').mockImplementation(async (batch) => {
+ publishedBatches.push(batch);
+ await publish(batch);
+ });
+
+ await deleteOneObjectMetadata({
+ expectToFail: false,
+ input: { idToDelete: createOneObject.id },
+ });
+ await emitter.drain();
+
+ const deletedViewIds = publishedBatches
+ .filter(
+ (batch) => batch.metadataName === 'view' && batch.type === 'deleted',
+ )
+ .flatMap((batch) => batch.events.map((event) => event.recordId));
+
+ expect(deletedViewIds).toContain(userView.id);
+ });
+});