Skip to content

The open alternative to Salesforce, designed for AI.

Refactor activity targets onto generic junction relations (#24766)

Félix Malfait91a99aa752fd
diff --git a/packages/twenty-front/src/modules/activities/components/ActivityTargetChips.tsx b/packages/twenty-front/src/modules/activities/components/ActivityTargetChips.tsx
deleted file mode 100644
index e96ee4de05c..00000000000
--- a/packages/twenty-front/src/modules/activities/components/ActivityTargetChips.tsx
+++ /dev/null
@@ -1,41 +0,0 @@
-import { styled } from '@linaria/react';
-
-import { type ActivityTargetWithTargetRecord } from '@/activities/types/ActivityTargetObject';
-import { RecordChip } from '@/object-record/components/RecordChip';
-import { ExpandableList } from '@/ui/layout/expandable-list/components/ExpandableList';
-import { themeCssVariables } from 'twenty-ui/theme-constants';
-
-type ActivityTargetChipsProps = {
- activityTargetObjectRecords: ActivityTargetWithTargetRecord[];
- maxWidth?: number;
-};
-
-const StyledContainer = styled.div<{ maxWidth?: number }>`
- display: flex;
- flex-wrap: wrap;
- gap: ${themeCssVariables.spacing[1]};
- max-width: ${({ maxWidth }) => (maxWidth ? `${maxWidth}px` : 'none')};
-`;
-
-export const ActivityTargetChips = ({
- activityTargetObjectRecords,
- maxWidth,
-}: ActivityTargetChipsProps) => {
- return (
- <StyledContainer maxWidth={maxWidth}>
- <ExpandableList isChipCountDisplayed>
- {activityTargetObjectRecords.map(
- (activityTargetObjectRecord, index) => (
- <RecordChip
- key={index}
- record={activityTargetObjectRecord.targetObject}
- objectNameSingular={
- activityTargetObjectRecord.targetObjectMetadataItem.nameSingular
- }
- />
- ),
- )}
- </ExpandableList>
- </StyledContainer>
- );
-};
diff --git a/packages/twenty-front/src/modules/activities/graphql/operation-signatures/factories/__tests__/activityOperationSignatureFactories.test.ts b/packages/twenty-front/src/modules/activities/graphql/operation-signatures/factories/__tests__/activityOperationSignatureFactories.test.ts
new file mode 100644
index 00000000000..79548cb4552
--- /dev/null
+++ b/packages/twenty-front/src/modules/activities/graphql/operation-signatures/factories/__tests__/activityOperationSignatureFactories.test.ts
@@ -0,0 +1,25 @@
+import { findActivityTargetsOperationSignatureFactory } from '@/activities/graphql/operation-signatures/factories/findActivityTargetsOperationSignatureFactory';
+import { CoreObjectNameSingular } from 'twenty-shared/types';
+import { getTestEnrichedObjectMetadataItemsMock } from '~/testing/utils/getTestEnrichedObjectMetadataItemsMock';
+
+describe('activity operation signature factories', () => {
+ const objectMetadataItems = getTestEnrichedObjectMetadataItemsMock();
+
+ it('derives the junction object and source relation from metadata', () => {
+ const result = findActivityTargetsOperationSignatureFactory({
+ objectNameSingular: CoreObjectNameSingular.Task,
+ objectMetadataItems,
+ });
+
+ expect(result.objectNameSingular).toBe(CoreObjectNameSingular.TaskTarget);
+ expect(result.fields).toMatchObject({
+ taskId: true,
+ task: {
+ id: true,
+ taskTargets: {
+ id: true,
+ },
+ },
+ });
+ });
+});
diff --git a/packages/twenty-front/src/modules/activities/graphql/operation-signatures/factories/findActivitiesOperationSignatureFactory.ts b/packages/twenty-front/src/modules/activities/graphql/operation-signatures/factories/findActivitiesOperationSignatureFactory.ts
deleted file mode 100644
index 59ea1fdd207..00000000000
--- a/packages/twenty-front/src/modules/activities/graphql/operation-signatures/factories/findActivitiesOperationSignatureFactory.ts
+++ /dev/null
@@ -1,85 +0,0 @@
-import { generateActivityTargetMorphFieldKeys } from '@/activities/utils/generateActivityTargetMorphFieldKeys';
-import { CoreObjectNameSingular } from 'twenty-shared/types';
-import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
-import { type RecordGqlOperationSignatureFactory } from '@/object-record/graphql/types/RecordGqlOperationSignatureFactory';
-
-type FindActivitiesOperationSignatureFactory = {
- objectMetadataItems: EnrichedObjectMetadataItem[];
- objectNameSingular: CoreObjectNameSingular;
-};
-
-export const findActivitiesOperationSignatureFactory: RecordGqlOperationSignatureFactory<
- FindActivitiesOperationSignatureFactory
-> = ({
- objectMetadataItems,
- objectNameSingular,
-}: FindActivitiesOperationSignatureFactory) => {
- const body = {
- bodyV2: {
- markdown: true,
- blocknote: true,
- },
- };
-
- return {
- objectNameSingular: objectNameSingular,
- variables: {},
- fields: {
- id: true,
- __typename: true,
- createdAt: true,
- updatedAt: true,
- author: {
- id: true,
- name: true,
- __typename: true,
- },
- // Deprecated: Use createdBy instead
- authorId: true,
- createdBy: {
- source: true,
- workspaceMemberId: true,
- name: true,
- },
- assigneeId: true,
- assignee: {
- id: true,
- name: true,
- __typename: true,
- },
- comments: true,
- attachments: true,
- ...body,
- title: true,
- status: true,
- dueAt: true,
- reminderAt: true,
- type: true,
- ...(objectNameSingular === CoreObjectNameSingular.Note
- ? {
- noteTargets: {
- id: true,
- __typename: true,
- createdAt: true,
- updatedAt: true,
- deletedAt: true,
- note: true,
- noteId: true,
- ...generateActivityTargetMorphFieldKeys(objectMetadataItems),
- },
- }
- : {
- taskTargets: {
- id: true,
- __typename: true,
- createdAt: true,
- updatedAt: true,
- deletedAt: true,
- task: true,
- taskId: true,
- ...generateActivityTargetMorphFieldKeys(objectMetadataItems),
- },
- }),
- },
- };
-};
diff --git a/packages/twenty-front/src/modules/activities/graphql/operation-signatures/factories/findActivityTargetsOperationSignatureFactory.ts b/packages/twenty-front/src/modules/activities/graphql/operation-signatures/factories/findActivityTargetsOperationSignatureFactory.ts
index c7fef8c1ccb..06ed4c7b92b 100644
--- a/packages/twenty-front/src/modules/activities/graphql/operation-signatures/factories/findActivityTargetsOperationSignatureFactory.ts
+++ b/packages/twenty-front/src/modules/activities/graphql/operation-signatures/factories/findActivityTargetsOperationSignatureFactory.ts
@@ -1,8 +1,8 @@
-import { getJoinObjectNameSingular } from '@/activities/utils/getJoinObjectNameSingular';
import { type CoreObjectNameSingular } from 'twenty-shared/types';
import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
import { generateDepthRecordGqlFieldsFromObject } from '@/object-record/graphql/record-gql-fields/utils/generateDepthRecordGqlFieldsFromObject';
import { type RecordGqlOperationSignatureFactory } from '@/object-record/graphql/types/RecordGqlOperationSignatureFactory';
+import { getObjectMorphJunctionConfig } from '@/object-record/record-field/ui/utils/junction/getObjectMorphJunctionConfig';
import { isDefined } from 'twenty-shared/utils';
type FindActivityTargetsOperationSignatureFactory = {
@@ -16,26 +16,31 @@ export const findActivityTargetsOperationSignatureFactory: RecordGqlOperationSig
objectNameSingular,
objectMetadataItems,
}: FindActivityTargetsOperationSignatureFactory) => {
- const targetObjectNameSingular =
- getJoinObjectNameSingular(objectNameSingular);
-
- const targetObjectMetadataItem = objectMetadataItems.find(
- (objectMetadataItem) =>
- objectMetadataItem.nameSingular === targetObjectNameSingular,
- );
-
const activityObjectMetadataItem = objectMetadataItems.find(
(objectMetadataItem) =>
objectMetadataItem.nameSingular === objectNameSingular,
);
- if (
- !isDefined(targetObjectMetadataItem) ||
- !isDefined(activityObjectMetadataItem)
- ) {
- throw new Error(`Cannot find target or targetable object metadata item`);
+ if (!isDefined(activityObjectMetadataItem)) {
+ throw new Error('Cannot resolve activity junction metadata');
+ }
+
+ const junctionConfig = getObjectMorphJunctionConfig({
+ objectMetadata: activityObjectMetadataItem,
+ objectMetadataItems,
+ });
+
+ if (!isDefined(junctionConfig)) {
+ throw new Error('Cannot resolve activity relation on junction object');
}
+ const {
+ junctionField,
+ junctionObjectMetadata,
+ sourceField,
+ sourceJoinColumnName,
+ } = junctionConfig;
+
const activityFieldKeys = generateDepthRecordGqlFieldsFromObject({
objectMetadataItems,
objectMetadataItem: activityObjectMetadataItem,
@@ -43,21 +48,21 @@ export const findActivityTargetsOperationSignatureFactory: RecordGqlOperationSig
});
return {
- objectNameSingular: targetObjectNameSingular,
+ objectNameSingular: junctionObjectMetadata.nameSingular,
variables: {},
fields: {
id: true,
__typename: true,
createdAt: true,
updatedAt: true,
- [objectNameSingular]: {
+ [sourceJoinColumnName]: true,
+ [sourceField.name]: {
...activityFieldKeys,
- [targetObjectMetadataItem.namePlural]:
- generateDepthRecordGqlFieldsFromObject({
- objectMetadataItems,
- objectMetadataItem: targetObjectMetadataItem,
- depth: 1,
- }),
+ [junctionField.name]: generateDepthRecordGqlFieldsFromObject({
+ objectMetadataItems,
+ objectMetadataItem: junctionObjectMetadata,
+ depth: 1,
+ }),
},
},
};
diff --git a/packages/twenty-front/src/modules/activities/hooks/__tests__/useActivities.test.tsx b/packages/twenty-front/src/modules/activities/hooks/__tests__/useActivities.test.tsx
index 0392cb59a81..b2475a4e536 100644
--- a/packages/twenty-front/src/modules/activities/hooks/__tests__/useActivities.test.tsx
+++ b/packages/twenty-front/src/modules/activities/hooks/__tests__/useActivities.test.tsx
@@ -34,7 +34,6 @@ const mockActivity = {
markdown: 'My Body',
},
assignee: null,
- taskTargets: [],
} satisfies Task;
describe('useActivities', () => {
@@ -50,6 +49,7 @@ describe('useActivities', () => {
{
activityTargets: [{ ...mockActivityTarget, task: mockActivity }],
loadingActivityTargets: false,
+ activityRelationFieldName: 'task',
},
);
diff --git a/packages/twenty-front/src/modules/activities/hooks/__tests__/useActivityTargetObjectRecords.test.tsx b/packages/twenty-front/src/modules/activities/hooks/__tests__/useActivityTargetObjectRecords.test.tsx
deleted file mode 100644
index 11cd3167238..00000000000
--- a/packages/twenty-front/src/modules/activities/hooks/__tests__/useActivityTargetObjectRecords.test.tsx
+++ /dev/null
@@ -1,183 +0,0 @@
-import { gql, InMemoryCache } from '@apollo/client';
-import { MockedProvider } from '@apollo/client/testing/react';
-import { act, renderHook } from '@testing-library/react';
-import { type ReactNode } from 'react';
-import { Provider as JotaiProvider } from 'jotai';
-
-import { useActivityTargetObjectRecords } from '@/activities/hooks/useActivityTargetObjectRecords';
-import { currentWorkspaceMemberState } from '@/auth/states/currentWorkspaceMemberState';
-import { recordStoreFamilyState } from '@/object-record/record-store/states/recordStoreFamilyState';
-import { setTestObjectMetadataItemsInMetadataStore } from '~/testing/utils/setTestObjectMetadataItemsInMetadataStore';
-import { useSetAtomFamilyState } from '@/ui/utilities/state/jotai/hooks/useSetAtomFamilyState';
-import { jotaiStore } from '@/ui/utilities/state/jotai/jotaiStore';
-import { SnackBarComponentInstanceContext } from '@/ui/feedback/snack-bar-manager/contexts/SnackBarComponentInstanceContext';
-import { getRecordFromRecordNode } from '@/object-record/cache/utils/getRecordFromRecordNode';
-import { type WorkspaceMember } from '@/workspace-member/types/WorkspaceMember';
-import { JestObjectMetadataItemSetter } from '~/testing/jest/JestObjectMetadataItemSetter';
-import { mockedWorkspaceMemberRecords } from '~/testing/mock-data/generated/data/workspaceMembers/mock-workspaceMembers-data';
-import { getTestEnrichedObjectMetadataItemsMock } from '~/testing/utils/getTestEnrichedObjectMetadataItemsMock';
-
-const cache = new InMemoryCache();
-
-const taskTarget = {
- id: '89bb825c-171e-4bcc-9cf7-43448d6fb300',
- createdAt: '2023-04-26T10:12:42.33625+00:00',
- updatedAt: '2023-04-26T10:23:42.33625+00:00',
- targetCompanyId: null,
- targetCompany: null,
- targetPersonId: '89bb825c-171e-4bcc-9cf7-43448d6fb280',
- targetPerson: {
- id: '89bb825c-171e-4bcc-9cf7-43448d6fb280',
- createdAt: '2023-04-26T10:12:42.33625+00:00',
- updatedAt: '2023-04-26T10:23:42.33625+00:00',
- city: 'City',
- name: {
- firstName: 'John',
- lastName: 'Doe',
- },
- __typename: 'Person',
- },
- taskId: '89bb825c-171e-4bcc-9cf7-43448d6fb230',
- task: {
- id: '89bb825c-171e-4bcc-9cf7-43448d6fb230',
- createdAt: '2023-04-26T10:12:42.33625+00:00',
- updatedAt: '2023-04-26T10:23:42.33625+00:00',
- dueAt: null,
- bodyV2: {
- blocknote: '',
- markdown: '',
- },
- title: 'Task title',
- assigneeId: null,
- __typename: 'Task',
- },
- __typename: 'TaskTarget',
-};
-
-cache.writeFragment({
- fragment: gql`
- fragment TaskTargetFragment on TaskTarget {
- __typename
- updatedAt
- createdAt
- targetPersonId
- taskId
- targetCompanyId
- id
- task {
- __typename
- createdAt
- title
- updatedAt
- bodyV2 {
- blocknote
- markdown
- }
- dueAt
- id
- assigneeId
- }
- targetPerson {
- __typename
- id
- createdAt
- updatedAt
- city
- name {
- firstName
- lastName
- }
- }
- targetCompany {
- __typename
- id
- createdAt
- updatedAt
- }
- }
- `,
- id: `TaskTarget:${taskTarget.id}`,
- data: taskTarget,
-});
-
-const task = {
- id: '89bb825c-171e-4bcc-9cf7-43448d6fb230',
- createdAt: '2023-04-26T10:12:42.33625+00:00',
- updatedAt: '2023-04-26T10:23:42.33625+00:00',
- title: 'Task title',
- bodyV2: {
- blocknote: null,
- markdown: null,
- },
- assigneeId: null,
- status: null,
- dueAt: '2023-04-26T10:12:42.33625+00:00',
- assignee: null,
- __typename: 'Task' as any,
- taskTargets: [taskTarget],
-};
-
-const Wrapper = ({ children }: { children: ReactNode }) => (
- <JotaiProvider store={jotaiStore}>
- <MockedProvider cache={cache}>
- <JestObjectMetadataItemSetter>
- <SnackBarComponentInstanceContext.Provider
- value={{ instanceId: 'snack-bar-manager' }}
- >
- {children}
- </SnackBarComponentInstanceContext.Provider>
- </JestObjectMetadataItemSetter>
- </MockedProvider>
- </JotaiProvider>
-);
-
-describe('useActivityTargetObjectRecords', () => {
- it('return targetObjects', async () => {
- jotaiStore.set(
- currentWorkspaceMemberState.atom,
- getRecordFromRecordNode<WorkspaceMember>({
- recordNode: mockedWorkspaceMemberRecords[0],
- }),
- );
-
- setTestObjectMetadataItemsInMetadataStore(
- jotaiStore,
- getTestEnrichedObjectMetadataItemsMock(),
- );
-
- const { result } = renderHook(
- () => {
- const setRecordStore = useSetAtomFamilyState(
- recordStoreFamilyState,
- task.id,
- );
-
- const { activityTargetObjectRecords } = useActivityTargetObjectRecords(
- task.id,
- );
-
- return {
- activityTargetObjectRecords,
- setRecordStore,
- };
- },
- { wrapper: Wrapper },
- );
-
- act(() => {
- result.current.setRecordStore(task);
- });
-
- const activityTargetObjectRecords =
- result.current.activityTargetObjectRecords;
-
- expect(activityTargetObjectRecords).toHaveLength(1);
- expect(activityTargetObjectRecords[0].activityTarget).toEqual(taskTarget);
- expect(activityTargetObjectRecords[0].targetObject).toEqual(
- taskTarget.targetPerson,
- );
- expect(
- activityTargetObjectRecords[0].targetObjectMetadataItem.nameSingular,
- ).toEqual('person');
- });
-});
diff --git a/packages/twenty-front/src/modules/activities/hooks/__tests__/useCreateActivityInDB.test.tsx b/packages/twenty-front/src/modules/activities/hooks/__tests__/useCreateActivityInDB.test.tsx
index d219848a613..8e8adc13f43 100644
--- a/packages/twenty-front/src/modules/activities/hooks/__tests__/useCreateActivityInDB.test.tsx
+++ b/packages/twenty-front/src/modules/activities/hooks/__tests__/useCreateActivityInDB.test.tsx
@@ -4,9 +4,13 @@ import { act, renderHook } from '@testing-library/react';
import { createOneActivityOperationSignatureFactory } from '@/activities/graphql/operation-signatures/factories/createOneActivityOperationSignatureFactory';
import { useCreateActivityInDB } from '@/activities/hooks/useCreateActivityInDB';
import { type Task } from '@/activities/types/Task';
+import { getObjectMorphJunctionConfig } from '@/object-record/record-field/ui/utils/junction/getObjectMorphJunctionConfig';
import { CoreObjectNameSingular } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
import { generateCreateOneRecordMutation } from '@/object-metadata/utils/generateCreateOneRecordMutation';
import { getRecordFromRecordNode } from '@/object-record/cache/utils/getRecordFromRecordNode';
+import { recordStoreFamilyState } from '@/object-record/record-store/states/recordStoreFamilyState';
+import { jotaiStore } from '@/ui/utilities/state/jotai/jotaiStore';
import { getJestMetadataAndApolloMocksWrapper } from '~/testing/jest/getJestMetadataAndApolloMocksWrapper';
import { mockedTaskRecords } from '~/testing/mock-data/generated/data/tasks/mock-tasks-data';
import { getTestEnrichedObjectMetadataItemsMock } from '~/testing/utils/getTestEnrichedObjectMetadataItemsMock';
@@ -31,6 +35,15 @@ const mockedActivity = {
};
const taskMetadataItem = getMockObjectMetadataItemOrThrow('task');
+const objectMetadataItems = getTestEnrichedObjectMetadataItemsMock();
+const activityTargetFieldName = getObjectMorphJunctionConfig({
+ objectMetadata: taskMetadataItem,
+ objectMetadataItems,
+})?.junctionField.name;
+
+if (!isDefined(activityTargetFieldName)) {
+ throw new Error('Task target junction metadata is missing');
+}
const operationSignature = createOneActivityOperationSignatureFactory({
objectNameSingular: CoreObjectNameSingular.Task,
@@ -38,7 +51,7 @@ const operationSignature = createOneActivityOperationSignatureFactory({
const createOneTaskMutation = generateCreateOneRecordMutation({
objectMetadataItem: taskMetadataItem,
- objectMetadataItems: getTestEnrichedObjectMetadataItemsMock(),
+ objectMetadataItems,
recordGqlFields: operationSignature.fields,
objectPermissionsByObjectMetadataId: {},
});
@@ -91,5 +104,10 @@ describe('useCreateActivityInDB', () => {
});
expect(mockResult).toHaveBeenCalled();
+ expect(jotaiStore.get(recordStoreFamilyState.atomFamily(id))).toMatchObject(
+ {
+ [activityTargetFieldName]: [],
+ },
+ );
});
});
diff --git a/packages/twenty-front/src/modules/activities/hooks/__tests__/useOpenCreateActivityDrawer.test.tsx b/packages/twenty-front/src/modules/activities/hooks/__tests__/useOpenCreateActivityDrawer.test.tsx
index cc720927282..d5604d24d33 100644
--- a/packages/twenty-front/src/modules/activities/hooks/__tests__/useOpenCreateActivityDrawer.test.tsx
+++ b/packages/twenty-front/src/modules/activities/hooks/__tests__/useOpenCreateActivityDrawer.test.tsx
@@ -10,17 +10,16 @@ import { jotaiStore } from '@/ui/utilities/state/jotai/jotaiStore';
import { getJestMetadataAndApolloMocksWrapper } from '~/testing/jest/getJestMetadataAndApolloMocksWrapper';
const mockCreateOneNote = jest.fn();
-const mockCreateOneNoteTarget = jest.fn();
+const mockCreateManyNoteTargets = jest.fn();
jest.mock('@/object-record/hooks/useCreateOneRecord', () => ({
- useCreateOneRecord: ({
- objectNameSingular,
- }: {
- objectNameSingular: string;
- }) =>
- objectNameSingular === CoreObjectNameSingular.NoteTarget
- ? { createOneRecord: mockCreateOneNoteTarget }
- : { createOneRecord: mockCreateOneNote },
+ useCreateOneRecord: () => ({ createOneRecord: mockCreateOneNote }),
+}));
+
+jest.mock('@/object-record/hooks/useCreateManyRecords', () => ({
+ useCreateManyRecords: () => ({
+ createManyRecords: mockCreateManyNoteTargets,
+ }),
}));
const mockOpenRecordInSidePanel = jest.fn();
@@ -41,12 +40,10 @@ describe('useOpenCreateActivityDrawer', () => {
beforeEach(() => {
jest.clearAllMocks();
mockCreateOneNote.mockResolvedValue({ id: fakeNoteId });
- mockCreateOneNoteTarget.mockResolvedValue({
- id: 'fake-note-target-id',
- });
+ mockCreateManyNoteTargets.mockResolvedValue([]);
});
- it('should create a note and note target then open the record in the side panel', async () => {
+ it('should create a note without an empty junction record then open the side panel', async () => {
const { result } = renderHook(
() =>
useOpenCreateActivityDrawer({
@@ -65,9 +62,7 @@ describe('useOpenCreateActivityDrawer', () => {
position: 'last',
});
- expect(mockCreateOneNoteTarget).toHaveBeenCalledWith({
- noteId: fakeNoteId,
- });
+ expect(mockCreateManyNoteTargets).not.toHaveBeenCalled();
expect(mockOpenRecordInSidePanel).toHaveBeenCalledWith({
recordId: fakeNoteId,
@@ -83,12 +78,16 @@ describe('useOpenCreateActivityDrawer', () => {
expect(jotaiStore.get(isUpsertingActivityInDBState.atom)).toBe(false);
});
- it('should create a note target with the targetable object relation when targets are provided', async () => {
+ it('should create every requested target through junction metadata', async () => {
const targetableObjects = [
{
id: 'company-id',
targetObjectNameSingular: CoreObjectNameSingular.Company,
},
+ {
+ id: 'person-id',
+ targetObjectNameSingular: CoreObjectNameSingular.Person,
+ },
];
const { result } = renderHook(
@@ -109,14 +108,51 @@ describe('useOpenCreateActivityDrawer', () => {
position: 'last',
});
- expect(mockCreateOneNoteTarget).toHaveBeenCalledWith(
- expect.objectContaining({
- noteId: fakeNoteId,
- }),
- );
+ expect(mockCreateManyNoteTargets).toHaveBeenCalledWith({
+ recordsToCreate: [
+ expect.objectContaining({
+ noteId: fakeNoteId,
+ targetCompanyId: 'company-id',
+ }),
+ expect.objectContaining({
+ noteId: fakeNoteId,
+ targetPersonId: 'person-id',
+ }),
+ ],
+ upsert: true,
+ });
expect(jotaiStore.get(activityTargetableEntityArrayState.atom)).toEqual(
targetableObjects,
);
});
+
+ it('should ignore targets not supported by the junction metadata', async () => {
+ const unsupportedTarget = {
+ id: 'unsupported-id',
+ targetObjectNameSingular: 'unsupportedObject',
+ };
+
+ const { result } = renderHook(
+ () =>
+ useOpenCreateActivityDrawer({
+ activityObjectNameSingular: CoreObjectNameSingular.Note,
+ }),
+ { wrapper: Wrapper },
+ );
+
+ await act(async () => {
+ await result.current({
+ targetableObjects: [unsupportedTarget],
+ });
+ });
+
+ expect(mockCreateManyNoteTargets).not.toHaveBeenCalled();
+ expect(mockOpenRecordInSidePanel).toHaveBeenCalledWith({
+ recordId: fakeNoteId,
+ objectNameSingular: CoreObjectNameSingular.Note,
+ isNewRecord: true,
+ });
+ expect(jotaiStore.get(activityTargetableEntityArrayState.atom)).toEqual([]);
+ });
});
diff --git a/packages/twenty-front/src/modules/activities/hooks/useActivities.ts b/packages/twenty-front/src/modules/activities/hooks/useActivities.ts
index a77c3742ec7..b330e300e79 100644
--- a/packages/twenty-front/src/modules/activities/hooks/useActivities.ts
+++ b/packages/twenty-front/src/modules/activities/hooks/useActivities.ts
@@ -3,10 +3,8 @@ import { useStore } from 'jotai';
import { useActivityTargetsForTargetableObjects } from '@/activities/hooks/useActivityTargetsForTargetableObjects';
import { type ActivityTargetableObject } from '@/activities/types/ActivityTargetableEntity';
-import { type Note } from '@/activities/types/Note';
-import { type NoteTarget } from '@/activities/types/NoteTarget';
-import { type Task } from '@/activities/types/Task';
-import { type TaskTarget } from '@/activities/types/TaskTarget';
+import { type ActivityTarget } from '@/activities/types/ActivityTarget';
+import { getRelatedRecordFromJunction } from '@/object-record/record-field/ui/utils/junction/getRelatedRecordFromJunction';
import {
type CoreObjectNameSingular,
type RecordGqlOperationOrderBy,
@@ -15,7 +13,7 @@ import { getRecordsFromRecordConnection } from '@/object-record/cache/utils/getR
import { recordStoreFamilyState } from '@/object-record/record-store/states/recordStoreFamilyState';
import { isDefined } from 'twenty-shared/utils';
-export const useActivities = <T extends Task | Note>({
+export const useActivities = ({
objectNameSingular,
targetableObjects,
activityTargetsOrderByVariables,
@@ -30,9 +28,12 @@ export const useActivities = <T extends Task | Note>({
}) => {
const store = useStore();
const updateActivitiesInStore = useCallback(
- (activityTargets: (TaskTarget | NoteTarget)[]) => {
+ (activityTargets: ActivityTarget[], activityRelationFieldName: string) => {
for (const activityTarget of activityTargets) {
- const activity = activityTarget[objectNameSingular];
+ const activity = getRelatedRecordFromJunction({
+ junctionRecord: activityTarget,
+ relationFieldName: activityRelationFieldName,
+ });
if (!isDefined(activity)) {
continue;
@@ -41,7 +42,7 @@ export const useActivities = <T extends Task | Note>({
store.set(recordStoreFamilyState.atomFamily(activity.id), activity);
}
},
- [store, objectNameSingular],
+ [store],
);
const {
@@ -50,6 +51,7 @@ export const useActivities = <T extends Task | Note>({
totalCountActivityTargets,
fetchMoreActivityTargets,
hasNextPage,
+ activityRelationFieldName,
} = useActivityTargetsForTargetableObjects({
objectNameSingular,
targetableObjects,
@@ -61,9 +63,12 @@ export const useActivities = <T extends Task | Note>({
const activities = activityTargets
.map((activityTarget) => {
- return activityTarget[objectNameSingular];
+ return getRelatedRecordFromJunction({
+ junctionRecord: activityTarget,
+ relationFieldName: activityRelationFieldName,
+ });
})
- .filter(isDefined) as T[];
+ .filter(isDefined);
const fetchMoreActivities = async () => {
const result = await fetchMoreActivityTargets();
@@ -72,23 +77,24 @@ export const useActivities = <T extends Task | Note>({
return [];
}
- const activityTargets = getRecordsFromRecordConnection<
- TaskTarget | NoteTarget
- >({
+ const activityTargets = getRecordsFromRecordConnection<ActivityTarget>({
recordConnection: result.data,
});
- updateActivitiesInStore(activityTargets);
+ updateActivitiesInStore(activityTargets, activityRelationFieldName);
return activityTargets
.map((activityTarget) => {
- return activityTarget[objectNameSingular];
+ return getRelatedRecordFromJunction({
+ junctionRecord: activityTarget,
+ relationFieldName: activityRelationFieldName,
+ });
})
- .filter(isDefined) as T[];
+ .filter(isDefined);
};
return {
- activities: activities as T[],
+ activities,
loading: loadingActivityTargets,
totalCountActivities: totalCountActivityTargets,
fetchMoreActivities,
diff --git a/packages/twenty-front/src/modules/activities/inline-cell/hooks/useActivityTargetsComponentInstanceId.ts b/packages/twenty-front/src/modules/activities/hooks/useActivityFieldComponentInstanceId.ts
similarity index 84%
rename from packages/twenty-front/src/modules/activities/inline-cell/hooks/useActivityTargetsComponentInstanceId.ts
rename to packages/twenty-front/src/modules/activities/hooks/useActivityFieldComponentInstanceId.ts
index cbfee7ee7eb..21ea9844f1e 100644
--- a/packages/twenty-front/src/modules/activities/inline-cell/hooks/useActivityTargetsComponentInstanceId.ts
+++ b/packages/twenty-front/src/modules/activities/hooks/useActivityFieldComponentInstanceId.ts
@@ -1,6 +1,6 @@
import { useIsInSidePanelOrThrow } from '@/ui/layout/side-panel/contexts/SidePanelContext';
-export const useActivityTargetsComponentInstanceId = (
+export const useActivityFieldComponentInstanceId = (
baseComponentInstanceId: string,
) => {
const { isInSidePanel } = useIsInSidePanelOrThrow();
diff --git a/packages/twenty-front/src/modules/activities/hooks/useActivityTargetObjectRecords.ts b/packages/twenty-front/src/modules/activities/hooks/useActivityTargetObjectRecords.ts
deleted file mode 100644
index e5e383752a0..00000000000
--- a/packages/twenty-front/src/modules/activities/hooks/useActivityTargetObjectRecords.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-import { type Note } from '@/activities/types/Note';
-import { type NoteTarget } from '@/activities/types/NoteTarget';
-import { type Task } from '@/activities/types/Task';
-import { type TaskTarget } from '@/activities/types/TaskTarget';
-import { getActivityTargetObjectRecords } from '@/activities/utils/getActivityTargetObjectRecords';
-import { objectMetadataItemsSelector } from '@/object-metadata/states/objectMetadataItemsSelector';
-import { recordStoreFamilyState } from '@/object-record/record-store/states/recordStoreFamilyState';
-import { useAtomFamilyStateValue } from '@/ui/utilities/state/jotai/hooks/useAtomFamilyStateValue';
-import { useAtomStateValue } from '@/ui/utilities/state/jotai/hooks/useAtomStateValue';
-import { type Nullable } from 'twenty-shared/types';
-import { isDefined } from 'twenty-shared/utils';
-
-export const useActivityTargetObjectRecords = (
- activityRecordId?: string,
- activityTargets?: Nullable<NoteTarget[] | TaskTarget[]>,
-) => {
- const objectMetadataItems = useAtomStateValue(objectMetadataItemsSelector);
-
- const activity = useAtomFamilyStateValue(
- recordStoreFamilyState,
- activityRecordId ?? '',
- ) as Note | Task | null;
-
- if (!isDefined(activity) && !isDefined(activityTargets)) {
- return { activityTargetObjectRecords: [] };
- }
-
- const activityTargetObjectRecords = getActivityTargetObjectRecords({
- activityRecord: activity as Note | Task,
- objectMetadataItems,
- activityTargets,
- });
-
- return {
- activityTargetObjectRecords,
- };
-};
diff --git a/packages/twenty-front/src/modules/activities/hooks/useActivityTargetsForTargetableObjects.ts b/packages/twenty-front/src/modules/activities/hooks/useActivityTargetsForTargetableObjects.ts
index 9964dfe483d..6162e9bdf62 100644
--- a/packages/twenty-front/src/modules/activities/hooks/useActivityTargetsForTargetableObjects.ts
+++ b/packages/twenty-front/src/modules/activities/hooks/useActivityTargetsForTargetableObjects.ts
@@ -4,9 +4,9 @@ import {
} from 'twenty-shared/types';
import { findActivityTargetsOperationSignatureFactory } from '@/activities/graphql/operation-signatures/factories/findActivityTargetsOperationSignatureFactory';
+import { useObjectMorphJunctionConfigOrThrow } from '@/object-record/record-field/ui/hooks/useObjectMorphJunctionConfigOrThrow';
import { type ActivityTargetableObject } from '@/activities/types/ActivityTargetableEntity';
-import { type NoteTarget } from '@/activities/types/NoteTarget';
-import { type TaskTarget } from '@/activities/types/TaskTarget';
+import { type ActivityTarget } from '@/activities/types/ActivityTarget';
import { getActivityTargetsFilter } from '@/activities/utils/getActivityTargetsFilter';
import { objectMetadataItemsSelector } from '@/object-metadata/states/objectMetadataItemsSelector';
import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
@@ -27,23 +27,34 @@ export const useActivityTargetsForTargetableObjects = ({
'id' | 'targetObjectNameSingular'
>[];
skip?: boolean;
- onCompleted?: (activityTargets: (TaskTarget | NoteTarget)[]) => void;
+ onCompleted?: (
+ activityTargets: ActivityTarget[],
+ activityRelationFieldName: string,
+ ) => void;
activityTargetsOrderByVariables: RecordGqlOperationOrderBy;
limit: number;
}) => {
const objectMetadataItems = useAtomStateValue<EnrichedObjectMetadataItem[]>(
objectMetadataItemsSelector,
);
- const activityTargetsFilter = getActivityTargetsFilter({
- targetableObjects,
- });
-
const FIND_ACTIVITY_TARGETS_OPERATION_SIGNATURE =
findActivityTargetsOperationSignatureFactory({
objectNameSingular,
objectMetadataItems,
});
+ const morphJunctionConfig = useObjectMorphJunctionConfigOrThrow({
+ objectNameSingular,
+ });
+
+ const { junctionObjectMetadata, sourceField } = morphJunctionConfig;
+
+ const activityTargetsFilter = getActivityTargetsFilter({
+ targetableObjects,
+ activityTargetObjectMetadata: junctionObjectMetadata,
+ objectMetadataItems,
+ });
+
// TODO: We want to optimistically remove from this request
// If we are on a show page and we remove the current show page object corresponding activity target
// See also if we need to update useTimelineActivities
@@ -53,13 +64,13 @@ export const useActivityTargetsForTargetableObjects = ({
totalCount: totalCountActivityTargets,
fetchMoreRecords: fetchMoreActivityTargets,
hasNextPage,
- } = useFindManyRecords<TaskTarget | NoteTarget>({
+ } = useFindManyRecords<ActivityTarget>({
skip,
objectNameSingular:
FIND_ACTIVITY_TARGETS_OPERATION_SIGNATURE.objectNameSingular,
filter: activityTargetsFilter,
recordGqlFields: FIND_ACTIVITY_TARGETS_OPERATION_SIGNATURE.fields,
- onCompleted,
+ onCompleted: (records) => onCompleted?.(records, sourceField.name),
orderBy: activityTargetsOrderByVariables,
limit,
});
@@ -70,5 +81,6 @@ export const useActivityTargetsForTargetableObjects = ({
totalCountActivityTargets: totalCountActivityTargets ?? 0,
fetchMoreActivityTargets,
hasNextPage,
+ activityRelationFieldName: sourceField.name,
};
};
diff --git a/packages/twenty-front/src/modules/activities/hooks/useCreateActivityInDB.ts b/packages/twenty-front/src/modules/activities/hooks/useCreateActivityInDB.ts
index 3a6ddf37e80..a3330daaa59 100644
--- a/packages/twenty-front/src/modules/activities/hooks/useCreateActivityInDB.ts
+++ b/packages/twenty-front/src/modules/activities/hooks/useCreateActivityInDB.ts
@@ -14,9 +14,9 @@ import { useCreateOneRecord } from '@/object-record/hooks/useCreateOneRecord';
import { recordStoreFamilyState } from '@/object-record/record-store/states/recordStoreFamilyState';
import { createOneActivityOperationSignatureFactory } from '@/activities/graphql/operation-signatures/factories/createOneActivityOperationSignatureFactory';
-import { type NoteTarget } from '@/activities/types/NoteTarget';
-import { type TaskTarget } from '@/activities/types/TaskTarget';
-import { getJoinObjectNameSingular } from '@/activities/utils/getJoinObjectNameSingular';
+import { useObjectMorphJunctionConfigOrThrow } from '@/object-record/record-field/ui/hooks/useObjectMorphJunctionConfigOrThrow';
+import { getJunctionRecordsFromRecord } from '@/object-record/record-field/ui/utils/junction/getJunctionRecordsFromRecord';
+import { type ActivityTarget } from '@/activities/types/ActivityTarget';
import { capitalize } from 'twenty-shared/utils';
export const useCreateActivityInDB = ({
@@ -37,25 +37,24 @@ export const useCreateActivityInDB = ({
shouldMatchRootQueryFilter: true,
});
- const { createManyRecords: createManyActivityTargets } = useCreateManyRecords<
- TaskTarget | NoteTarget
- >({
- objectNameSingular: getJoinObjectNameSingular(activityObjectNameSingular),
- shouldMatchRootQueryFilter: true,
- });
-
const { objectMetadataItems } = useObjectMetadataItems();
- const { objectMetadataItem: objectMetadataItemActivityTarget } =
- useObjectMetadataItem({
- objectNameSingular: getJoinObjectNameSingular(activityObjectNameSingular),
- });
-
const { objectMetadataItem: objectMetadataItemActivity } =
useObjectMetadataItem({
objectNameSingular: activityObjectNameSingular,
});
+ const morphJunctionConfig = useObjectMorphJunctionConfigOrThrow({
+ objectNameSingular: activityObjectNameSingular,
+ });
+
+ const { createManyRecords: createManyActivityTargets } =
+ useCreateManyRecords<ActivityTarget>({
+ objectNameSingular:
+ morphJunctionConfig.junctionObjectMetadata.nameSingular,
+ shouldMatchRootQueryFilter: true,
+ });
+
const cache = useApolloCoreClient().cache;
const store = useStore();
@@ -66,8 +65,12 @@ export const useCreateActivityInDB = ({
updatedAt: new Date().toISOString(),
});
- const activityTargetsToCreate =
- activityToCreate.noteTargets ?? activityToCreate.taskTargets ?? [];
+ const { junctionObjectMetadata, junctionField } = morphJunctionConfig;
+
+ const activityTargetsToCreate = getJunctionRecordsFromRecord({
+ record: activityToCreate,
+ junctionFieldName: junctionField.name,
+ });
if (isNonEmptyArray(activityTargetsToCreate)) {
await createManyActivityTargets({
@@ -77,10 +80,10 @@ export const useCreateActivityInDB = ({
const activityTargetsConnection = getRecordConnectionFromRecords({
objectMetadataItems,
- objectMetadataItem: objectMetadataItemActivityTarget,
+ objectMetadataItem: junctionObjectMetadata,
records: activityTargetsToCreate.map((activityTarget) => ({
...activityTarget,
- __typename: capitalize(objectMetadataItemActivityTarget.nameSingular),
+ __typename: capitalize(junctionObjectMetadata.nameSingular),
})),
withPageInfo: false,
computeReferences: true,
@@ -91,14 +94,14 @@ export const useCreateActivityInDB = ({
recordId: createdActivity.id,
cache,
fieldModifiers: {
- activityTargets: () => activityTargetsConnection,
+ [junctionField.name]: () => activityTargetsConnection,
},
objectMetadataItem: objectMetadataItemActivity,
});
store.set(recordStoreFamilyState.atomFamily(createdActivity.id), {
...createdActivity,
- activityTargets: activityTargetsToCreate,
+ [junctionField.name]: activityTargetsToCreate,
});
},
[
@@ -106,8 +109,8 @@ export const useCreateActivityInDB = ({
cache,
createManyActivityTargets,
createOneActivity,
+ morphJunctionConfig,
objectMetadataItemActivity,
- objectMetadataItemActivityTarget,
objectMetadataItems,
],
);
diff --git a/packages/twenty-front/src/modules/activities/hooks/useOpenCreateActivityDrawer.ts b/packages/twenty-front/src/modules/activities/hooks/useOpenCreateActivityDrawer.ts
index 483a8d11316..8a91fd66a9b 100644
--- a/packages/twenty-front/src/modules/activities/hooks/useOpenCreateActivityDrawer.ts
+++ b/packages/twenty-front/src/modules/activities/hooks/useOpenCreateActivityDrawer.ts
@@ -8,13 +8,14 @@ import { isUpsertingActivityInDBState } from '@/activities/states/isCreatingActi
import { useSetAtomState } from '@/ui/utilities/state/jotai/hooks/useSetAtomState';
import { type ActivityTargetableObject } from '@/activities/types/ActivityTargetableEntity';
import { type Note } from '@/activities/types/Note';
-import { type NoteTarget } from '@/activities/types/NoteTarget';
import { type Task } from '@/activities/types/Task';
-import { type TaskTarget } from '@/activities/types/TaskTarget';
import { useOpenRecordInSidePanel } from '@/side-panel/hooks/useOpenRecordInSidePanel';
import { useObjectMetadataItems } from '@/object-metadata/hooks/useObjectMetadataItems';
+import { useCreateManyRecords } from '@/object-record/hooks/useCreateManyRecords';
import { useCreateOneRecord } from '@/object-record/hooks/useCreateOneRecord';
import { findTargetFieldInfo } from '@/object-record/record-field/ui/utils/junction/findTargetFieldInfo';
+import { useObjectMorphJunctionConfigOrThrow } from '@/object-record/record-field/ui/hooks/useObjectMorphJunctionConfigOrThrow';
+import { isDefined } from 'twenty-shared/utils';
export const useOpenCreateActivityDrawer = ({
activityObjectNameSingular,
@@ -29,13 +30,14 @@ export const useOpenCreateActivityDrawer = ({
objectNameSingular: activityObjectNameSingular,
});
- const { createOneRecord: createOneActivityTarget } = useCreateOneRecord<
- TaskTarget | NoteTarget
- >({
- objectNameSingular:
- activityObjectNameSingular === CoreObjectNameSingular.Task
- ? CoreObjectNameSingular.TaskTarget
- : CoreObjectNameSingular.NoteTarget,
+ const { objectMetadataItems } = useObjectMetadataItems();
+
+ const morphJunctionConfig = useObjectMorphJunctionConfigOrThrow({
+ objectNameSingular: activityObjectNameSingular,
+ });
+
+ const { createManyRecords: createActivityTargets } = useCreateManyRecords({
+ objectNameSingular: morphJunctionConfig.junctionObjectMetadata.nameSingular,
shouldMatchRootQueryFilter: true,
});
@@ -53,8 +55,6 @@ export const useOpenCreateActivityDrawer = ({
const { openRecordInSidePanel } = useOpenRecordInSidePanel();
- const { objectMetadataItems } = useObjectMetadataItems();
-
const openCreateActivityDrawer = async ({
targetableObjects,
customAssignee,
@@ -74,57 +74,44 @@ export const useOpenCreateActivityDrawer = ({
position: 'last',
});
- if (targetableObjects.length > 0) {
- const activityTargetObjectNameSingular =
- activityObjectNameSingular === CoreObjectNameSingular.Task
- ? CoreObjectNameSingular.TaskTarget
- : CoreObjectNameSingular.NoteTarget;
+ const { junctionObjectMetadata, sourceJoinColumnName } =
+ morphJunctionConfig;
- const activityTargetObjectMetadata = objectMetadataItems.find(
- (item) => item.nameSingular === activityTargetObjectNameSingular,
- );
-
- const targetObjectMetadataItem = objectMetadataItems.find(
+ const supportedTargets = targetableObjects.flatMap((targetableObject) => {
+ const targetObjectMetadata = objectMetadataItems.find(
(item) =>
- item.nameSingular === targetableObjects[0].targetObjectNameSingular,
+ item.nameSingular === targetableObject.targetObjectNameSingular,
);
-
const targetFieldInfo = findTargetFieldInfo(
- activityTargetObjectMetadata?.fields ?? [],
- targetObjectMetadataItem?.id ?? '',
+ junctionObjectMetadata.fields,
+ targetObjectMetadata?.id ?? '',
objectMetadataItems,
);
- const targetableObjectRelationIdName =
- targetFieldInfo?.joinColumnName ??
- `${targetableObjects[0].targetObjectNameSingular}Id`;
-
- await createOneActivityTarget({
- ...(activityObjectNameSingular === CoreObjectNameSingular.Task
- ? {
- taskId: activity.id,
- }
- : {
- noteId: activity.id,
- }),
- [targetableObjectRelationIdName]: targetableObjects[0].id,
- });
-
- setActivityTargetableEntityArray(targetableObjects);
- } else {
- await createOneActivityTarget({
- ...(activityObjectNameSingular === CoreObjectNameSingular.Task
- ? {
- taskId: activity.id,
- }
- : {
- noteId: activity.id,
- }),
- });
-
- setActivityTargetableEntityArray([]);
+ if (!isDefined(targetFieldInfo?.joinColumnName)) {
+ return [];
+ }
+
+ return [
+ { targetableObject, joinColumnName: targetFieldInfo.joinColumnName },
+ ];
+ });
+
+ if (supportedTargets.length > 0) {
+ const recordsToCreate = supportedTargets.map(
+ ({ targetableObject, joinColumnName }) => ({
+ [sourceJoinColumnName]: activity.id,
+ [joinColumnName]: targetableObject.id,
+ }),
+ );
+
+ await createActivityTargets({ recordsToCreate, upsert: true });
}
+ setActivityTargetableEntityArray(
+ supportedTargets.map(({ targetableObject }) => targetableObject),
+ );
+
openRecordInSidePanel({
recordId: activity.id,
objectNameSingular: activityObjectNameSingular,
diff --git a/packages/twenty-front/src/modules/activities/hooks/usePrepareFindManyActivitiesQuery.ts b/packages/twenty-front/src/modules/activities/hooks/usePrepareFindManyActivitiesQuery.ts
index f54a5a18db8..b6b14cf78fd 100644
--- a/packages/twenty-front/src/modules/activities/hooks/usePrepareFindManyActivitiesQuery.ts
+++ b/packages/twenty-front/src/modules/activities/hooks/usePrepareFindManyActivitiesQuery.ts
@@ -1,9 +1,6 @@
-import { findActivitiesOperationSignatureFactory } from '@/activities/graphql/operation-signatures/factories/findActivitiesOperationSignatureFactory';
import { type ActivityTargetableObject } from '@/activities/types/ActivityTargetableEntity';
import { type Note } from '@/activities/types/Note';
-import { type NoteTarget } from '@/activities/types/NoteTarget';
import { type Task } from '@/activities/types/Task';
-import { type TaskTarget } from '@/activities/types/TaskTarget';
import { useApolloCoreClient } from '@/object-metadata/hooks/useApolloCoreClient';
import { useObjectMetadataItem } from '@/object-metadata/hooks/useObjectMetadataItem';
import { useObjectMetadataItems } from '@/object-metadata/hooks/useObjectMetadataItems';
@@ -11,10 +8,16 @@ import { type CoreObjectNameSingular } from 'twenty-shared/types';
import { useGetRecordFromCache } from '@/object-record/cache/hooks/useGetRecordFromCache';
import { useUpsertFindManyRecordsQueryInCache } from '@/object-record/cache/hooks/useUpsertFindManyRecordsQueryInCache';
import { getRecordFromCache } from '@/object-record/cache/utils/getRecordFromCache';
+import { generateDepthRecordGqlFieldsFromObject } from '@/object-record/graphql/record-gql-fields/utils/generateDepthRecordGqlFieldsFromObject';
import { useObjectPermissions } from '@/object-record/hooks/useObjectPermissions';
+import { useObjectMorphJunctionConfigOrThrow } from '@/object-record/record-field/ui/hooks/useObjectMorphJunctionConfigOrThrow';
+import { findTargetFieldInfo } from '@/object-record/record-field/ui/utils/junction/findTargetFieldInfo';
+import { getJunctionRecordsFromRecord } from '@/object-record/record-field/ui/utils/junction/getJunctionRecordsFromRecord';
+import { getRelatedRecordIdFromJunction } from '@/object-record/record-field/ui/utils/junction/getRelatedRecordIdFromJunction';
import { type ObjectRecord } from '@/object-record/types/ObjectRecord';
import { isDefined } from 'twenty-shared/utils';
import { sortByAscString } from '~/utils/array/sortByAscString';
+import { useMemo } from 'react';
export const usePrepareFindManyActivitiesQuery = ({
activityObjectNameSingular,
@@ -26,14 +29,30 @@ export const usePrepareFindManyActivitiesQuery = ({
objectNameSingular: activityObjectNameSingular,
});
+ const { objectMetadataItems } = useObjectMetadataItems();
+
+ const activityRecordGqlFields = useMemo(
+ () =>
+ generateDepthRecordGqlFieldsFromObject({
+ objectMetadataItem: objectMetadataItemActivity,
+ objectMetadataItems,
+ depth: 1,
+ }),
+ [objectMetadataItemActivity, objectMetadataItems],
+ );
+
const getActivityFromCache = useGetRecordFromCache({
objectNameSingular: activityObjectNameSingular,
+ recordGqlFields: activityRecordGqlFields,
});
const cache = useApolloCoreClient().cache;
- const { objectMetadataItems } = useObjectMetadataItems();
const { objectPermissionsByObjectMetadataId } = useObjectPermissions();
+ const morphJunctionConfig = useObjectMorphJunctionConfigOrThrow({
+ objectNameSingular: activityObjectNameSingular,
+ });
+
const { upsertFindManyRecordsQueryInCache: upsertFindManyActivitiesInCache } =
useUpsertFindManyRecordsQueryInCache({
objectMetadataItem: objectMetadataItemActivity,
@@ -68,35 +87,40 @@ export const usePrepareFindManyActivitiesQuery = ({
objectPermissionsByObjectMetadataId,
});
- const activityTargets: (TaskTarget | NoteTarget)[] =
- targetableObjectRecord?.taskTargets ??
- targetableObjectRecord?.noteTargets ??
- [];
+ const { junctionObjectMetadata, sourceField, sourceJoinColumnName } =
+ morphJunctionConfig;
- const activityTargetIds = [
+ const junctionFieldName = findTargetFieldInfo(
+ targetableObjectMetadataItem.fields,
+ junctionObjectMetadata.id,
+ objectMetadataItems,
+ )?.fieldName;
+
+ const activityTargets = isDefined(junctionFieldName)
+ ? getJunctionRecordsFromRecord({
+ record: targetableObjectRecord ?? {},
+ junctionFieldName,
+ })
+ : [];
+
+ const activityIds = [
...new Set(
activityTargets
- .map((activityTarget) => activityTarget.id)
+ .map((activityTarget) =>
+ getRelatedRecordIdFromJunction({
+ junctionRecord: activityTarget,
+ relationFieldName: sourceField.name,
+ joinColumnName: sourceJoinColumnName,
+ }),
+ )
.filter(isDefined),
),
];
- const activities: (Task | Note)[] = activityTargetIds
- .map((activityTargetId) => {
- const activityTarget = activityTargets.find(
- (activityTarget) => activityTarget.id === activityTargetId,
- );
-
- if (!activityTarget) {
- return undefined;
- }
-
- return getActivityFromCache<Task | Note>(activityTarget.activityId);
- })
+ const activities: (Task | Note)[] = activityIds
+ .map((activityId) => getActivityFromCache<Task | Note>(activityId))
.filter(isDefined);
- const activityIds = [...new Set(activities.map((activity) => activity.id))];
-
const nextFindManyActivitiesQueryFilter = {
filter: {
id: {
@@ -112,19 +136,13 @@ export const usePrepareFindManyActivitiesQuery = ({
return a.createdAt > b.createdAt ? -1 : 1;
});
- const FIND_ACTIVITIES_OPERATION_SIGNATURE =
- findActivitiesOperationSignatureFactory({
- objectNameSingular: activityObjectNameSingular,
- objectMetadataItems,
- });
-
upsertFindManyActivitiesInCache({
objectRecordsToOverwrite: filteredActivities,
queryVariables: {
...nextFindManyActivitiesQueryFilter,
orderBy: [{ createdAt: 'DescNullsFirst' }],
},
- recordGqlFields: FIND_ACTIVITIES_OPERATION_SIGNATURE.fields,
+ recordGqlFields: activityRecordGqlFields,
computeReferences: true,
});
};
diff --git a/packages/twenty-front/src/modules/activities/inline-cell/components/ActivityTargetsInlineCell.tsx b/packages/twenty-front/src/modules/activities/inline-cell/components/ActivityTargetsInlineCell.tsx
deleted file mode 100644
index b7aee545a8d..00000000000
--- a/packages/twenty-front/src/modules/activities/inline-cell/components/ActivityTargetsInlineCell.tsx
+++ /dev/null
@@ -1,140 +0,0 @@
-import { t } from '@lingui/core/macro';
-import { useCallback, useContext, useState } from 'react';
-
-import { ActivityTargetChips } from '@/activities/components/ActivityTargetChips';
-import { useActivityTargetObjectRecords } from '@/activities/hooks/useActivityTargetObjectRecords';
-import { useOpenActivityTargetCellEditMode } from '@/activities/inline-cell/hooks/useOpenActivityTargetCellEditMode';
-import { useUpdateActivityTargetFromCell } from '@/activities/inline-cell/hooks/useUpdateActivityTargetFromCell';
-import { type CoreObjectNameSingular } from 'twenty-shared/types';
-import { RecordFieldsScopeContextProvider } from '@/object-record/record-field-list/contexts/RecordFieldsScopeContext';
-import { FieldContextProvider } from '@/object-record/record-field/ui/components/FieldContextProvider';
-import { FieldContext } from '@/object-record/record-field/ui/contexts/FieldContext';
-import { FieldFocusContextProvider } from '@/object-record/record-field/ui/contexts/FieldFocusContextProvider';
-import { RecordFieldComponentInstanceContext } from '@/object-record/record-field/ui/states/contexts/RecordFieldComponentInstanceContext';
-import { RecordInlineCellContainer } from '@/object-record/record-inline-cell/components/RecordInlineCellContainer';
-import { RecordInlineCellContext } from '@/object-record/record-inline-cell/components/RecordInlineCellContext';
-import { RecordInlineCellEditMode } from '@/object-record/record-inline-cell/components/RecordInlineCellEditMode';
-import { MultipleRecordPicker } from '@/object-record/record-picker/multiple-record-picker/components/MultipleRecordPicker';
-import { useGoBackToPreviousDropdownFocusId } from '@/ui/layout/dropdown/hooks/useGoBackToPreviousDropdownFocusId';
-import { IconArrowUpRight, IconPencil } from 'twenty-ui/icon';
-
-type ActivityTargetsInlineCellProps = {
- activityRecordId: string;
- showLabel?: boolean;
- maxWidth?: number;
- activityObjectNameSingular:
- | CoreObjectNameSingular.Note
- | CoreObjectNameSingular.Task;
- componentInstanceId: string;
-};
-
-export const ActivityTargetsInlineCell = ({
- activityRecordId,
- showLabel = true,
- maxWidth,
- activityObjectNameSingular,
- componentInstanceId,
-}: ActivityTargetsInlineCellProps) => {
- const { activityTargetObjectRecords } =
- useActivityTargetObjectRecords(activityRecordId);
-
- const {
- fieldDefinition,
- isRecordFieldReadOnly: isReadOnly,
- anchorId,
- onMouseEnter,
- } = useContext(FieldContext);
-
- const { openActivityTargetCellEditMode } =
- useOpenActivityTargetCellEditMode();
-
- const { updateActivityTargetFromCell } = useUpdateActivityTargetFromCell({
- activityObjectNameSingular,
- activityId: activityRecordId,
- });
-
- const [isRelationPickerOpen, setIsRelationPickerOpen] = useState(false);
-
- const { goBackToPreviousDropdownFocusId } =
- useGoBackToPreviousDropdownFocusId();
-
- const handleOpenRelationPicker = useCallback(() => {
- openActivityTargetCellEditMode({
- recordPickerInstanceId: componentInstanceId,
- activityTargetObjectRecords,
- });
- setIsRelationPickerOpen(true);
- }, [
- activityTargetObjectRecords,
- componentInstanceId,
- openActivityTargetCellEditMode,
- ]);
-
- const handleCloseRelationPicker = useCallback(() => {
- setIsRelationPickerOpen(false);
- goBackToPreviousDropdownFocusId();
- }, [goBackToPreviousDropdownFocusId]);
-
- return (
- <RecordFieldsScopeContextProvider
- value={{ scopeInstanceId: componentInstanceId }}
- >
- <RecordFieldComponentInstanceContext.Provider
- value={{
- instanceId: componentInstanceId,
- }}
- >
- <FieldFocusContextProvider>
- <FieldContextProvider
- objectNameSingular={activityObjectNameSingular}
- objectRecordId={activityRecordId}
- fieldMetadataName={fieldDefinition.metadata.fieldName}
- fieldPosition={3}
- overridenIsFieldEmpty={activityTargetObjectRecords.length === 0}
- onMouseEnter={onMouseEnter}
- anchorId={anchorId}
- >
- <RecordInlineCellContext.Provider
- value={{
- buttonIcon: IconPencil,
- IconLabel: showLabel ? IconArrowUpRight : undefined,
- showLabel: showLabel,
- readonly: isReadOnly,
- labelWidth: fieldDefinition?.labelWidth,
- label: t`Relations`,
- displayModeContent: (
- <ActivityTargetChips
- activityTargetObjectRecords={activityTargetObjectRecords}
- maxWidth={maxWidth}
- />
- ),
- onOpenEditMode: handleOpenRelationPicker,
- onCloseEditMode: handleCloseRelationPicker,
- }}
- >
- <RecordInlineCellContainer />
- {isRelationPickerOpen && (
- <RecordInlineCellEditMode>
- <MultipleRecordPicker
- focusId={componentInstanceId}
- componentInstanceId={componentInstanceId}
- onClickOutside={handleCloseRelationPicker}
- onChange={(morphItem) => {
- updateActivityTargetFromCell({
- recordPickerInstanceId: componentInstanceId,
- morphItem,
- activityTargetWithTargetRecords:
- activityTargetObjectRecords,
- });
- }}
- onSubmit={handleCloseRelationPicker}
- />
- </RecordInlineCellEditMode>
- )}
- </RecordInlineCellContext.Provider>
- </FieldContextProvider>
- </FieldFocusContextProvider>
- </RecordFieldComponentInstanceContext.Provider>
- </RecordFieldsScopeContextProvider>
- );
-};
diff --git a/packages/twenty-front/src/modules/activities/inline-cell/hooks/useOpenActivityTargetCellEditMode.ts b/packages/twenty-front/src/modules/activities/inline-cell/hooks/useOpenActivityTargetCellEditMode.ts
deleted file mode 100644
index a99a5538ede..00000000000
--- a/packages/twenty-front/src/modules/activities/inline-cell/hooks/useOpenActivityTargetCellEditMode.ts
+++ /dev/null
@@ -1,111 +0,0 @@
-import { type ActivityTargetWithTargetRecord } from '@/activities/types/ActivityTargetObject';
-import { objectMetadataItemsSelector } from '@/object-metadata/states/objectMetadataItemsSelector';
-import { CoreObjectNameSingular } from 'twenty-shared/types';
-import { useMultipleRecordPickerOpen } from '@/object-record/record-picker/multiple-record-picker/hooks/useMultipleRecordPickerOpen';
-import { useMultipleRecordPickerPerformSearch } from '@/object-record/record-picker/multiple-record-picker/hooks/useMultipleRecordPickerPerformSearch';
-import { multipleRecordPickerPickableMorphItemsComponentState } from '@/object-record/record-picker/multiple-record-picker/states/multipleRecordPickerPickableMorphItemsComponentState';
-import { multipleRecordPickerSearchFilterComponentState } from '@/object-record/record-picker/multiple-record-picker/states/multipleRecordPickerSearchFilterComponentState';
-import { multipleRecordPickerSearchableObjectMetadataItemsComponentState } from '@/object-record/record-picker/multiple-record-picker/states/multipleRecordPickerSearchableObjectMetadataItemsComponentState';
-import { usePushFocusItemToFocusStack } from '@/ui/utilities/focus/hooks/usePushFocusItemToFocusStack';
-import { FocusComponentType } from '@/ui/utilities/focus/types/FocusComponentType';
-import { useCallback } from 'react';
-import { useStore } from 'jotai';
-
-type OpenActivityTargetCellEditModeProps = {
- recordPickerInstanceId: string;
- activityTargetObjectRecords: ActivityTargetWithTargetRecord[];
-};
-
-// TODO: deprecate this once we are supporting one to many through relations
-export const useOpenActivityTargetCellEditMode = () => {
- const store = useStore();
- const { performSearch: multipleRecordPickerPerformSearch } =
- useMultipleRecordPickerPerformSearch();
- const { openMultipleRecordPicker } = useMultipleRecordPickerOpen();
-
- const { pushFocusItemToFocusStack } = usePushFocusItemToFocusStack();
-
- const openActivityTargetCellEditMode = useCallback(
- ({
- recordPickerInstanceId,
- activityTargetObjectRecords,
- }: OpenActivityTargetCellEditModeProps) => {
- const objectMetadataItems = store
- .get(objectMetadataItemsSelector.atom)
- .filter(
- (objectMetadataItem) =>
- objectMetadataItem.isSearchable &&
- objectMetadataItem.isActive &&
- objectMetadataItem.nameSingular !== CoreObjectNameSingular.Task &&
- objectMetadataItem.nameSingular !== CoreObjectNameSingular.Note &&
- objectMetadataItem.nameSingular !==
- CoreObjectNameSingular.WorkspaceMember,
- );
-
- store.set(
- multipleRecordPickerPickableMorphItemsComponentState.atomFamily({
- instanceId: recordPickerInstanceId,
- }),
- activityTargetObjectRecords.map((activityTargetObjectRecord) => ({
- recordId: activityTargetObjectRecord.targetObject.id,
- objectMetadataId:
- activityTargetObjectRecord.targetObjectMetadataItem.id,
- isSelected: true,
- isMatchingSearchFilter: true,
- })),
- );
-
- store.set(
- multipleRecordPickerSearchableObjectMetadataItemsComponentState.atomFamily(
- {
- instanceId: recordPickerInstanceId,
- },
- ),
- objectMetadataItems,
- );
-
- store.set(
- multipleRecordPickerSearchFilterComponentState.atomFamily({
- instanceId: recordPickerInstanceId,
- }),
- '',
- );
-
- openMultipleRecordPicker(recordPickerInstanceId);
-
- multipleRecordPickerPerformSearch({
- multipleRecordPickerInstanceId: recordPickerInstanceId,
- forceSearchFilter: '',
- forceSearchableObjectMetadataItems: objectMetadataItems,
- forcePickableMorphItems: activityTargetObjectRecords.map(
- (activityTargetObjectRecord) => ({
- recordId: activityTargetObjectRecord.targetObject.id,
- objectMetadataId:
- activityTargetObjectRecord.targetObjectMetadataItem.id,
- isSelected: true,
- isMatchingSearchFilter: true,
- }),
- ),
- });
-
- pushFocusItemToFocusStack({
- focusId: recordPickerInstanceId,
- component: {
- type: FocusComponentType.DROPDOWN,
- instanceId: recordPickerInstanceId,
- },
- globalHotkeysConfig: {
- enableGlobalHotkeysConflictingWithKeyboard: false,
- },
- });
- },
- [
- multipleRecordPickerPerformSearch,
- openMultipleRecordPicker,
- pushFocusItemToFocusStack,
- store,
- ],
- );
-
- return { openActivityTargetCellEditMode };
-};
diff --git a/packages/twenty-front/src/modules/activities/inline-cell/hooks/useUpdateActivityTargetFromCell.ts b/packages/twenty-front/src/modules/activities/inline-cell/hooks/useUpdateActivityTargetFromCell.ts
deleted file mode 100644
index 08c9abc5547..00000000000
--- a/packages/twenty-front/src/modules/activities/inline-cell/hooks/useUpdateActivityTargetFromCell.ts
+++ /dev/null
@@ -1,205 +0,0 @@
-import { type ActivityTargetWithTargetRecord } from '@/activities/types/ActivityTargetObject';
-import { type NoteTarget } from '@/activities/types/NoteTarget';
-import { type TaskTarget } from '@/activities/types/TaskTarget';
-import { getActivityTargetFieldNameForObject } from '@/activities/utils/getActivityTargetFieldNameForObject';
-import { getJoinObjectNameSingular } from '@/activities/utils/getJoinObjectNameSingular';
-import { objectMetadataItemsSelector } from '@/object-metadata/states/objectMetadataItemsSelector';
-import { CoreObjectNameSingular } from 'twenty-shared/types';
-import { useCreateOneRecord } from '@/object-record/hooks/useCreateOneRecord';
-import { useDeleteOneRecord } from '@/object-record/hooks/useDeleteOneRecord';
-import { searchRecordStoreFamilyState } from '@/object-record/record-picker/multiple-record-picker/states/searchRecordStoreComponentFamilyState';
-import { type RecordPickerPickableMorphItem } from '@/object-record/record-picker/types/RecordPickerPickableMorphItem';
-import { recordStoreFamilyState } from '@/object-record/record-store/states/recordStoreFamilyState';
-import { useSetAtomFamilyState } from '@/ui/utilities/state/jotai/hooks/useSetAtomFamilyState';
-import { useCallback } from 'react';
-import { useStore } from 'jotai';
-import { isDefined } from 'twenty-shared/utils';
-import { v4 } from 'uuid';
-
-type UpdateActivityTargetFromCellProps = {
- recordPickerInstanceId: string;
- morphItem: RecordPickerPickableMorphItem;
- activityTargetWithTargetRecords: ActivityTargetWithTargetRecord[];
-};
-
-// TODO: deprecate this hook once we implement one-to-many relation through
-export const useUpdateActivityTargetFromCell = ({
- activityObjectNameSingular,
- activityId,
-}: {
- activityObjectNameSingular:
- | CoreObjectNameSingular.Note
- | CoreObjectNameSingular.Task;
- activityId: string;
-}) => {
- const joinObjectNameSingular = getJoinObjectNameSingular(
- activityObjectNameSingular,
- );
-
- const { createOneRecord: createOneActivityTarget } = useCreateOneRecord<
- NoteTarget | TaskTarget
- >({
- objectNameSingular:
- joinObjectNameSingular === ''
- ? activityObjectNameSingular
- : joinObjectNameSingular,
- shouldMatchRootQueryFilter: true,
- });
-
- const { deleteOneRecord: deleteOneActivityTarget } = useDeleteOneRecord({
- objectNameSingular:
- joinObjectNameSingular === ''
- ? activityObjectNameSingular
- : joinObjectNameSingular,
- });
- const store = useStore();
- const setRecordStore = useSetAtomFamilyState(
- recordStoreFamilyState,
- activityId,
- );
-
- const updateActivityTargetFromCell = useCallback(
- async ({
- morphItem,
- activityTargetWithTargetRecords,
- }: UpdateActivityTargetFromCellProps) => {
- const targetObjectName =
- activityObjectNameSingular === CoreObjectNameSingular.Task
- ? 'task'
- : 'note';
-
- const objectMetadataItems = store.get(objectMetadataItemsSelector.atom);
-
- const pickedObjectMetadataItem = objectMetadataItems.find(
- (objectMetadataItem) =>
- objectMetadataItem.id === morphItem.objectMetadataId,
- );
-
- if (!isDefined(pickedObjectMetadataItem)) {
- throw new Error('Could not find object metadata item');
- }
-
- const targetFieldName = getActivityTargetFieldNameForObject({
- activityObjectNameSingular,
- targetObjectMetadataId: morphItem.objectMetadataId,
- objectMetadataItems,
- });
-
- if (!isDefined(targetFieldName)) {
- throw new Error(
- `Could not find field on activity target for object ${pickedObjectMetadataItem.nameSingular}`,
- );
- }
-
- let activityTargetsAfterUpdate: (TaskTarget | NoteTarget)[] = [];
-
- const existingActivityTarget = activityTargetWithTargetRecords.find(
- (activityTarget) =>
- activityTarget.targetObject.id === morphItem.recordId,
- );
-
- if (isDefined(existingActivityTarget)) {
- activityTargetsAfterUpdate = activityTargetWithTargetRecords.flatMap(
- (activityTarget) => {
- if (
- activityTarget.targetObject.id === morphItem.recordId &&
- !morphItem.isSelected
- ) {
- return [];
- }
-
- return [activityTarget.activityTarget];
- },
- );
-
- if (!morphItem.isSelected) {
- await deleteOneActivityTarget(
- existingActivityTarget.activityTarget.id,
- );
- }
- } else {
- const searchRecord = store.get(
- searchRecordStoreFamilyState.atomFamily(morphItem.recordId),
- );
-
- if (!isDefined(searchRecord) || !isDefined(searchRecord?.record)) {
- return;
- }
-
- if (!morphItem.isSelected) {
- return;
- }
-
- const targetRecord = searchRecord.record;
-
- const activityTarget: NoteTarget | TaskTarget =
- activityObjectNameSingular === CoreObjectNameSingular.Task
- ? {
- id: v4(),
- createdAt: new Date().toISOString(),
- updatedAt: new Date().toISOString(),
- __typename: 'TaskTarget',
- taskId: activityId,
- task: {
- id: activityId,
- __typename: 'Task',
- createdAt: new Date().toISOString(),
- updatedAt: new Date().toISOString(),
- },
- [targetFieldName]: targetRecord,
- }
- : {
- id: v4(),
- createdAt: new Date().toISOString(),
- updatedAt: new Date().toISOString(),
- __typename: 'NoteTarget',
- noteId: activityId,
- note: {
- id: activityId,
- __typename: 'Note',
- createdAt: new Date().toISOString(),
- updatedAt: new Date().toISOString(),
- },
- [targetFieldName]: targetRecord,
- };
-
- activityTargetsAfterUpdate = [
- ...activityTargetWithTargetRecords.map((activityTarget) => {
- return activityTarget.activityTarget;
- }),
- activityTarget,
- ];
-
- const activityTargetInput: Partial<NoteTarget | TaskTarget> = {
- ...activityTarget,
- [targetObjectName]: undefined,
- [targetFieldName]: undefined,
- [`${targetFieldName}Id`]: morphItem.recordId,
- };
-
- await createOneActivityTarget(activityTargetInput);
- }
-
- setRecordStore((currentActivity) => {
- if (!isDefined(currentActivity)) {
- return null;
- }
-
- return {
- ...currentActivity,
- [`${targetObjectName}Targets`]: activityTargetsAfterUpdate,
- };
- });
- },
- [
- store,
- activityId,
- activityObjectNameSingular,
- createOneActivityTarget,
- deleteOneActivityTarget,
- setRecordStore,
- ],
- );
-
- return { updateActivityTargetFromCell };
-};
diff --git a/packages/twenty-front/src/modules/activities/notes/components/NoteTile.tsx b/packages/twenty-front/src/modules/activities/notes/components/NoteTile.tsx
index 60663bd9b47..988274089fc 100644
--- a/packages/twenty-front/src/modules/activities/notes/components/NoteTile.tsx
+++ b/packages/twenty-front/src/modules/activities/notes/components/NoteTile.tsx
@@ -1,14 +1,17 @@
import { styled } from '@linaria/react';
import { t } from '@lingui/core/macro';
-import { ActivityTargetsInlineCell } from '@/activities/inline-cell/components/ActivityTargetsInlineCell';
-import { useActivityTargetsComponentInstanceId } from '@/activities/inline-cell/hooks/useActivityTargetsComponentInstanceId';
+import { useActivityFieldComponentInstanceId } from '@/activities/hooks/useActivityFieldComponentInstanceId';
import { type Note } from '@/activities/types/Note';
import { getActivityPreview } from '@/activities/utils/getActivityPreview';
+import { useObjectMorphJunctionConfigOrThrow } from '@/object-record/record-field/ui/hooks/useObjectMorphJunctionConfigOrThrow';
import { useOpenRecordInSidePanel } from '@/side-panel/hooks/useOpenRecordInSidePanel';
import { CoreObjectNameSingular } from 'twenty-shared/types';
import { RecordFieldsScopeContextProvider } from '@/object-record/record-field-list/contexts/RecordFieldsScopeContext';
import { FieldContextProvider } from '@/object-record/record-field/ui/components/FieldContextProvider';
+import { RecordFieldComponentInstanceContext } from '@/object-record/record-field/ui/states/contexts/RecordFieldComponentInstanceContext';
+import { RecordInlineCell } from '@/object-record/record-inline-cell/components/RecordInlineCell';
+import { getRecordFieldInputInstanceId } from '@/object-record/utils/getRecordFieldInputId';
import { themeCssVariables } from 'twenty-ui/theme-constants';
const StyledCard = styled.div<{ isSingleNote: boolean }>`
@@ -76,10 +79,17 @@ export const NoteTile = ({
const body = getActivityPreview(note?.bodyV2?.blocknote ?? null);
- const baseComponentInstanceId = `note-card-${note.id}-targets`;
- const componentInstanceId = useActivityTargetsComponentInstanceId(
- baseComponentInstanceId,
- );
+ const junctionFieldName = useObjectMorphJunctionConfigOrThrow({
+ objectNameSingular: CoreObjectNameSingular.Note,
+ }).junctionField.name;
+
+ const instanceIdPrefix =
+ useActivityFieldComponentInstanceId('note-card-targets');
+ const componentInstanceId = getRecordFieldInputInstanceId({
+ recordId: note.id,
+ fieldName: junctionFieldName,
+ prefix: instanceIdPrefix,
+ });
return (
<StyledCard isSingleNote={isSingleNote}>
@@ -98,19 +108,20 @@ export const NoteTile = ({
<FieldContextProvider
objectNameSingular={CoreObjectNameSingular.Note}
objectRecordId={note.id}
- fieldMetadataName="noteTargets"
+ fieldMetadataName={junctionFieldName}
fieldPosition={0}
+ isDisplayModeFixHeight
>
<RecordFieldsScopeContextProvider
value={{
scopeInstanceId: note.id,
}}
>
- <ActivityTargetsInlineCell
- componentInstanceId={componentInstanceId}
- activityRecordId={note.id}
- activityObjectNameSingular={CoreObjectNameSingular.Note}
- />
+ <RecordFieldComponentInstanceContext.Provider
+ value={{ instanceId: componentInstanceId }}
+ >
+ <RecordInlineCell instanceIdPrefix={instanceIdPrefix} />
+ </RecordFieldComponentInstanceContext.Provider>
</RecordFieldsScopeContextProvider>
</FieldContextProvider>
</StyledFooter>
diff --git a/packages/twenty-front/src/modules/activities/notes/hooks/__tests__/useNotes.test.ts b/packages/twenty-front/src/modules/activities/notes/hooks/__tests__/useNotes.test.ts
index 3975a519be5..2c480fa1ef3 100644
--- a/packages/twenty-front/src/modules/activities/notes/hooks/__tests__/useNotes.test.ts
+++ b/packages/twenty-front/src/modules/activities/notes/hooks/__tests__/useNotes.test.ts
@@ -5,8 +5,9 @@ import { type ActivityTargetableObject } from '@/activities/types/ActivityTarget
jest.mock('@/activities/hooks/useActivities', () => ({
useActivities: jest.fn(() => ({
- activities: [{ id: '1', content: 'Example Note' }],
+ activities: [{ id: '1', content: 'Example Note', __typename: 'Note' }],
loading: false,
+ fetchMoreActivities: jest.fn(),
})),
}));
@@ -29,7 +30,7 @@ describe('useNotes', () => {
const { result } = renderHook(() => useNotes(mockTargetableObject));
expect(result.current.notes).toEqual([
- { id: '1', content: 'Example Note' },
+ { id: '1', content: 'Example Note', __typename: 'Note' },
]);
expect(result.current.loading).toBe(false);
});
diff --git a/packages/twenty-front/src/modules/activities/notes/hooks/useNotes.ts b/packages/twenty-front/src/modules/activities/notes/hooks/useNotes.ts
index b2b95facf23..0c9b1b1745b 100644
--- a/packages/twenty-front/src/modules/activities/notes/hooks/useNotes.ts
+++ b/packages/twenty-front/src/modules/activities/notes/hooks/useNotes.ts
@@ -28,13 +28,22 @@ export const useNotes = (targetableObject: ActivityTargetableObject) => {
totalCountActivities,
fetchMoreActivities,
hasNextPage,
- } = useActivities<Note>({
+ } = useActivities({
objectNameSingular: CoreObjectNameSingular.Note,
activityTargetsOrderByVariables: notesQueryVariables.orderBy ?? [{}],
targetableObjects: [targetableObject],
limit: 10,
});
+ const notes = activities.filter(
+ (activity): activity is Note => activity.__typename === 'Note',
+ );
+
+ const fetchMoreNotes = async () =>
+ (await fetchMoreActivities()).filter(
+ (activity): activity is Note => activity.__typename === 'Note',
+ );
+
const [currentNotesQueryVariables, setCurrentNotesQueryVariables] =
useAtomState(currentNotesQueryVariablesState);
@@ -50,10 +59,10 @@ export const useNotes = (targetableObject: ActivityTargetableObject) => {
]);
return {
- notes: activities as Note[],
+ notes,
loading,
totalCountNotes: totalCountActivities,
- fetchMoreNotes: fetchMoreActivities,
+ fetchMoreNotes,
hasNextPage,
};
};
diff --git a/packages/twenty-front/src/modules/activities/tasks/components/TaskRow.tsx b/packages/twenty-front/src/modules/activities/tasks/components/TaskRow.tsx
index 2439af787e1..05e5d11e34f 100644
--- a/packages/twenty-front/src/modules/activities/tasks/components/TaskRow.tsx
+++ b/packages/twenty-front/src/modules/activities/tasks/components/TaskRow.tsx
@@ -1,18 +1,21 @@
import { styled } from '@linaria/react';
import { t } from '@lingui/core/macro';
-import { ActivityTargetsInlineCell } from '@/activities/inline-cell/components/ActivityTargetsInlineCell';
import { getActivitySummary } from '@/activities/utils/getActivitySummary';
import { beautifyExactDate, hasDatePassed } from '~/utils/date-utils';
import { ActivityRow } from '@/activities/components/ActivityRow';
-import { useActivityTargetsComponentInstanceId } from '@/activities/inline-cell/hooks/useActivityTargetsComponentInstanceId';
+import { useActivityFieldComponentInstanceId } from '@/activities/hooks/useActivityFieldComponentInstanceId';
import { type Task } from '@/activities/types/Task';
+import { useObjectMorphJunctionConfigOrThrow } from '@/object-record/record-field/ui/hooks/useObjectMorphJunctionConfigOrThrow';
import { useOpenRecordInSidePanel } from '@/side-panel/hooks/useOpenRecordInSidePanel';
import { CoreObjectNameSingular } from 'twenty-shared/types';
import { StopPropagationContainer } from '@/object-record/record-board/record-board-card/components/StopPropagationContainer';
import { RecordFieldsScopeContextProvider } from '@/object-record/record-field-list/contexts/RecordFieldsScopeContext';
import { FieldContextProvider } from '@/object-record/record-field/ui/components/FieldContextProvider';
+import { RecordFieldComponentInstanceContext } from '@/object-record/record-field/ui/states/contexts/RecordFieldComponentInstanceContext';
+import { RecordInlineCell } from '@/object-record/record-inline-cell/components/RecordInlineCell';
+import { getRecordFieldInputInstanceId } from '@/object-record/utils/getRecordFieldInputId';
import { useContext } from 'react';
import { IconCalendar } from 'twenty-ui/icon';
import { OverflowingTextWithTooltip } from 'twenty-ui/surfaces';
@@ -93,10 +96,17 @@ export const TaskRow = ({ task }: { task: Task }) => {
const { completeTask } = useCompleteTask(task);
- const baseComponentInstanceId = `task-row-targets-${task.id}`;
- const componentInstanceId = useActivityTargetsComponentInstanceId(
- baseComponentInstanceId,
- );
+ const junctionFieldName = useObjectMorphJunctionConfigOrThrow({
+ objectNameSingular: CoreObjectNameSingular.Task,
+ }).junctionField.name;
+
+ const instanceIdPrefix =
+ useActivityFieldComponentInstanceId('task-row-targets');
+ const componentInstanceId = getRecordFieldInputInstanceId({
+ recordId: task.id,
+ fieldName: junctionFieldName,
+ prefix: instanceIdPrefix,
+ });
return (
<ActivityRow
@@ -140,8 +150,11 @@ export const TaskRow = ({ task }: { task: Task }) => {
<FieldContextProvider
objectNameSingular={CoreObjectNameSingular.Task}
objectRecordId={task.id}
- fieldMetadataName="taskTargets"
+ fieldMetadataName={junctionFieldName}
fieldPosition={0}
+ showLabel={false}
+ maxWidth={200}
+ isDisplayModeFixHeight
>
<RecordFieldsScopeContextProvider
value={{
@@ -149,13 +162,11 @@ export const TaskRow = ({ task }: { task: Task }) => {
}}
>
<StopPropagationContainer>
- <ActivityTargetsInlineCell
- activityObjectNameSingular={CoreObjectNameSingular.Task}
- activityRecordId={task.id}
- showLabel={false}
- maxWidth={200}
- componentInstanceId={componentInstanceId}
- />
+ <RecordFieldComponentInstanceContext.Provider
+ value={{ instanceId: componentInstanceId }}
+ >
+ <RecordInlineCell instanceIdPrefix={instanceIdPrefix} />
+ </RecordFieldComponentInstanceContext.Provider>
</StopPropagationContainer>
</RecordFieldsScopeContextProvider>
</FieldContextProvider>
diff --git a/packages/twenty-front/src/modules/activities/tasks/hooks/__tests__/useCompleteTask.test.tsx b/packages/twenty-front/src/modules/activities/tasks/hooks/__tests__/useCompleteTask.test.tsx
index 2fa01dce9a9..664c9582c1d 100644
--- a/packages/twenty-front/src/modules/activities/tasks/hooks/__tests__/useCompleteTask.test.tsx
+++ b/packages/twenty-front/src/modules/activities/tasks/hooks/__tests__/useCompleteTask.test.tsx
@@ -21,7 +21,6 @@ const task: Task = {
updatedAt: '2024-03-15T07:33:14.212Z',
assignee: null,
assigneeId: null,
- taskTargets: [],
__typename: 'Task',
};
diff --git a/packages/twenty-front/src/modules/activities/tasks/hooks/__tests__/useTasks.test.tsx b/packages/twenty-front/src/modules/activities/tasks/hooks/__tests__/useTasks.test.tsx
index 3dc65f94f53..06d4c0fec6e 100644
--- a/packages/twenty-front/src/modules/activities/tasks/hooks/__tests__/useTasks.test.tsx
+++ b/packages/twenty-front/src/modules/activities/tasks/hooks/__tests__/useTasks.test.tsx
@@ -9,31 +9,38 @@ const tasks = [
{
id: '1',
status: 'DONE',
+ __typename: 'Task',
},
{
id: '2',
status: 'DONE',
+ __typename: 'Task',
},
{
id: '3',
status: 'DONE',
+ __typename: 'Task',
},
{
id: '4',
+ __typename: 'Task',
},
{
id: '5',
dueAt: '2024-03-15T07:33:14.212Z',
+ __typename: 'Task',
},
{
id: '6',
dueAt: '2024-03-15T07:33:14.212Z',
+ __typename: 'Task',
},
];
const useActivitiesMock = jest.fn(() => {
return {
activities: tasks,
+ fetchMoreActivities: jest.fn(),
};
});
@@ -57,8 +64,6 @@ describe('useTasks', () => {
wrapper: Wrapper,
});
- expect(result.current).toEqual({
- tasks: tasks,
- });
+ expect(result.current.tasks).toEqual(tasks);
});
});
diff --git a/packages/twenty-front/src/modules/activities/tasks/hooks/useTasks.ts b/packages/twenty-front/src/modules/activities/tasks/hooks/useTasks.ts
index a76cac8d468..eeede18a8b0 100644
--- a/packages/twenty-front/src/modules/activities/tasks/hooks/useTasks.ts
+++ b/packages/twenty-front/src/modules/activities/tasks/hooks/useTasks.ts
@@ -15,17 +15,26 @@ export const useTasks = ({ targetableObjects }: UseTasksProps) => {
fetchMoreActivities: fetchMoreTasks,
hasNextPage,
totalCountActivities,
- } = useActivities<Task>({
+ } = useActivities({
objectNameSingular: CoreObjectNameSingular.Task,
targetableObjects,
activityTargetsOrderByVariables: FIND_MANY_TIMELINE_ACTIVITIES_ORDER_BY,
limit: 200,
});
+ const filteredTasks = tasks.filter(
+ (activity): activity is Task => activity.__typename === 'Task',
+ );
+
+ const fetchMoreFilteredTasks = async () =>
+ (await fetchMoreTasks()).filter(
+ (activity): activity is Task => activity.__typename === 'Task',
+ );
+
return {
- tasks: (tasks ?? []) as Task[],
+ tasks: filteredTasks,
tasksLoading,
- fetchMoreTasks,
+ fetchMoreTasks: fetchMoreFilteredTasks,
hasNextPage,
totalCountTasks: totalCountActivities,
};
diff --git a/packages/twenty-front/src/modules/activities/types/ActivityForEditor.ts b/packages/twenty-front/src/modules/activities/types/ActivityForEditor.ts
index 16e4f9dd7df..505e47fdb6f 100644
--- a/packages/twenty-front/src/modules/activities/types/ActivityForEditor.ts
+++ b/packages/twenty-front/src/modules/activities/types/ActivityForEditor.ts
@@ -1,6 +1,4 @@
import { type Note } from '@/activities/types/Note';
import { type Task } from '@/activities/types/Task';
-export type ActivityForEditor = Partial<Task | Note> &
- Partial<Pick<Task, 'status' | 'dueAt' | 'assignee' | 'taskTargets'>> &
- Partial<Pick<Note, 'noteTargets'>>;
+export type ActivityForEditor = Partial<Task | Note>;
diff --git a/packages/twenty-front/src/modules/activities/types/ActivityTarget.ts b/packages/twenty-front/src/modules/activities/types/ActivityTarget.ts
new file mode 100644
index 00000000000..5fd6b2337fe
--- /dev/null
+++ b/packages/twenty-front/src/modules/activities/types/ActivityTarget.ts
@@ -0,0 +1,3 @@
+import { type BaseObjectRecord } from '@/object-record/types/BaseObjectRecord';
+
+export type ActivityTarget = BaseObjectRecord;
diff --git a/packages/twenty-front/src/modules/activities/types/ActivityTargetObject.ts b/packages/twenty-front/src/modules/activities/types/ActivityTargetObject.ts
deleted file mode 100644
index f047fddade2..00000000000
--- a/packages/twenty-front/src/modules/activities/types/ActivityTargetObject.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import { type NoteTarget } from '@/activities/types/NoteTarget';
-import { type TaskTarget } from '@/activities/types/TaskTarget';
-import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
-import { type ObjectRecord } from '@/object-record/types/ObjectRecord';
-
-export type ActivityTargetWithTargetRecord = {
- targetObjectMetadataItem: EnrichedObjectMetadataItem;
- activityTarget: NoteTarget | TaskTarget;
- targetObject: ObjectRecord;
-};
diff --git a/packages/twenty-front/src/modules/activities/types/Note.ts b/packages/twenty-front/src/modules/activities/types/Note.ts
index ced7c344451..40869ce1c82 100644
--- a/packages/twenty-front/src/modules/activities/types/Note.ts
+++ b/packages/twenty-front/src/modules/activities/types/Note.ts
@@ -1,7 +1,5 @@
import { type Activity } from '@/activities/types/Activity';
-import { type NoteTarget } from '@/activities/types/NoteTarget';
export type Note = Activity & {
- noteTargets?: NoteTarget[];
__typename: 'Note';
};
diff --git a/packages/twenty-front/src/modules/activities/types/NoteTarget.ts b/packages/twenty-front/src/modules/activities/types/NoteTarget.ts
deleted file mode 100644
index ad1f6458ff1..00000000000
--- a/packages/twenty-front/src/modules/activities/types/NoteTarget.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-import { type Note } from '@/activities/types/Note';
-import { type Company } from '@/companies/types/Company';
-import { type Person } from '@/people/types/Person';
-
-export type NoteTarget = {
- id: string;
- createdAt: string;
- updatedAt: string;
- deletedAt?: string | null;
- companyId?: string | null;
- personId?: string | null;
- opportunityId?: string | null;
- targetCompanyId?: string | null;
- targetPersonId?: string | null;
- targetOpportunityId?: string | null;
- note: Pick<Note, 'id' | 'createdAt' | 'updatedAt' | '__typename'>;
- person?: Pick<Person, 'id' | 'name' | 'avatarUrl' | '__typename'> | null;
- company?: Pick<Company, 'id' | 'name' | 'domainName' | '__typename'> | null;
- [key: string]: any;
- __typename: 'NoteTarget';
-};
diff --git a/packages/twenty-front/src/modules/activities/types/Task.ts b/packages/twenty-front/src/modules/activities/types/Task.ts
index e3a321f8d1a..d959732fb81 100644
--- a/packages/twenty-front/src/modules/activities/types/Task.ts
+++ b/packages/twenty-front/src/modules/activities/types/Task.ts
@@ -1,5 +1,4 @@
import { type Activity } from '@/activities/types/Activity';
-import { type TaskTarget } from '@/activities/types/TaskTarget';
import { type WorkspaceMember } from '@/workspace-member/types/WorkspaceMember';
type ActivityStatus = 'TODO' | 'IN_PROGRESS' | 'DONE';
@@ -12,6 +11,5 @@ export type Task = Activity & {
assigneeId: string | null;
status: ActivityStatus | null;
dueAt: string | null;
- taskTargets: TaskTarget[];
__typename: 'Task';
};
diff --git a/packages/twenty-front/src/modules/activities/types/TaskTarget.ts b/packages/twenty-front/src/modules/activities/types/TaskTarget.ts
deleted file mode 100644
index 23ae0fc1cfb..00000000000
--- a/packages/twenty-front/src/modules/activities/types/TaskTarget.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import { type Task } from '@/activities/types/Task';
-import { type Company } from '@/companies/types/Company';
-import { type Person } from '@/people/types/Person';
-import { type WorkspaceMember } from '~/generated-metadata/graphql';
-
-export type TaskTarget = {
- id: string;
- createdAt: string;
- updatedAt: string;
- deletedAt?: string | null;
- companyId?: string | null;
- personId?: string | null;
- opportunityId?: string | null;
- targetCompanyId?: string | null;
- targetPersonId?: string | null;
- targetOpportunityId?: string | null;
- taskId: string | null;
- task: Pick<Task, 'id' | 'createdAt' | 'updatedAt' | '__typename'>;
- person?: Pick<Person, 'id' | 'name' | 'avatarUrl' | '__typename'> | null;
- company?: Pick<Company, 'id' | 'name' | 'domainName' | '__typename'> | null;
- assignee?: Partial<WorkspaceMember>;
- [key: string]: any;
- __typename: 'TaskTarget';
-};
diff --git a/packages/twenty-front/src/modules/activities/utils/__tests__/getActivityTargetsFilter.test.ts b/packages/twenty-front/src/modules/activities/utils/__tests__/getActivityTargetsFilter.test.ts
new file mode 100644
index 00000000000..d8d70197079
--- /dev/null
+++ b/packages/twenty-front/src/modules/activities/utils/__tests__/getActivityTargetsFilter.test.ts
@@ -0,0 +1,29 @@
+import { getActivityTargetsFilter } from '@/activities/utils/getActivityTargetsFilter';
+
+import { getMockObjectMetadataItemOrThrow } from '~/testing/utils/getMockObjectMetadataItemOrThrow';
+import { getTestEnrichedObjectMetadataItemsMock } from '~/testing/utils/getTestEnrichedObjectMetadataItemsMock';
+
+describe('getActivityTargetsFilter', () => {
+ it('preserves every target when several targets have the same type', () => {
+ const objectMetadataItems = getTestEnrichedObjectMetadataItemsMock();
+
+ const filter = getActivityTargetsFilter({
+ targetableObjects: [
+ { id: 'person-1', targetObjectNameSingular: 'person' },
+ { id: 'person-2', targetObjectNameSingular: 'person' },
+ { id: 'company-1', targetObjectNameSingular: 'company' },
+ ],
+ activityTargetObjectMetadata:
+ getMockObjectMetadataItemOrThrow('taskTarget'),
+ objectMetadataItems,
+ });
+
+ expect(filter).toEqual({
+ or: [
+ { targetPersonId: { eq: 'person-1' } },
+ { targetPersonId: { eq: 'person-2' } },
+ { targetCompanyId: { eq: 'company-1' } },
+ ],
+ });
+ });
+});
diff --git a/packages/twenty-front/src/modules/activities/utils/generateActivityTargetMorphFieldKeys.ts b/packages/twenty-front/src/modules/activities/utils/generateActivityTargetMorphFieldKeys.ts
deleted file mode 100644
index 03f12a7dc78..00000000000
--- a/packages/twenty-front/src/modules/activities/utils/generateActivityTargetMorphFieldKeys.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import { getActivityTargetObjectFieldIdName } from '@/activities/utils/getActivityTargetObjectFieldIdName';
-import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
-
-export const generateActivityTargetMorphFieldKeys = (
- objectMetadataItems: EnrichedObjectMetadataItem[],
-) => {
- const targetableObjectMetadataItems = objectMetadataItems.filter(
- (objectMetadataItem) =>
- objectMetadataItem.isActive && !objectMetadataItem.isSystem,
- );
-
- const targetableObjects = Object.fromEntries(
- targetableObjectMetadataItems.map((objectMetadataItem) => {
- const targetFieldIdName = getActivityTargetObjectFieldIdName({
- nameSingular: objectMetadataItem.nameSingular,
- });
-
- return [targetFieldIdName.replace(/Id$/, ''), true];
- }),
- );
-
- const targetableObjectIds = Object.fromEntries(
- targetableObjectMetadataItems.map((objectMetadataItem) => {
- const targetFieldIdName = getActivityTargetObjectFieldIdName({
- nameSingular: objectMetadataItem.nameSingular,
- });
-
- return [targetFieldIdName, true];
- }),
- );
-
- return {
- ...targetableObjects,
- ...targetableObjectIds,
- };
-};
diff --git a/packages/twenty-front/src/modules/activities/utils/getActivityTargetFieldNameForObject.ts b/packages/twenty-front/src/modules/activities/utils/getActivityTargetFieldNameForObject.ts
deleted file mode 100644
index 31329e2eeb3..00000000000
--- a/packages/twenty-front/src/modules/activities/utils/getActivityTargetFieldNameForObject.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-import { getActivityTargetObjectFieldIdName } from '@/activities/utils/getActivityTargetObjectFieldIdName';
-import { CoreObjectNameSingular } from 'twenty-shared/types';
-import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
-import { isDefined } from 'twenty-shared/utils';
-
-type GetActivityTargetFieldNameForObjectArgs = {
- activityObjectNameSingular:
- | CoreObjectNameSingular.Note
- | CoreObjectNameSingular.Task;
- targetObjectMetadataId: string;
- objectMetadataItems: EnrichedObjectMetadataItem[];
-};
-
-export const getActivityTargetFieldNameForObject = ({
- activityObjectNameSingular,
- targetObjectMetadataId,
- objectMetadataItems,
-}: GetActivityTargetFieldNameForObjectArgs): string | undefined => {
- const activityTargetObjectNameSingular =
- activityObjectNameSingular === CoreObjectNameSingular.Task
- ? CoreObjectNameSingular.TaskTarget
- : CoreObjectNameSingular.NoteTarget;
-
- const activityTargetObjectMetadata = objectMetadataItems.find(
- (objectMetadataItem) =>
- objectMetadataItem.nameSingular === activityTargetObjectNameSingular,
- );
-
- if (!isDefined(activityTargetObjectMetadata)) {
- return undefined;
- }
-
- const targetObjectMetadataItem = objectMetadataItems.find(
- (objectMetadataItem) => objectMetadataItem.id === targetObjectMetadataId,
- );
-
- if (!isDefined(targetObjectMetadataItem)) {
- return undefined;
- }
-
- const fieldIdName = getActivityTargetObjectFieldIdName({
- nameSingular: targetObjectMetadataItem.nameSingular,
- });
-
- return fieldIdName.replace(/Id$/, '');
-};
diff --git a/packages/twenty-front/src/modules/activities/utils/getActivityTargetObjectRecords.ts b/packages/twenty-front/src/modules/activities/utils/getActivityTargetObjectRecords.ts
deleted file mode 100644
index 53a92178d18..00000000000
--- a/packages/twenty-front/src/modules/activities/utils/getActivityTargetObjectRecords.ts
+++ /dev/null
@@ -1,164 +0,0 @@
-import { type ActivityTargetWithTargetRecord } from '@/activities/types/ActivityTargetObject';
-import { type Note } from '@/activities/types/Note';
-import { type NoteTarget } from '@/activities/types/NoteTarget';
-import { type Task } from '@/activities/types/Task';
-import { type TaskTarget } from '@/activities/types/TaskTarget';
-import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
-import { type ObjectRecord } from '@/object-record/types/ObjectRecord';
-import {
- CoreObjectNameSingular,
- FieldMetadataType,
- type Nullable,
-} from 'twenty-shared/types';
-import {
- computeMorphRelationGqlFieldName,
- isDefined,
-} from 'twenty-shared/utils';
-
-type GetActivityTargetObjectRecordsProps = {
- activityRecord: Note | Task;
- objectMetadataItems: EnrichedObjectMetadataItem[];
- activityTargets?: Nullable<NoteTarget[] | TaskTarget[]>;
-};
-
-export const getActivityTargetObjectRecords = ({
- activityRecord,
- objectMetadataItems,
- activityTargets,
-}: GetActivityTargetObjectRecordsProps) => {
- if (!isDefined(activityRecord) && !isDefined(activityTargets)) {
- return [];
- }
-
- const isNote = isDefined(activityRecord) && 'noteTargets' in activityRecord;
-
- const targets = activityTargets
- ? activityTargets
- : 'noteTargets' in activityRecord && isDefined(activityRecord.noteTargets)
- ? activityRecord.noteTargets
- : 'taskTargets' in activityRecord && isDefined(activityRecord.taskTargets)
- ? activityRecord.taskTargets
- : [];
-
- const activityTargetObjectNameSingular = isNote
- ? CoreObjectNameSingular.NoteTarget
- : CoreObjectNameSingular.TaskTarget;
-
- const activityTargetObjectMetadata = objectMetadataItems.find(
- (item) => item.nameSingular === activityTargetObjectNameSingular,
- );
-
- const activityTargetRelationFields =
- activityTargetObjectMetadata?.fields.filter((field) => {
- if (
- field.type === FieldMetadataType.MORPH_RELATION &&
- isDefined(field.morphRelations) &&
- field.morphRelations.length > 0
- ) {
- return true;
- }
-
- const targetObjectNameSingular =
- field.relation?.targetObjectMetadata.nameSingular;
-
- if (!isDefined(field.relation?.targetObjectMetadata.id)) {
- return false;
- }
-
- if (!isDefined(targetObjectNameSingular)) {
- return false;
- }
-
- return (
- targetObjectNameSingular !== CoreObjectNameSingular.Note &&
- targetObjectNameSingular !== CoreObjectNameSingular.Task
- );
- }) ?? [];
-
- const activityTargetObjectRecords = targets
- .map<ActivityTargetWithTargetRecord | undefined>((activityTarget) => {
- if (!isDefined(activityTarget)) {
- throw new Error('Cannot find activity target');
- }
-
- if (isDefined(activityTarget.deletedAt)) {
- return undefined;
- }
-
- let matchingFieldName: string | undefined;
- let correspondingObjectMetadataItem:
- | EnrichedObjectMetadataItem
- | undefined;
-
- for (const field of activityTargetRelationFields) {
- if (
- field.type === FieldMetadataType.MORPH_RELATION &&
- isDefined(field.morphRelations)
- ) {
- const matchingMorphRelation = field.morphRelations.find(
- (morphRelation) => {
- const morphFieldName = computeMorphRelationGqlFieldName({
- fieldName: field.name,
- relationType: morphRelation.type,
- targetObjectMetadataNameSingular:
- morphRelation.targetObjectMetadata.nameSingular,
- targetObjectMetadataNamePlural:
- morphRelation.targetObjectMetadata.namePlural,
- });
-
- return isDefined(activityTarget[morphFieldName]);
- },
- );
-
- if (isDefined(matchingMorphRelation)) {
- matchingFieldName = computeMorphRelationGqlFieldName({
- fieldName: field.name,
- relationType: matchingMorphRelation.type,
- targetObjectMetadataNameSingular:
- matchingMorphRelation.targetObjectMetadata.nameSingular,
- targetObjectMetadataNamePlural:
- matchingMorphRelation.targetObjectMetadata.namePlural,
- });
- correspondingObjectMetadataItem = objectMetadataItems.find(
- (objectMetadataItem) =>
- objectMetadataItem.id ===
- matchingMorphRelation.targetObjectMetadata.id,
- );
- break;
- }
- } else if (isDefined(activityTarget[field.name])) {
- matchingFieldName = field.name;
- correspondingObjectMetadataItem = objectMetadataItems.find(
- (objectMetadataItem) =>
- objectMetadataItem.id === field.relation?.targetObjectMetadata.id,
- );
- break;
- }
- }
-
- if (
- !isDefined(matchingFieldName) ||
- !isDefined(correspondingObjectMetadataItem)
- ) {
- return undefined;
- }
-
- const targetObjectRecord: ObjectRecord | undefined =
- activityTarget[matchingFieldName];
-
- if (!isDefined(targetObjectRecord)) {
- throw new Error(
- `Cannot find target object record of type ${correspondingObjectMetadataItem.nameSingular}, make sure the request for activities eagerly loads for the target objects on activity target relation.`,
- );
- }
-
- return {
- activityTarget,
- targetObject: targetObjectRecord,
- targetObjectMetadataItem: correspondingObjectMetadataItem,
- };
- })
- .filter(isDefined);
-
- return activityTargetObjectRecords;
-};
diff --git a/packages/twenty-front/src/modules/activities/utils/getActivityTargetsFilter.ts b/packages/twenty-front/src/modules/activities/utils/getActivityTargetsFilter.ts
index 62e4e8dd3fd..4f1af658bef 100644
--- a/packages/twenty-front/src/modules/activities/utils/getActivityTargetsFilter.ts
+++ b/packages/twenty-front/src/modules/activities/utils/getActivityTargetsFilter.ts
@@ -1,31 +1,39 @@
import { type ActivityTargetableObject } from '@/activities/types/ActivityTargetableEntity';
-import { getActivityTargetObjectFieldIdName } from '@/activities/utils/getActivityTargetObjectFieldIdName';
+import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
+import { findTargetFieldInfo } from '@/object-record/record-field/ui/utils/junction/findTargetFieldInfo';
import { isDefined } from 'twenty-shared/utils';
export const getActivityTargetsFilter = ({
targetableObjects,
+ activityTargetObjectMetadata,
+ objectMetadataItems,
}: {
targetableObjects: Pick<
ActivityTargetableObject,
'id' | 'targetObjectNameSingular'
>[];
+ activityTargetObjectMetadata: EnrichedObjectMetadataItem;
+ objectMetadataItems: EnrichedObjectMetadataItem[];
}) => {
- const findManyActivityTargetsQueryFilter = Object.fromEntries(
- targetableObjects
- .map((targetableObject) => {
- const joinColumnName = getActivityTargetObjectFieldIdName({
- nameSingular: targetableObject.targetObjectNameSingular,
- });
+ const targetFilters = targetableObjects
+ .map((targetableObject) => {
+ const targetObjectMetadata = objectMetadataItems.find(
+ (objectMetadataItem) =>
+ objectMetadataItem.nameSingular ===
+ targetableObject.targetObjectNameSingular,
+ );
- return [
- joinColumnName,
- {
- eq: targetableObject.id,
- },
- ];
- })
- .filter(isDefined),
- );
+ const joinColumnName = findTargetFieldInfo(
+ activityTargetObjectMetadata.fields,
+ targetObjectMetadata?.id ?? '',
+ objectMetadataItems,
+ )?.joinColumnName;
- return findManyActivityTargetsQueryFilter;
+ return isDefined(joinColumnName)
+ ? { [joinColumnName]: { eq: targetableObject.id } }
+ : undefined;
+ })
+ .filter(isDefined);
+
+ return { or: targetFilters };
};
diff --git a/packages/twenty-front/src/modules/activities/utils/getJoinObjectNameSingular.ts b/packages/twenty-front/src/modules/activities/utils/getJoinObjectNameSingular.ts
deleted file mode 100644
index 324e8357909..00000000000
--- a/packages/twenty-front/src/modules/activities/utils/getJoinObjectNameSingular.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-import { CoreObjectNameSingular } from 'twenty-shared/types';
-
-export const getJoinObjectNameSingular = (
- objectNameSingular: CoreObjectNameSingular,
-) => {
- return objectNameSingular === CoreObjectNameSingular.Note
- ? CoreObjectNameSingular.NoteTarget
- : objectNameSingular === CoreObjectNameSingular.Task
- ? CoreObjectNameSingular.TaskTarget
- : '';
-};
diff --git a/packages/twenty-front/src/modules/apollo/optimistic-effect/utils/triggerUpdateRelationsOptimisticEffect.ts b/packages/twenty-front/src/modules/apollo/optimistic-effect/utils/triggerUpdateRelationsOptimisticEffect.ts
index 8325506af3f..d40792c4b2d 100644
--- a/packages/twenty-front/src/modules/apollo/optimistic-effect/utils/triggerUpdateRelationsOptimisticEffect.ts
+++ b/packages/twenty-front/src/modules/apollo/optimistic-effect/utils/triggerUpdateRelationsOptimisticEffect.ts
@@ -1,9 +1,8 @@
import { triggerAttachRelationOptimisticEffect } from '@/apollo/optimistic-effect/utils/triggerAttachRelationOptimisticEffect';
import { triggerDestroyRecordsOptimisticEffect } from '@/apollo/optimistic-effect/utils/triggerDestroyRecordsOptimisticEffect';
import { triggerDetachRelationOptimisticEffect } from '@/apollo/optimistic-effect/utils/triggerDetachRelationOptimisticEffect';
-import { CORE_OBJECT_NAMES_TO_DELETE_ON_TRIGGER_RELATION_DETACH } from '@/apollo/types/coreObjectNamesToDeleteOnRelationDetach';
import {
- type CoreObjectNameSingular,
+ CoreObjectNameSingular,
FieldMetadataType,
RelationType,
type ObjectPermissions,
@@ -16,6 +15,7 @@ import { type RecordGqlConnectionEdgesRequired } from '@/object-record/graphql/t
import { type RecordGqlNode } from '@/object-record/graphql/types/RecordGqlNode';
import { isFieldMorphRelation } from '@/object-record/record-field/ui/types/guards/isFieldMorphRelation';
import { isFieldRelation } from '@/object-record/record-field/ui/types/guards/isFieldRelation';
+import { getJunctionObjectMetadataIds } from '@/object-record/record-field/ui/utils/junction/getJunctionObjectMetadataIds';
import { type ObjectRecord } from '@/object-record/types/ObjectRecord';
import { type ApolloCache } from '@apollo/client';
import { isArray } from '@sniptt/guards';
@@ -39,6 +39,18 @@ type TriggerUpdateRelationsOptimisticEffectArgs = {
upsertRecordsInStore: (props: { partialRecords: ObjectRecord[] }) => void;
};
+// A junction record only exists to link its two sides, so detaching one destroys it.
+// Comments are the one remaining relation that cascades without being a junction.
+const shouldCascadeDeleteOnDetach = ({
+ targetObjectMetadata,
+ junctionObjectMetadataIds,
+}: {
+ targetObjectMetadata: FieldMetadataItemRelation['targetObjectMetadata'];
+ junctionObjectMetadataIds: ReadonlySet<string>;
+}) =>
+ junctionObjectMetadataIds.has(targetObjectMetadata.id) ||
+ targetObjectMetadata.nameSingular === CoreObjectNameSingular.Comment;
+
export const triggerUpdateRelationsOptimisticEffect = ({
cache,
sourceObjectMetadataItem,
@@ -51,6 +63,8 @@ export const triggerUpdateRelationsOptimisticEffect = ({
const isDeletion =
isDefined(updatedSourceRecord) &&
isDefined(updatedSourceRecord['deletedAt']);
+ const junctionObjectMetadataIds =
+ getJunctionObjectMetadataIds(objectMetadataItems);
sourceObjectMetadataItem.fields.forEach((fieldMetadataItemOnSourceRecord) => {
if (
@@ -71,6 +85,7 @@ export const triggerUpdateRelationsOptimisticEffect = ({
isDeletion,
upsertRecordsInStore,
objectPermissionsByObjectMetadataId,
+ junctionObjectMetadataIds,
});
}
@@ -85,6 +100,7 @@ export const triggerUpdateRelationsOptimisticEffect = ({
isDeletion,
upsertRecordsInStore,
objectPermissionsByObjectMetadataId,
+ junctionObjectMetadataIds,
});
}
});
@@ -100,6 +116,7 @@ const triggerUpdateRelationOptimisticEffect = ({
isDeletion,
upsertRecordsInStore,
objectPermissionsByObjectMetadataId,
+ junctionObjectMetadataIds,
}: {
fieldMetadataItemOnSourceRecord: FieldMetadataItem;
updatedSourceRecord: RecordGqlNode | null;
@@ -113,6 +130,7 @@ const triggerUpdateRelationOptimisticEffect = ({
string,
ObjectPermissions & { objectMetadataId: string }
>;
+ junctionObjectMetadataIds: ReadonlySet<string>;
}) => {
const fieldDoesNotExist =
isDefined(updatedSourceRecord) &&
@@ -176,12 +194,10 @@ const triggerUpdateRelationOptimisticEffect = ({
relation,
);
- // TODO: see if we can de-hardcode this, put cascade delete in relation metadata item
- // Instead of hardcoding it here
- const shouldCascadeDeleteTargetRecords =
- CORE_OBJECT_NAMES_TO_DELETE_ON_TRIGGER_RELATION_DETACH.includes(
- targetObjectMetadata.nameSingular as CoreObjectNameSingular,
- );
+ const shouldCascadeDeleteTargetRecords = shouldCascadeDeleteOnDetach({
+ targetObjectMetadata,
+ junctionObjectMetadataIds,
+ });
const gqlFieldNameOnTargetRecord =
targetFieldMetadataFullObject.type === FieldMetadataType.RELATION
@@ -256,6 +272,7 @@ const triggerUpdateMorphRelationOptimisticEffect = ({
isDeletion,
objectPermissionsByObjectMetadataId,
upsertRecordsInStore,
+ junctionObjectMetadataIds,
}: {
fieldMetadataItemOnSourceRecord: FieldMetadataItem;
updatedSourceRecord: RecordGqlNode | null;
@@ -269,6 +286,7 @@ const triggerUpdateMorphRelationOptimisticEffect = ({
string,
ObjectPermissions & { objectMetadataId: string }
>;
+ junctionObjectMetadataIds: ReadonlySet<string>;
}) => {
const morphRelations = fieldMetadataItemOnSourceRecord.morphRelations;
if (!morphRelations) {
@@ -342,12 +360,10 @@ const triggerUpdateMorphRelationOptimisticEffect = ({
morphRelation,
);
- // TODO: see if we can de-hardcode this, put cascade delete in relation metadata item
- // Instead of hardcoding it here
- const shouldCascadeDeleteTargetRecords =
- CORE_OBJECT_NAMES_TO_DELETE_ON_TRIGGER_RELATION_DETACH.includes(
- targetObjectMetadata.nameSingular as CoreObjectNameSingular,
- );
+ const shouldCascadeDeleteTargetRecords = shouldCascadeDeleteOnDetach({
+ targetObjectMetadata,
+ junctionObjectMetadataIds,
+ });
if (
shouldCascadeDeleteTargetRecords &&
targetRecordsToDetachFrom.length > 0
diff --git a/packages/twenty-front/src/modules/apollo/types/coreObjectNamesToDeleteOnRelationDetach.ts b/packages/twenty-front/src/modules/apollo/types/coreObjectNamesToDeleteOnRelationDetach.ts
deleted file mode 100644
index 3c568cd5041..00000000000
--- a/packages/twenty-front/src/modules/apollo/types/coreObjectNamesToDeleteOnRelationDetach.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-import { CoreObjectNameSingular } from 'twenty-shared/types';
-
-export const CORE_OBJECT_NAMES_TO_DELETE_ON_TRIGGER_RELATION_DETACH = [
- CoreObjectNameSingular.NoteTarget,
- CoreObjectNameSingular.TaskTarget,
- CoreObjectNameSingular.Comment,
-];
diff --git a/packages/twenty-front/src/modules/object-metadata/hooks/useActiveFieldMetadataItems.ts b/packages/twenty-front/src/modules/object-metadata/hooks/useActiveFieldMetadataItems.ts
index 1a261693f03..3e220a77b51 100644
--- a/packages/twenty-front/src/modules/object-metadata/hooks/useActiveFieldMetadataItems.ts
+++ b/packages/twenty-front/src/modules/object-metadata/hooks/useActiveFieldMetadataItems.ts
@@ -14,13 +14,11 @@ export const useActiveFieldMetadataItems = ({
isDefined(objectMetadataItem)
? dedupeMorphRelationFieldMetadataItems(
objectMetadataItem.readableFields.filter(
- ({ id, isActive, isSystem, name }) =>
- isActiveFieldMetadataItem({
- objectNameSingular: objectMetadataItem.nameSingular,
- fieldMetadata: { isActive, isSystem, name },
- }) ||
+ (fieldMetadata) =>
+ isActiveFieldMetadataItem({ fieldMetadata }) ||
// Allow label identifier field even if it's a system field
- id === objectMetadataItem.labelIdentifierFieldMetadataId,
+ fieldMetadata.id ===
+ objectMetadataItem.labelIdentifierFieldMetadataId,
),
)
: [],
diff --git a/packages/twenty-front/src/modules/object-metadata/types/CoreObjectNamePlural.ts b/packages/twenty-front/src/modules/object-metadata/types/CoreObjectNamePlural.ts
index f7010343516..6e7cec61bab 100644
--- a/packages/twenty-front/src/modules/object-metadata/types/CoreObjectNamePlural.ts
+++ b/packages/twenty-front/src/modules/object-metadata/types/CoreObjectNamePlural.ts
@@ -1,6 +1,4 @@
export enum CoreObjectNamePlural {
- Activity = 'activities',
- ActivityTarget = 'activityTargets',
ApiKey = 'apiKeys',
Attachment = 'attachments',
Blocklist = 'blocklists',
@@ -13,11 +11,9 @@ export enum CoreObjectNamePlural {
MessageParticipant = 'messageParticipants',
MessageThread = 'messageThreads',
Note = 'notes',
- NoteTarget = 'noteTargets',
Opportunity = 'opportunities',
Person = 'people',
Task = 'tasks',
- TaskTarget = 'taskTargets',
View = 'views',
ViewField = 'viewFields',
ViewFilter = 'viewFilters',
diff --git a/packages/twenty-front/src/modules/object-metadata/utils/__tests__/isActiveFieldMetadataItem.test.ts b/packages/twenty-front/src/modules/object-metadata/utils/__tests__/isActiveFieldMetadataItem.test.ts
index db6e1c42024..10be43883e5 100644
--- a/packages/twenty-front/src/modules/object-metadata/utils/__tests__/isActiveFieldMetadataItem.test.ts
+++ b/packages/twenty-front/src/modules/object-metadata/utils/__tests__/isActiveFieldMetadataItem.test.ts
@@ -1,50 +1,64 @@
import { isActiveFieldMetadataItem } from '@/object-metadata/utils/isActiveFieldMetadataItem';
+import { FieldMetadataType } from 'twenty-shared/types';
describe('isActiveFieldMetadataItem', () => {
it('should return false for inactive fields', () => {
const res = isActiveFieldMetadataItem({
- fieldMetadata: { isActive: false, isSystem: false, name: 'fieldName' },
- objectNameSingular: 'objectNameSingular',
+ fieldMetadata: {
+ isActive: false,
+ isSystem: false,
+ name: 'fieldName',
+ type: FieldMetadataType.TEXT,
+ },
});
expect(res).toBe(false);
});
it('should return true for active fields', () => {
const res = isActiveFieldMetadataItem({
- fieldMetadata: { isActive: true, isSystem: false, name: 'fieldName' },
- objectNameSingular: 'objectNameSingular',
+ fieldMetadata: {
+ isActive: true,
+ isSystem: false,
+ name: 'fieldName',
+ type: FieldMetadataType.TEXT,
+ },
});
expect(res).toBe(true);
});
it('should return false for hidden system fields', () => {
const res = isActiveFieldMetadataItem({
- fieldMetadata: { isActive: true, isSystem: true, name: 'position' },
- objectNameSingular: 'objectNameSingular',
+ fieldMetadata: {
+ isActive: true,
+ isSystem: true,
+ name: 'position',
+ type: FieldMetadataType.POSITION,
+ },
});
expect(res).toBe(false);
});
it('should return false for non hidden system fields', () => {
const res = isActiveFieldMetadataItem({
- fieldMetadata: { isActive: true, isSystem: true, name: 'fieldName' },
- objectNameSingular: 'objectNameSingular',
+ fieldMetadata: {
+ isActive: true,
+ isSystem: true,
+ name: 'fieldName',
+ type: FieldMetadataType.TEXT,
+ },
});
expect(res).toBe(true);
});
- it('should return true for note targets', () => {
+ it('should return true for junction relations, whatever object they belong to', () => {
const res = isActiveFieldMetadataItem({
- fieldMetadata: { isActive: true, isSystem: false, name: 'noteTargets' },
- objectNameSingular: 'note',
- });
- expect(res).toBe(true);
- });
-
- it('should return true for task targets', () => {
- const res = isActiveFieldMetadataItem({
- fieldMetadata: { isActive: true, isSystem: false, name: 'taskTargets' },
- objectNameSingular: 'task',
+ fieldMetadata: {
+ isActive: true,
+ isSystem: true,
+ name: 'position',
+ type: FieldMetadataType.RELATION,
+ settings: { junctionTargetFieldId: 'junction-target-field-id' },
+ },
});
expect(res).toBe(true);
});
diff --git a/packages/twenty-front/src/modules/object-metadata/utils/isActiveFieldMetadataItem.ts b/packages/twenty-front/src/modules/object-metadata/utils/isActiveFieldMetadataItem.ts
index 53bd930ef81..9c3de09d50c 100644
--- a/packages/twenty-front/src/modules/object-metadata/utils/isActiveFieldMetadataItem.ts
+++ b/packages/twenty-front/src/modules/object-metadata/utils/isActiveFieldMetadataItem.ts
@@ -1,26 +1,24 @@
-import { CoreObjectNameSingular } from 'twenty-shared/types';
import { type FieldMetadataItem } from '@/object-metadata/types/FieldMetadataItem';
import { isHiddenSystemField } from '@/object-metadata/utils/isHiddenSystemField';
+import { isConfiguredJunctionRelationField } from '@/object-record/record-field/ui/utils/junction/isConfiguredJunctionRelationField';
type IsFieldMetadataAvailableForViewFieldArgs = {
- objectNameSingular: string;
- fieldMetadata: Pick<FieldMetadataItem, 'name' | 'isSystem' | 'isActive'>;
+ fieldMetadata: Pick<
+ FieldMetadataItem,
+ 'name' | 'isSystem' | 'isActive' | 'type' | 'settings'
+ >;
};
export const isActiveFieldMetadataItem = ({
- objectNameSingular,
fieldMetadata,
}: IsFieldMetadataAvailableForViewFieldArgs) => {
if (fieldMetadata.isActive === false) {
return false;
}
- if (
- (objectNameSingular === CoreObjectNameSingular.Note &&
- fieldMetadata.name === 'noteTargets') ||
- (objectNameSingular === CoreObjectNameSingular.Task &&
- fieldMetadata.name === 'taskTargets')
- ) {
+ // A junction relation is a system field that must stay visible, since it is the only
+ // way to reach the records it links to.
+ if (isConfiguredJunctionRelationField(fieldMetadata)) {
return true;
}
diff --git a/packages/twenty-front/src/modules/object-record/graphql/record-gql-fields/utils/__tests__/__snapshots__/generateActivityTargetGqlFields.test.ts.snap b/packages/twenty-front/src/modules/object-record/graphql/record-gql-fields/utils/__tests__/__snapshots__/generateActivityTargetGqlFields.test.ts.snap
deleted file mode 100644
index 56c62e3b5d1..00000000000
--- a/packages/twenty-front/src/modules/object-record/graphql/record-gql-fields/utils/__tests__/__snapshots__/generateActivityTargetGqlFields.test.ts.snap
+++ /dev/null
@@ -1,195 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`generateActivityTargetGqlFields snapshot tests should match snapshot for Note with loadRelations="activity" 1`] = `
-{
- "id": true,
- "note": {
- "id": true,
- "title": true,
- },
-}
-`;
-
-exports[`generateActivityTargetGqlFields snapshot tests should match snapshot for Note with loadRelations="both" 1`] = `
-{
- "createdAt": true,
- "createdBy": true,
- "deletedAt": true,
- "id": true,
- "note": {
- "id": true,
- "title": true,
- },
- "noteId": true,
- "position": true,
- "searchVector": true,
- "targetCompany": {
- "domainName": true,
- "id": true,
- "name": true,
- },
- "targetCompanyId": true,
- "targetEmploymentHistory": {
- "id": true,
- },
- "targetEmploymentHistoryId": true,
- "targetOpportunity": {
- "id": true,
- "name": true,
- },
- "targetOpportunityId": true,
- "targetPerson": {
- "avatarFile": true,
- "id": true,
- "name": true,
- },
- "targetPersonId": true,
- "targetPet": {
- "id": true,
- "name": true,
- },
- "targetPetCareAgreement": {
- "id": true,
- },
- "targetPetCareAgreementId": true,
- "targetPetId": true,
- "targetRocket": {
- "id": true,
- "name": true,
- },
- "targetRocketId": true,
- "targetSurveyResult": {
- "id": true,
- "name": true,
- },
- "targetSurveyResultId": true,
- "updatedAt": true,
- "updatedBy": true,
-}
-`;
-
-exports[`generateActivityTargetGqlFields snapshot tests should match snapshot for Note with loadRelations="relations" 1`] = `
-{
- "createdAt": true,
- "createdBy": true,
- "deletedAt": true,
- "id": true,
- "position": true,
- "searchVector": true,
- "targetCompany": true,
- "targetCompanyId": true,
- "targetEmploymentHistory": true,
- "targetEmploymentHistoryId": true,
- "targetOpportunity": true,
- "targetOpportunityId": true,
- "targetPerson": true,
- "targetPersonId": true,
- "targetPet": true,
- "targetPetCareAgreement": true,
- "targetPetCareAgreementId": true,
- "targetPetId": true,
- "targetRocket": true,
- "targetRocketId": true,
- "targetSurveyResult": true,
- "targetSurveyResultId": true,
- "updatedAt": true,
- "updatedBy": true,
-}
-`;
-
-exports[`generateActivityTargetGqlFields snapshot tests should match snapshot for Task with loadRelations="activity" 1`] = `
-{
- "id": true,
- "task": {
- "id": true,
- "title": true,
- },
-}
-`;
-
-exports[`generateActivityTargetGqlFields snapshot tests should match snapshot for Task with loadRelations="both" 1`] = `
-{
- "createdAt": true,
- "createdBy": true,
- "deletedAt": true,
- "id": true,
- "position": true,
- "searchVector": true,
- "targetCompany": {
- "domainName": true,
- "id": true,
- "name": true,
- },
- "targetCompanyId": true,
- "targetEmploymentHistory": {
- "id": true,
- },
- "targetEmploymentHistoryId": true,
- "targetOpportunity": {
- "id": true,
- "name": true,
- },
- "targetOpportunityId": true,
- "targetPerson": {
- "avatarFile": true,
- "id": true,
- "name": true,
- },
- "targetPersonId": true,
- "targetPet": {
- "id": true,
- "name": true,
- },
- "targetPetCareAgreement": {
- "id": true,
- },
- "targetPetCareAgreementId": true,
- "targetPetId": true,
- "targetRocket": {
- "id": true,
- "name": true,
- },
- "targetRocketId": true,
- "targetSurveyResult": {
- "id": true,
- "name": true,
- },
- "targetSurveyResultId": true,
- "task": {
- "id": true,
- "title": true,
- },
- "taskId": true,
- "updatedAt": true,
- "updatedBy": true,
-}
-`;
-
-exports[`generateActivityTargetGqlFields snapshot tests should match snapshot for Task with loadRelations="relations" 1`] = `
-{
- "createdAt": true,
- "createdBy": true,
- "deletedAt": true,
- "id": true,
- "position": true,
- "searchVector": true,
- "targetCompany": true,
- "targetCompanyId": true,
- "targetEmploymentHistory": true,
- "targetEmploymentHistoryId": true,
- "targetOpportunity": true,
- "targetOpportunityId": true,
- "targetPerson": true,
- "targetPersonId": true,
- "targetPet": true,
- "targetPetCareAgreement": true,
- "targetPetCareAgreementId": true,
- "targetPetId": true,
- "targetRocket": true,
- "targetRocketId": true,
- "targetSurveyResult": true,
- "targetSurveyResultId": true,
- "updatedAt": true,
- "updatedBy": true,
-}
-`;
diff --git a/packages/twenty-front/src/modules/object-record/graphql/record-gql-fields/utils/__tests__/__snapshots__/generateDepthRecordGqlFieldsFromObject.test.ts.snap b/packages/twenty-front/src/modules/object-record/graphql/record-gql-fields/utils/__tests__/__snapshots__/generateDepthRecordGqlFieldsFromObject.test.ts.snap
index afb3b754636..138a3cdab54 100644
--- a/packages/twenty-front/src/modules/object-record/graphql/record-gql-fields/utils/__tests__/__snapshots__/generateDepthRecordGqlFieldsFromObject.test.ts.snap
+++ b/packages/twenty-front/src/modules/object-record/graphql/record-gql-fields/utils/__tests__/__snapshots__/generateDepthRecordGqlFieldsFromObject.test.ts.snap
@@ -1,4 +1,4 @@
-// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+// Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`generateDepthRecordGqlFieldsFromObject should generate depth one record gql fields from object 1`] = `
{
diff --git a/packages/twenty-front/src/modules/object-record/graphql/record-gql-fields/utils/__tests__/generateActivityTargetGqlFields.test.ts b/packages/twenty-front/src/modules/object-record/graphql/record-gql-fields/utils/__tests__/generateActivityTargetGqlFields.test.ts
deleted file mode 100644
index c97e4cab4f9..00000000000
--- a/packages/twenty-front/src/modules/object-record/graphql/record-gql-fields/utils/__tests__/generateActivityTargetGqlFields.test.ts
+++ /dev/null
@@ -1,67 +0,0 @@
-import { CoreObjectNameSingular } from 'twenty-shared/types';
-import { generateActivityTargetGqlFields } from '@/object-record/graphql/record-gql-fields/utils/generateActivityTargetGqlFields';
-import { getTestEnrichedObjectMetadataItemsMock } from '~/testing/utils/getTestEnrichedObjectMetadataItemsMock';
-
-describe('generateActivityTargetGqlFields', () => {
- describe('snapshot tests', () => {
- it('should match snapshot for Note with loadRelations="activity"', () => {
- const result = generateActivityTargetGqlFields({
- objectMetadataItems: getTestEnrichedObjectMetadataItemsMock(),
- activityObjectNameSingular: CoreObjectNameSingular.Note,
- loadRelations: 'activity',
- });
-
- expect(result).toMatchSnapshot();
- });
-
- it('should match snapshot for Note with loadRelations="both"', () => {
- const result = generateActivityTargetGqlFields({
- objectMetadataItems: getTestEnrichedObjectMetadataItemsMock(),
- activityObjectNameSingular: CoreObjectNameSingular.Note,
- loadRelations: 'both',
- });
-
- expect(result).toMatchSnapshot();
- });
-
- it('should match snapshot for Note with loadRelations="relations"', () => {
- const result = generateActivityTargetGqlFields({
- objectMetadataItems: getTestEnrichedObjectMetadataItemsMock(),
- activityObjectNameSingular: CoreObjectNameSingular.Note,
- loadRelations: 'relations',
- });
-
- expect(result).toMatchSnapshot();
- });
-
- it('should match snapshot for Task with loadRelations="activity"', () => {
- const result = generateActivityTargetGqlFields({
- objectMetadataItems: getTestEnrichedObjectMetadataItemsMock(),
- activityObjectNameSingular: CoreObjectNameSingular.Task,
- loadRelations: 'activity',
- });
-
- expect(result).toMatchSnapshot();
- });
-
- it('should match snapshot for Task with loadRelations="both"', () => {
- const result = generateActivityTargetGqlFields({
- objectMetadataItems: getTestEnrichedObjectMetadataItemsMock(),
- activityObjectNameSingular: CoreObjectNameSingular.Task,
- loadRelations: 'both',
- });
-
- expect(result).toMatchSnapshot();
- });
-
- it('should match snapshot for Task with loadRelations="relations"', () => {
- const result = generateActivityTargetGqlFields({
- objectMetadataItems: getTestEnrichedObjectMetadataItemsMock(),
- activityObjectNameSingular: CoreObjectNameSingular.Task,
- loadRelations: 'relations',
- });
-
- expect(result).toMatchSnapshot();
- });
- });
-});
diff --git a/packages/twenty-front/src/modules/object-record/graphql/record-gql-fields/utils/generateActivityTargetGqlFields.ts b/packages/twenty-front/src/modules/object-record/graphql/record-gql-fields/utils/generateActivityTargetGqlFields.ts
deleted file mode 100644
index 4ef2931121b..00000000000
--- a/packages/twenty-front/src/modules/object-record/graphql/record-gql-fields/utils/generateActivityTargetGqlFields.ts
+++ /dev/null
@@ -1,101 +0,0 @@
-import { CoreObjectNameSingular } from 'twenty-shared/types';
-import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
-import { getLabelIdentifierFieldMetadataItem } from '@/object-metadata/utils/getLabelIdentifierFieldMetadataItem';
-import { generateDepthRecordGqlFieldsFromFields } from '@/object-record/graphql/record-gql-fields/utils/generateDepthRecordGqlFieldsFromFields';
-import { isDefined } from 'twenty-shared/utils';
-
-export type GenerateDepthRecordGqlFields = {
- objectMetadataItems: Pick<
- EnrichedObjectMetadataItem,
- | 'id'
- | 'nameSingular'
- | 'namePlural'
- | 'fields'
- | 'labelIdentifierFieldMetadataId'
- | 'imageIdentifierFieldMetadataId'
- >[];
- activityObjectNameSingular:
- | CoreObjectNameSingular.Note
- | CoreObjectNameSingular.Task;
- loadRelations?: 'activity' | 'relations' | 'both';
-};
-
-export const generateActivityTargetGqlFields = ({
- objectMetadataItems,
- activityObjectNameSingular,
- loadRelations = 'both',
-}: GenerateDepthRecordGqlFields) => {
- const isNote = activityObjectNameSingular === CoreObjectNameSingular.Note;
- const activityTargetNameSingular = isNote
- ? CoreObjectNameSingular.NoteTarget
- : CoreObjectNameSingular.TaskTarget;
-
- const activityTargetObjectMetadataItem = objectMetadataItems.find(
- (objectMetadataItem) =>
- objectMetadataItem.nameSingular === activityTargetNameSingular,
- );
-
- const activityObjectMetadataItem = objectMetadataItems.find(
- (objectMetadataItem) =>
- objectMetadataItem.nameSingular === activityObjectNameSingular,
- );
-
- if (
- !isDefined(activityTargetObjectMetadataItem) ||
- !isDefined(activityObjectMetadataItem)
- ) {
- return {};
- }
-
- const activityLabelIdentifierFieldMetadataItem =
- getLabelIdentifierFieldMetadataItem(activityObjectMetadataItem);
-
- if (loadRelations === 'activity') {
- return {
- id: true,
- [activityObjectNameSingular]: {
- id: true,
- ...(isDefined(activityLabelIdentifierFieldMetadataItem)
- ? { [activityLabelIdentifierFieldMetadataItem.name]: true }
- : {}),
- },
- };
- }
-
- if (loadRelations === 'both') {
- return {
- id: true,
- [activityObjectNameSingular]: {
- id: true,
- ...(isDefined(activityLabelIdentifierFieldMetadataItem)
- ? { [activityLabelIdentifierFieldMetadataItem.name]: true }
- : {}),
- },
- ...generateDepthRecordGqlFieldsFromFields({
- depth: 1,
- fields: activityTargetObjectMetadataItem.fields,
- objectMetadataItems,
- shouldOnlyLoadRelationIdentifiers: true,
- }),
- };
- }
-
- if (loadRelations === 'relations') {
- return {
- ...generateDepthRecordGqlFieldsFromFields({
- depth: 1,
- fields: activityTargetObjectMetadataItem.fields.filter(
- (fieldMetadataItem) =>
- fieldMetadataItem.name !== 'task' &&
- fieldMetadataItem.name !== 'note',
- ),
- objectMetadataItems,
- shouldOnlyLoadRelationIdentifiers: false,
- }),
- };
- }
-
- throw new Error(
- `Invalid loadRelations value: ${loadRelations}. Please use 'activity', 'relations', or 'both'.`,
- );
-};
diff --git a/packages/twenty-front/src/modules/object-record/graphql/record-gql-fields/utils/generateDepthRecordGqlFieldsFromFields.ts b/packages/twenty-front/src/modules/object-record/graphql/record-gql-fields/utils/generateDepthRecordGqlFieldsFromFields.ts
index ed9a98bba30..22b0fdd4aa1 100644
--- a/packages/twenty-front/src/modules/object-record/graphql/record-gql-fields/utils/generateDepthRecordGqlFieldsFromFields.ts
+++ b/packages/twenty-front/src/modules/object-record/graphql/record-gql-fields/utils/generateDepthRecordGqlFieldsFromFields.ts
@@ -1,16 +1,10 @@
-import { CoreObjectNamePlural } from '@/object-metadata/types/CoreObjectNamePlural';
-import {
- CoreObjectNameSingular,
- FieldMetadataType,
- RelationType,
-} from 'twenty-shared/types';
+import { FieldMetadataType, RelationType } from 'twenty-shared/types';
import { type FieldMetadataItem } from '@/object-metadata/types/FieldMetadataItem';
import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
import { type RecordGqlFields } from '@/object-record/graphql/record-gql-fields/types/RecordGqlFields';
import { buildIdentifierGqlFields } from '@/object-record/graphql/record-gql-fields/utils/buildIdentifierGqlFields';
-import { generateActivityTargetGqlFields } from '@/object-record/graphql/record-gql-fields/utils/generateActivityTargetGqlFields';
import { generateJunctionRelationGqlFields } from '@/object-record/graphql/record-gql-fields/utils/generateJunctionRelationGqlFields';
-import { isJunctionRelationField } from '@/object-record/record-field/ui/utils/junction/isJunctionRelationField';
+import { getReverseJunctionConfig } from '@/object-record/record-field/ui/utils/junction/getReverseJunctionConfig';
import {
computeMorphRelationGqlFieldName,
isDefined,
@@ -26,6 +20,8 @@ export type GenerateDepthRecordGqlFieldsFromFields = {
| 'nameSingular'
| 'namePlural'
>[];
+ // Required to resolve the junction records held by the reverse side of a junction
+ sourceObjectMetadataItem?: Pick<EnrichedObjectMetadataItem, 'id'>;
fields: Pick<
FieldMetadataItem,
'id' | 'name' | 'type' | 'settings' | 'morphRelations' | 'relation'
@@ -36,6 +32,7 @@ export type GenerateDepthRecordGqlFieldsFromFields = {
export const generateDepthRecordGqlFieldsFromFields = ({
objectMetadataItems,
+ sourceObjectMetadataItem,
fields,
depth,
shouldOnlyLoadRelationIdentifiers = true,
@@ -62,40 +59,37 @@ export const generateDepthRecordGqlFieldsFromFields = ({
);
}
- const isActivityTargetField =
- fieldMetadata.name === CoreObjectNamePlural.NoteTarget ||
- fieldMetadata.name === CoreObjectNamePlural.TaskTarget;
-
- if (isActivityTargetField && depth === 1) {
- const activityTargetObjectNameSingular =
- fieldMetadata.name === CoreObjectNamePlural.NoteTarget
- ? CoreObjectNameSingular.Note
- : CoreObjectNameSingular.Task;
-
- const activityTargetGqlFields = generateActivityTargetGqlFields({
- activityObjectNameSingular: activityTargetObjectNameSingular,
- objectMetadataItems,
- loadRelations: 'activity',
- });
+ const reverseJunctionConfig = getReverseJunctionConfig({
+ junctionObjectMetadataId: targetObjectMetadataItem.id,
+ sourceObjectMetadataId: sourceObjectMetadataItem?.id,
+ objectMetadataItems,
+ });
+ if (isDefined(reverseJunctionConfig) && depth === 1) {
return {
...recordGqlFields,
- [fieldMetadata.name]: activityTargetGqlFields,
+ [fieldMetadata.name]: {
+ ...buildIdentifierGqlFields(
+ reverseJunctionConfig.junctionObjectMetadata,
+ ),
+ [reverseJunctionConfig.relationFieldName]:
+ buildIdentifierGqlFields(
+ reverseJunctionConfig.relatedObjectMetadata,
+ ),
+ },
};
}
- if (isJunctionRelationField(fieldMetadata)) {
- const junctionGqlFields = generateJunctionRelationGqlFields({
- fieldMetadataItem: fieldMetadata,
- objectMetadataItems,
- });
+ const junctionGqlFields = generateJunctionRelationGqlFields({
+ fieldMetadataItem: fieldMetadata,
+ objectMetadataItems,
+ });
- if (isDefined(junctionGqlFields) && depth === 1) {
- return {
- ...recordGqlFields,
- [fieldMetadata.name]: junctionGqlFields,
- };
- }
+ if (isDefined(junctionGqlFields) && depth === 1) {
+ return {
+ ...recordGqlFields,
+ [fieldMetadata.name]: junctionGqlFields,
+ };
}
const relationIdentifierSubGqlFields = buildIdentifierGqlFields(
diff --git a/packages/twenty-front/src/modules/object-record/graphql/record-gql-fields/utils/generateDepthRecordGqlFieldsFromObject.ts b/packages/twenty-front/src/modules/object-record/graphql/record-gql-fields/utils/generateDepthRecordGqlFieldsFromObject.ts
index b8393a42a55..21624a2c3b7 100644
--- a/packages/twenty-front/src/modules/object-record/graphql/record-gql-fields/utils/generateDepthRecordGqlFieldsFromObject.ts
+++ b/packages/twenty-front/src/modules/object-record/graphql/record-gql-fields/utils/generateDepthRecordGqlFieldsFromObject.ts
@@ -3,7 +3,7 @@ import { generateDepthRecordGqlFieldsFromFields } from '@/object-record/graphql/
export type GenerateDepthRecordGqlFields = {
objectMetadataItems: EnrichedObjectMetadataItem[];
- objectMetadataItem: Pick<EnrichedObjectMetadataItem, 'fields'>;
+ objectMetadataItem: Pick<EnrichedObjectMetadataItem, 'id' | 'fields'>;
depth: 0 | 1;
shouldOnlyLoadRelationIdentifiers?: boolean;
};
@@ -16,6 +16,7 @@ export const generateDepthRecordGqlFieldsFromObject = ({
}: GenerateDepthRecordGqlFields) => {
return generateDepthRecordGqlFieldsFromFields({
objectMetadataItems,
+ sourceObjectMetadataItem: objectMetadataItem,
fields: objectMetadataItem.fields,
depth,
shouldOnlyLoadRelationIdentifiers,
diff --git a/packages/twenty-front/src/modules/object-record/graphql/record-gql-fields/utils/generateJunctionRelationGqlFields.ts b/packages/twenty-front/src/modules/object-record/graphql/record-gql-fields/utils/generateJunctionRelationGqlFields.ts
index 0ca9c755027..892e7e56f59 100644
--- a/packages/twenty-front/src/modules/object-record/graphql/record-gql-fields/utils/generateJunctionRelationGqlFields.ts
+++ b/packages/twenty-front/src/modules/object-record/graphql/record-gql-fields/utils/generateJunctionRelationGqlFields.ts
@@ -90,6 +90,8 @@ export const generateJunctionRelationGqlFields = ({
settings: fieldMetadataItem.settings,
relationObjectMetadataId:
fieldMetadataItem.relation?.targetObjectMetadata.id ?? '',
+ relationTargetFieldMetadataId:
+ fieldMetadataItem.relation?.targetFieldMetadata.id,
objectMetadataItems,
});
diff --git a/packages/twenty-front/src/modules/object-record/hooks/__tests__/useRecordIndexTableQuery.test.tsx b/packages/twenty-front/src/modules/object-record/hooks/__tests__/useRecordIndexTableQuery.test.tsx
index b4233afde88..1712a73cc48 100644
--- a/packages/twenty-front/src/modules/object-record/hooks/__tests__/useRecordIndexTableQuery.test.tsx
+++ b/packages/twenty-front/src/modules/object-record/hooks/__tests__/useRecordIndexTableQuery.test.tsx
@@ -57,6 +57,19 @@ const mocks: MockedResponse[] = [
extension
url
}
+ caredForPets {
+ edges {
+ node {
+ __typename
+ id
+ pet {
+ __typename
+ id
+ name
+ }
+ }
+ }
+ }
createdAt
deletedAt
id
@@ -78,6 +91,24 @@ const mocks: MockedResponse[] = [
}
}
position
+ previousCompanies {
+ edges {
+ node {
+ __typename
+ company {
+ __typename
+ domainName {
+ primaryLinkUrl
+ primaryLinkLabel
+ secondaryLinks
+ }
+ id
+ name
+ }
+ id
+ }
+ }
+ }
taskTargets {
edges {
node {
diff --git a/packages/twenty-front/src/modules/object-record/record-field-list/components/RecordFieldList.tsx b/packages/twenty-front/src/modules/object-record/record-field-list/components/RecordFieldList.tsx
index 4f6aeb95d40..69ba67352af 100644
--- a/packages/twenty-front/src/modules/object-record/record-field-list/components/RecordFieldList.tsx
+++ b/packages/twenty-front/src/modules/object-record/record-field-list/components/RecordFieldList.tsx
@@ -1,4 +1,3 @@
-import { ActivityTargetsInlineCell } from '@/activities/inline-cell/components/ActivityTargetsInlineCell';
import { useGetIsMetadataItemFromStandardApplication } from '@/object-metadata/hooks/useGetIsMetadataItemFromStandardApplication';
import { useObjectMetadataItem } from '@/object-metadata/hooks/useObjectMetadataItem';
import { useObjectMetadataItems } from '@/object-metadata/hooks/useObjectMetadataItems';
@@ -24,10 +23,7 @@ import { useRecordShowContainerData } from '@/object-record/record-show/hooks/us
import { getRecordFieldInputInstanceId } from '@/object-record/utils/getRecordFieldInputId';
import { getObjectPermissionsFromMapByObjectMetadataId } from '@/settings/roles/role-permissions/objects-permissions/utils/getObjectPermissionsFromMapByObjectMetadataId';
import { useSetAtomComponentState } from '@/ui/utilities/state/jotai/hooks/useSetAtomComponentState';
-import {
- FieldMetadataType,
- type CoreObjectNameSingular,
-} from 'twenty-shared/types';
+import { FieldMetadataType } from 'twenty-shared/types';
type RecordFieldListProps = {
instanceId: string;
@@ -79,16 +75,13 @@ export const RecordFieldList = ({
setRecordFieldListHoverPosition(index);
};
- const {
- inlineFieldMetadataItems,
- legacyActivityTargetFieldMetadataItems,
- boxedRelationFieldMetadataItems,
- } = useFieldListFieldMetadataItems({
- objectNameSingular,
- excludeFieldMetadataIds,
- showRelationSections,
- excludeCreatedAtAndUpdatedAt,
- });
+ const { inlineFieldMetadataItems, boxedRelationFieldMetadataItems } =
+ useFieldListFieldMetadataItems({
+ objectNameSingular,
+ excludeFieldMetadataIds,
+ showRelationSections,
+ excludeCreatedAtAndUpdatedAt,
+ });
return (
<RecordFieldListComponentInstanceContext.Provider
@@ -97,72 +90,6 @@ export const RecordFieldList = ({
}}
>
<PropertyBox dataTestId="record-fields-list-container">
- {legacyActivityTargetFieldMetadataItems?.map(
- (fieldMetadataItem, index) => {
- const fieldDefinition = formatFieldMetadataItemAsColumnDefinition({
- field: fieldMetadataItem,
- position: index,
- objectMetadataItem,
- showLabel: true,
- labelWidth: 90,
- });
-
- return (
- <FieldContext.Provider
- key={objectRecordId + fieldMetadataItem.id}
- value={{
- recordId: objectRecordId,
- maxWidth: 200,
- isLabelIdentifier: false,
- fieldDefinition,
- useUpdateRecord: useUpdateOneObjectRecordMutation,
- isDisplayModeFixHeight: true,
- onMouseEnter: () => handleMouseEnter(index),
- anchorId: `${getRecordFieldInputInstanceId({
- recordId: objectRecordId,
- fieldName: fieldMetadataItem.name,
- prefix: instanceId,
- })}`,
- isRecordFieldReadOnly: isRecordFieldReadOnly({
- isRecordReadOnly,
- isSystemObject: objectMetadataItem.isSystem,
- objectPermissions:
- getObjectPermissionsFromMapByObjectMetadataId({
- objectPermissionsByObjectMetadataId,
- objectMetadataId: objectMetadataItem.id,
- }),
- isFieldFromStandardApplication:
- getIsMetadataItemFromStandardApplication(
- fieldMetadataItem,
- ),
- fieldMetadataItem: {
- id: fieldMetadataItem.id,
- isUIEditable: fieldMetadataItem.isUIEditable ?? true,
- },
- fieldDefinition,
- objectPermissionsByObjectMetadataId,
- }),
- }}
- >
- <ActivityTargetsInlineCell
- componentInstanceId={getRecordFieldInputInstanceId({
- recordId: objectRecordId,
- fieldName: fieldMetadataItem.name,
- prefix: instanceId,
- })}
- activityObjectNameSingular={
- objectNameSingular as
- | CoreObjectNameSingular.Note
- | CoreObjectNameSingular.Task
- }
- activityRecordId={objectRecordId}
- showLabel={true}
- maxWidth={200}
- />
- </FieldContext.Provider>
- );
- },
- )}
{inlineFieldMetadataItems?.map((fieldMetadataItem, index) => {
const fieldDefinition = formatFieldMetadataItemAsColumnDefinition({
field: fieldMetadataItem,
@@ -199,11 +126,7 @@ export const RecordFieldList = ({
fieldDefinition,
objectPermissionsByObjectMetadataId,
}),
- onMouseEnter: () =>
- handleMouseEnter(
- index +
- (legacyActivityTargetFieldMetadataItems?.length ?? 0),
- ),
+ onMouseEnter: () => handleMouseEnter(index),
anchorId: `${getRecordFieldInputInstanceId({
recordId: objectRecordId,
fieldName: fieldMetadataItem.name,
diff --git a/packages/twenty-front/src/modules/object-record/record-field-list/hooks/useFieldListFieldMetadataFromPosition.ts b/packages/twenty-front/src/modules/object-record/record-field-list/hooks/useFieldListFieldMetadataFromPosition.ts
index d5daa306e5f..e934c2a52aa 100644
--- a/packages/twenty-front/src/modules/object-record/record-field-list/hooks/useFieldListFieldMetadataFromPosition.ts
+++ b/packages/twenty-front/src/modules/object-record/record-field-list/hooks/useFieldListFieldMetadataFromPosition.ts
@@ -19,16 +19,12 @@ export const useFieldListFieldMetadataFromPosition = ({
recordFieldListCellEditModePositionComponentState,
);
- const {
- inlineFieldMetadataItems,
- legacyActivityTargetFieldMetadataItems,
- boxedRelationFieldMetadataItems,
- } = useFieldListFieldMetadataItems({
- objectNameSingular,
- });
+ const { inlineFieldMetadataItems, boxedRelationFieldMetadataItems } =
+ useFieldListFieldMetadataItems({
+ objectNameSingular,
+ });
const fieldMetadataItems = [
- ...legacyActivityTargetFieldMetadataItems,
...inlineFieldMetadataItems,
...boxedRelationFieldMetadataItems,
];
diff --git a/packages/twenty-front/src/modules/object-record/record-field-list/hooks/useFieldListFieldMetadataItems.ts b/packages/twenty-front/src/modules/object-record/record-field-list/hooks/useFieldListFieldMetadataItems.ts
index 82105a5fc0d..5f24839bbc8 100644
--- a/packages/twenty-front/src/modules/object-record/record-field-list/hooks/useFieldListFieldMetadataItems.ts
+++ b/packages/twenty-front/src/modules/object-record/record-field-list/hooks/useFieldListFieldMetadataItems.ts
@@ -4,10 +4,8 @@ import { useObjectMetadataItems } from '@/object-metadata/hooks/useObjectMetadat
import { useObjectPermissions } from '@/object-record/hooks/useObjectPermissions';
import { categorizeRelationFields } from '@/object-record/record-field-list/utils/categorizeRelationFields';
import { isFieldCellSupported } from '@/object-record/utils/isFieldCellSupported';
-import { useIsFeatureEnabled } from '@/workspace/hooks/useIsFeatureEnabled';
import groupBy from 'lodash.groupby';
import { CoreObjectNameSingular, FieldMetadataType } from 'twenty-shared/types';
-import { FeatureFlagKey } from '~/generated-metadata/graphql';
type UseFieldListFieldMetadataItemsProps = {
objectNameSingular: string;
@@ -37,10 +35,6 @@ export const useFieldListFieldMetadataItems = ({
const { objectMetadataItems } = useObjectMetadataItems();
- const isJunctionRelationsEnabled = useIsFeatureEnabled(
- FeatureFlagKey.IS_JUNCTION_RELATIONS_ENABLED,
- );
-
const availableFieldMetadataItems = objectMetadataItem.readableFields
.filter(
(fieldMetadataItem) =>
@@ -83,17 +77,12 @@ export const useFieldListFieldMetadataItems = ({
: 'inlineFieldMetadataItems',
);
- const {
- activityTargetFields,
- inlineRelationFields,
- junctionRelationFields,
- boxedRelationFields,
- } = categorizeRelationFields({
- relationFields: relationFieldMetadataItems ?? [],
- objectNameSingular,
- objectPermissionsByObjectMetadataId,
- isJunctionRelationsEnabled,
- });
+ const { inlineRelationFields, junctionRelationFields, boxedRelationFields } =
+ categorizeRelationFields({
+ relationFields: relationFieldMetadataItems ?? [],
+ objectMetadataItems,
+ objectPermissionsByObjectMetadataId,
+ });
const allInlineFieldMetadataItems = [
...(inlineFieldMetadataItems ?? []),
@@ -102,7 +91,6 @@ export const useFieldListFieldMetadataItems = ({
return {
inlineFieldMetadataItems: allInlineFieldMetadataItems,
- legacyActivityTargetFieldMetadataItems: activityTargetFields,
junctionRelationFieldMetadataItems: junctionRelationFields,
boxedRelationFieldMetadataItems: boxedRelationFields,
};
diff --git a/packages/twenty-front/src/modules/object-record/record-field-list/record-detail-section/relation/components/RecordDetailRelationSectionDropdownToMany.tsx b/packages/twenty-front/src/modules/object-record/record-field-list/record-detail-section/relation/components/RecordDetailRelationSectionDropdownToMany.tsx
index fa746c2847c..1dfe72f5a9d 100644
--- a/packages/twenty-front/src/modules/object-record/record-field-list/record-detail-section/relation/components/RecordDetailRelationSectionDropdownToMany.tsx
+++ b/packages/twenty-front/src/modules/object-record/record-field-list/record-detail-section/relation/components/RecordDetailRelationSectionDropdownToMany.tsx
@@ -16,7 +16,6 @@ import { type FieldRelationMetadata } from '@/object-record/record-field/ui/type
import { extractTargetRecordsFromJunction } from '@/object-record/record-field/ui/utils/junction/extractTargetRecordsFromJunction';
import { getJunctionConfig } from '@/object-record/record-field/ui/utils/junction/getJunctionConfig';
import { getSourceJoinColumnName } from '@/object-record/record-field/ui/utils/junction/getSourceJoinColumnName';
-import { hasJunctionConfig } from '@/object-record/record-field/ui/utils/junction/hasJunctionConfig';
import { MultipleRecordPicker } from '@/object-record/record-picker/multiple-record-picker/components/MultipleRecordPicker';
import { useMultipleRecordPickerOpen } from '@/object-record/record-picker/multiple-record-picker/hooks/useMultipleRecordPickerOpen';
import { useMultipleRecordPickerPerformSearch } from '@/object-record/record-picker/multiple-record-picker/hooks/useMultipleRecordPickerPerformSearch';
@@ -72,8 +71,6 @@ export const RecordDetailRelationSectionDropdownToMany = ({
);
}
- const isJunctionRelation = hasJunctionConfig(fieldMetadataItem.settings);
-
const relationFieldDefinition =
fieldDefinition as FieldDefinition<FieldRelationMetadata>;
@@ -84,16 +81,17 @@ export const RecordDetailRelationSectionDropdownToMany = ({
recordId,
});
- const junctionConfig =
- isJunctionRelation && isJunctionConfigValid
- ? getJunctionConfig({
- settings: fieldMetadataItem.settings,
- relationObjectMetadataId:
- relationFieldDefinition.metadata.relationObjectMetadataId,
- sourceObjectMetadataId: objectMetadataItem.id,
- objectMetadataItems,
- })
- : null;
+ const junctionConfig = isJunctionConfigValid
+ ? getJunctionConfig({
+ settings: fieldMetadataItem.settings,
+ relationObjectMetadataId:
+ relationFieldDefinition.metadata.relationObjectMetadataId,
+ relationTargetFieldMetadataId: relationFieldMetadataId,
+ sourceObjectMetadataId: objectMetadataItem.id,
+ objectMetadataItems,
+ })
+ : null;
+ const isJunctionRelation = isDefined(junctionConfig);
const firstJunctionTargetField =
junctionConfig && !junctionConfig.isMorphRelation
diff --git a/packages/twenty-front/src/modules/object-record/record-field-list/utils/__tests__/categorizeRelationFields.test.ts b/packages/twenty-front/src/modules/object-record/record-field-list/utils/__tests__/categorizeRelationFields.test.ts
new file mode 100644
index 00000000000..9a263fc2714
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-record/record-field-list/utils/__tests__/categorizeRelationFields.test.ts
@@ -0,0 +1,26 @@
+import { categorizeRelationFields } from '@/object-record/record-field-list/utils/categorizeRelationFields';
+import { getMockFieldMetadataItemOrThrow } from '~/testing/utils/getMockFieldMetadataItemOrThrow';
+import { getMockObjectMetadataItemOrThrow } from '~/testing/utils/getMockObjectMetadataItemOrThrow';
+import { getTestEnrichedObjectMetadataItemsMock } from '~/testing/utils/getTestEnrichedObjectMetadataItemsMock';
+
+describe('categorizeRelationFields', () => {
+ it('categorizes configured activity junctions as regular inline junctions', () => {
+ const taskMetadata = getMockObjectMetadataItemOrThrow('task');
+ const taskTargetsField = getMockFieldMetadataItemOrThrow({
+ objectMetadataItem: taskMetadata,
+ fieldName: 'taskTargets',
+ });
+
+ expect(
+ categorizeRelationFields({
+ relationFields: [taskTargetsField],
+ objectMetadataItems: getTestEnrichedObjectMetadataItemsMock(),
+ objectPermissionsByObjectMetadataId: {},
+ }),
+ ).toEqual({
+ inlineRelationFields: [taskTargetsField],
+ junctionRelationFields: [taskTargetsField],
+ boxedRelationFields: [],
+ });
+ });
+});
diff --git a/packages/twenty-front/src/modules/object-record/record-field-list/utils/__tests__/isActivityTargetField.test.ts b/packages/twenty-front/src/modules/object-record/record-field-list/utils/__tests__/isActivityTargetField.test.ts
deleted file mode 100644
index 41e7248de11..00000000000
--- a/packages/twenty-front/src/modules/object-record/record-field-list/utils/__tests__/isActivityTargetField.test.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-import { CoreObjectNameSingular } from 'twenty-shared/types';
-import { isActivityTargetField } from '@/object-record/record-field-list/utils/categorizeRelationFields';
-
-describe('isActivityTargetField', () => {
- it('should return true for noteTargets field on Note object', () => {
- expect(
- isActivityTargetField('noteTargets', CoreObjectNameSingular.Note),
- ).toBe(true);
- });
-
- it('should return true for taskTargets field on Task object', () => {
- expect(
- isActivityTargetField('taskTargets', CoreObjectNameSingular.Task),
- ).toBe(true);
- });
-
- it('should return false for noteTargets field on non-Note object', () => {
- expect(
- isActivityTargetField('noteTargets', CoreObjectNameSingular.Task),
- ).toBe(false);
- });
-
- it('should return false for taskTargets field on non-Task object', () => {
- expect(
- isActivityTargetField('taskTargets', CoreObjectNameSingular.Note),
- ).toBe(false);
- });
-
- it('should return false for regular field names', () => {
- expect(
- isActivityTargetField('company', CoreObjectNameSingular.Person),
- ).toBe(false);
- expect(
- isActivityTargetField('people', CoreObjectNameSingular.Company),
- ).toBe(false);
- });
-});
diff --git a/packages/twenty-front/src/modules/object-record/record-field-list/utils/categorizeRelationFields.ts b/packages/twenty-front/src/modules/object-record/record-field-list/utils/categorizeRelationFields.ts
index e900740aa81..3dccb788f92 100644
--- a/packages/twenty-front/src/modules/object-record/record-field-list/utils/categorizeRelationFields.ts
+++ b/packages/twenty-front/src/modules/object-record/record-field-list/utils/categorizeRelationFields.ts
@@ -1,10 +1,8 @@
import { type FieldMetadataItem } from '@/object-metadata/types/FieldMetadataItem';
+import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
import { getObjectPermissionsForObject } from '@/object-metadata/utils/getObjectPermissionsForObject';
-import { isJunctionRelationField } from '@/object-record/record-field/ui/utils/junction/isJunctionRelationField';
-import {
- CoreObjectNameSingular,
- type ObjectPermissions,
-} from 'twenty-shared/types';
+import { getJunctionConfig } from '@/object-record/record-field/ui/utils/junction/getJunctionConfig';
+import { type ObjectPermissions } from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
type ObjectPermissionsByObjectMetadataId = Record<
@@ -14,32 +12,16 @@ type ObjectPermissionsByObjectMetadataId = Record<
type CategorizeRelationFieldsArgs = {
relationFields: FieldMetadataItem[];
- objectNameSingular: string;
+ objectMetadataItems: EnrichedObjectMetadataItem[];
objectPermissionsByObjectMetadataId: ObjectPermissionsByObjectMetadataId;
- isJunctionRelationsEnabled: boolean;
};
type CategorizedRelationFields = {
- activityTargetFields: FieldMetadataItem[];
inlineRelationFields: FieldMetadataItem[];
junctionRelationFields: FieldMetadataItem[];
boxedRelationFields: FieldMetadataItem[];
};
-export const isActivityTargetField = (
- fieldName: string,
- objectNameSingular: string,
-): boolean =>
- (objectNameSingular === CoreObjectNameSingular.Note &&
- fieldName === 'noteTargets') ||
- (objectNameSingular === CoreObjectNameSingular.Task &&
- fieldName === 'taskTargets');
-
-const isActivityTargetRelation = (
- fieldMetadataItem: FieldMetadataItem,
- objectNameSingular: string,
-): boolean => isActivityTargetField(fieldMetadataItem.name, objectNameSingular);
-
const canReadRelationTarget = (
fieldMetadataItem: FieldMetadataItem,
objectPermissionsByObjectMetadataId: ObjectPermissionsByObjectMetadataId,
@@ -65,22 +47,23 @@ const canReadRelationTarget = (
export const categorizeRelationFields = ({
relationFields,
- objectNameSingular,
+ objectMetadataItems,
objectPermissionsByObjectMetadataId,
- isJunctionRelationsEnabled,
}: CategorizeRelationFieldsArgs): CategorizedRelationFields => {
- const activityTargetFields: FieldMetadataItem[] = [];
const inlineRelationFields: FieldMetadataItem[] = [];
const junctionRelationFields: FieldMetadataItem[] = [];
const boxedRelationFields: FieldMetadataItem[] = [];
for (const field of relationFields) {
- if (isActivityTargetRelation(field, objectNameSingular)) {
- activityTargetFields.push(field);
- continue;
- }
+ const junctionConfig = getJunctionConfig({
+ settings: field.settings,
+ relationObjectMetadataId: field.relation?.targetObjectMetadata.id ?? '',
+ relationTargetFieldMetadataId: field.relation?.targetFieldMetadata.id,
+ sourceObjectMetadataId: field.relation?.sourceObjectMetadata.id,
+ objectMetadataItems,
+ });
- if (isJunctionRelationsEnabled && isJunctionRelationField(field)) {
+ if (isDefined(junctionConfig)) {
inlineRelationFields.push(field);
junctionRelationFields.push(field);
continue;
@@ -92,7 +75,6 @@ export const categorizeRelationFields = ({
}
return {
- activityTargetFields,
inlineRelationFields,
junctionRelationFields,
boxedRelationFields,
diff --git a/packages/twenty-front/src/modules/object-record/record-field/hooks/useRelevantRecordsGqlFields.ts b/packages/twenty-front/src/modules/object-record/record-field/hooks/useRelevantRecordsGqlFields.ts
index ceef5d3f3c5..3eeb5b5ad55 100644
--- a/packages/twenty-front/src/modules/object-record/record-field/hooks/useRelevantRecordsGqlFields.ts
+++ b/packages/twenty-front/src/modules/object-record/record-field/hooks/useRelevantRecordsGqlFields.ts
@@ -3,10 +3,8 @@ import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/Enriche
import { getImageIdentifierFieldMetadataItem } from '@/object-metadata/utils/getImageIdentifierFieldMetadataItem';
import { getLabelIdentifierFieldMetadataItem } from '@/object-metadata/utils/getLabelIdentifierFieldMetadataItem';
import { hasObjectMetadataItemPositionField } from '@/object-metadata/utils/hasObjectMetadataItemPositionField';
-import { generateActivityTargetGqlFields } from '@/object-record/graphql/record-gql-fields/utils/generateActivityTargetGqlFields';
-import { CoreObjectNameSingular } from 'twenty-shared/types';
-
import { generateDepthRecordGqlFieldsFromFields } from '@/object-record/graphql/record-gql-fields/utils/generateDepthRecordGqlFieldsFromFields';
+import { getJunctionObjectMetadataIds } from '@/object-record/record-field/ui/utils/junction/getJunctionObjectMetadataIds';
import { visibleRecordFieldsComponentSelector } from '@/object-record/record-field/states/visibleRecordFieldsComponentSelector';
import { currentRecordFiltersComponentState } from '@/object-record/record-filter/states/currentRecordFiltersComponentState';
import { useRecordIndexContextOrThrow } from '@/object-record/record-index/contexts/RecordIndexContext';
@@ -72,6 +70,22 @@ export const useRelevantRecordsGqlFields = ({
depth: 1,
});
+ // Junction records are the only way to reach what they link to, so they are always
+ // fetched, whether or not the field holding them is visible.
+ const junctionObjectMetadataIds =
+ getJunctionObjectMetadataIds(objectMetadataItems);
+
+ const junctionRelationGqlFields = generateDepthRecordGqlFieldsFromFields({
+ objectMetadataItems,
+ sourceObjectMetadataItem: objectMetadataItem,
+ fields: objectMetadataItem.fields.filter((fieldMetadataItem) =>
+ junctionObjectMetadataIds.has(
+ fieldMetadataItem.relation?.targetObjectMetadata.id ?? '',
+ ),
+ ),
+ depth: 1,
+ });
+
const labelIdentifierFieldMetadataItem =
getLabelIdentifierFieldMetadataItem(objectMetadataItem);
const imageIdentifierFieldMetadataItem =
@@ -79,10 +93,6 @@ export const useRelevantRecordsGqlFields = ({
const hasPosition = hasObjectMetadataItemPositionField(objectMetadataItem);
- const isObjectAnActivity =
- objectMetadataItem.nameSingular === CoreObjectNameSingular.Note ||
- objectMetadataItem.nameSingular === CoreObjectNameSingular.Task;
-
return {
id: true,
...(isDefined(labelIdentifierFieldMetadataItem)
@@ -92,19 +102,10 @@ export const useRelevantRecordsGqlFields = ({
? { [imageIdentifierFieldMetadataItem.name]: true }
: {}),
...(hasPosition ? { position: true } : {}),
+ ...junctionRelationGqlFields,
...allDepthOneGqlFields,
createdAt: true,
updatedAt: true,
deletedAt: true,
- noteTargets: generateActivityTargetGqlFields({
- activityObjectNameSingular: CoreObjectNameSingular.Note,
- objectMetadataItems,
- loadRelations: isObjectAnActivity ? 'relations' : 'activity',
- }),
- taskTargets: generateActivityTargetGqlFields({
- activityObjectNameSingular: CoreObjectNameSingular.Task,
- objectMetadataItems,
- loadRelations: isObjectAnActivity ? 'relations' : 'activity',
- }),
};
};
diff --git a/packages/twenty-front/src/modules/object-record/record-field/states/visibleRecordFieldsComponentSelector.ts b/packages/twenty-front/src/modules/object-record/record-field/states/visibleRecordFieldsComponentSelector.ts
index 5effe44f300..6d18f41eaf0 100644
--- a/packages/twenty-front/src/modules/object-record/record-field/states/visibleRecordFieldsComponentSelector.ts
+++ b/packages/twenty-front/src/modules/object-record/record-field/states/visibleRecordFieldsComponentSelector.ts
@@ -68,7 +68,6 @@ const filterVisibleAndReadableRecordFields = (
const isActive =
isLabelIdentifier ||
isActiveFieldMetadataItem({
- objectNameSingular: objectMetadataItem.nameSingular,
fieldMetadata: fieldMetadataItem,
});
diff --git a/packages/twenty-front/src/modules/object-record/record-field/ui/components/FieldContextProvider.tsx b/packages/twenty-front/src/modules/object-record/record-field/ui/components/FieldContextProvider.tsx
index 9fa0db8c2aa..34d2d471df1 100644
--- a/packages/twenty-front/src/modules/object-record/record-field/ui/components/FieldContextProvider.tsx
+++ b/packages/twenty-front/src/modules/object-record/record-field/ui/components/FieldContextProvider.tsx
@@ -20,6 +20,9 @@ export const FieldContextProvider = ({
overridenIsFieldEmpty,
onMouseEnter,
anchorId,
+ showLabel = true,
+ maxWidth,
+ isDisplayModeFixHeight,
children,
}: {
clearable?: boolean;
@@ -32,6 +35,9 @@ export const FieldContextProvider = ({
overridenIsFieldEmpty?: boolean;
onMouseEnter?: () => void;
anchorId?: string;
+ showLabel?: boolean;
+ maxWidth?: number;
+ isDisplayModeFixHeight?: boolean;
children: ReactNode;
}) => {
const { objectMetadataItem } = useObjectMetadataItem({
@@ -74,7 +80,7 @@ export const FieldContextProvider = ({
isLabelIdentifier,
fieldDefinition: formatFieldMetadataItemAsColumnDefinition({
field: fieldMetadataItem,
- showLabel: true,
+ showLabel,
position: fieldPosition,
objectMetadataItem,
labelWidth: 90,
@@ -86,6 +92,8 @@ export const FieldContextProvider = ({
isRecordFieldReadOnly,
onMouseEnter,
anchorId,
+ maxWidth,
+ isDisplayModeFixHeight,
}}
>
{children}
diff --git a/packages/twenty-front/src/modules/object-record/record-field/ui/hooks/useObjectMorphJunctionConfigOrThrow.ts b/packages/twenty-front/src/modules/object-record/record-field/ui/hooks/useObjectMorphJunctionConfigOrThrow.ts
new file mode 100644
index 00000000000..a9bd8fec96c
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-record/record-field/ui/hooks/useObjectMorphJunctionConfigOrThrow.ts
@@ -0,0 +1,26 @@
+import { useObjectMetadataItem } from '@/object-metadata/hooks/useObjectMetadataItem';
+import { useObjectMetadataItems } from '@/object-metadata/hooks/useObjectMetadataItems';
+import { getObjectMorphJunctionConfig } from '@/object-record/record-field/ui/utils/junction/getObjectMorphJunctionConfig';
+import { isDefined } from 'twenty-shared/utils';
+
+export const useObjectMorphJunctionConfigOrThrow = ({
+ objectNameSingular,
+}: {
+ objectNameSingular: string;
+}) => {
+ const { objectMetadataItem } = useObjectMetadataItem({ objectNameSingular });
+ const { objectMetadataItems } = useObjectMetadataItems();
+
+ const junctionConfig = getObjectMorphJunctionConfig({
+ objectMetadata: objectMetadataItem,
+ objectMetadataItems,
+ });
+
+ if (!isDefined(junctionConfig)) {
+ throw new Error(
+ `Cannot resolve morph junction metadata for ${objectNameSingular}`,
+ );
+ }
+
+ return junctionConfig;
+};
diff --git a/packages/twenty-front/src/modules/object-record/record-field/ui/hooks/useOpenFieldInputEditMode.ts b/packages/twenty-front/src/modules/object-record/record-field/ui/hooks/useOpenFieldInputEditMode.ts
index dd3bc2ea63a..b0a13d30eab 100644
--- a/packages/twenty-front/src/modules/object-record/record-field/ui/hooks/useOpenFieldInputEditMode.ts
+++ b/packages/twenty-front/src/modules/object-record/record-field/ui/hooks/useOpenFieldInputEditMode.ts
@@ -1,10 +1,3 @@
-import { useOpenActivityTargetCellEditMode } from '@/activities/inline-cell/hooks/useOpenActivityTargetCellEditMode';
-import { type Note } from '@/activities/types/Note';
-import { type NoteTarget } from '@/activities/types/NoteTarget';
-import { type Task } from '@/activities/types/Task';
-import { type TaskTarget } from '@/activities/types/TaskTarget';
-import { getActivityTargetObjectRecords } from '@/activities/utils/getActivityTargetObjectRecords';
-import { currentWorkspaceState } from '@/auth/states/currentWorkspaceState';
import { objectMetadataItemsSelector } from '@/object-metadata/states/objectMetadataItemsSelector';
import { useUpdateOneRecord } from '@/object-record/hooks/useUpdateOneRecord';
import { useOpenJunctionRelationFieldInput } from '@/object-record/record-field/ui/hooks/useOpenJunctionRelationFieldInput';
@@ -14,21 +7,14 @@ import { useOpenMorphRelationOneToManyFieldInput } from '@/object-record/record-
import { useOpenRelationFromManyFieldInput } from '@/object-record/record-field/ui/meta-types/input/hooks/useOpenRelationFromManyFieldInput';
import { useOpenRelationToOneFieldInput } from '@/object-record/record-field/ui/meta-types/input/hooks/useOpenRelationToOneFieldInput';
import { type FieldDefinition } from '@/object-record/record-field/ui/types/FieldDefinition';
-import {
- type FieldMetadata,
- type FieldRelationFromManyValue,
- type FieldRelationMetadata,
- type FieldRelationValue,
-} from '@/object-record/record-field/ui/types/FieldMetadata';
+import { type FieldMetadata } from '@/object-record/record-field/ui/types/FieldMetadata';
import { isFieldFiles } from '@/object-record/record-field/ui/types/guards/isFieldFiles';
import { isFieldMorphRelation } from '@/object-record/record-field/ui/types/guards/isFieldMorphRelation';
import { isFieldMorphRelationManyToOne } from '@/object-record/record-field/ui/types/guards/isFieldMorphRelationManyToOne';
import { isFieldMorphRelationOneToMany } from '@/object-record/record-field/ui/types/guards/isFieldMorphRelationOneToMany';
import { isFieldRelationManyToOne } from '@/object-record/record-field/ui/types/guards/isFieldRelationManyToOne';
import { isFieldRelationOneToMany } from '@/object-record/record-field/ui/types/guards/isFieldRelationOneToMany';
-import { hasJunctionConfig } from '@/object-record/record-field/ui/utils/junction/hasJunctionConfig';
-import { recordStoreFamilyState } from '@/object-record/record-store/states/recordStoreFamilyState';
-import { recordStoreFamilySelector } from '@/object-record/record-store/states/selectors/recordStoreFamilySelector';
+import { getJunctionConfig } from '@/object-record/record-field/ui/utils/junction/getJunctionConfig';
import { getRecordFieldInputInstanceId } from '@/object-record/utils/getRecordFieldInputId';
import { usePushFocusItemToFocusStack } from '@/ui/utilities/focus/hooks/usePushFocusItemToFocusStack';
import { useRemoveFocusItemFromFocusStackById } from '@/ui/utilities/focus/hooks/useRemoveFocusItemFromFocusStackById';
@@ -46,9 +32,6 @@ export const useOpenFieldInputEditMode = () => {
const { openMorphRelationOneToManyFieldInput } =
useOpenMorphRelationOneToManyFieldInput();
- const { openActivityTargetCellEditMode } =
- useOpenActivityTargetCellEditMode();
-
const { openJunctionRelationFieldInput } =
useOpenJunctionRelationFieldInput();
@@ -75,17 +58,23 @@ export const useOpenFieldInputEditMode = () => {
}) => {
const objectMetadataItems = store.get(objectMetadataItemsSelector.atom);
- const currentWorkspace = store.get(currentWorkspaceState.atom);
-
- const isJunctionRelationsEnabled =
- currentWorkspace?.featureFlags?.find(
- (flag) => (flag.key as string) === 'IS_JUNCTION_RELATIONS_ENABLED',
- )?.value ?? false;
-
- const isOneToMany = isFieldRelationOneToMany(fieldDefinition);
- const fieldHasJunctionConfig = hasJunctionConfig(
- fieldDefinition.metadata.settings,
- );
+ const sourceObjectMetadataId = objectMetadataItems.find(
+ ({ nameSingular }) =>
+ nameSingular === fieldDefinition.metadata.objectMetadataNameSingular,
+ )?.id;
+ const fieldHasJunctionConfig =
+ isFieldRelationOneToMany(fieldDefinition) &&
+ isDefined(
+ getJunctionConfig({
+ settings: fieldDefinition.metadata.settings,
+ relationObjectMetadataId:
+ fieldDefinition.metadata.relationObjectMetadataId,
+ relationTargetFieldMetadataId:
+ fieldDefinition.metadata.relationFieldMetadataId,
+ sourceObjectMetadataId,
+ objectMetadataItems,
+ }),
+ );
if (isFieldFiles(fieldDefinition)) {
const objectMetadataItem = objectMetadataItems.find(
@@ -118,50 +107,15 @@ export const useOpenFieldInputEditMode = () => {
}
}
- if (isJunctionRelationsEnabled && isOneToMany && fieldHasJunctionConfig) {
+ if (isFieldRelationOneToMany(fieldDefinition) && fieldHasJunctionConfig) {
openJunctionRelationFieldInput({
- fieldDefinition:
- fieldDefinition as FieldDefinition<FieldRelationMetadata>,
+ fieldDefinition,
recordId,
prefix,
});
return;
}
- // Backward compatibility: hardcoded taskTarget/noteTarget check
- // TODO: Remove this once taskTarget/noteTarget are migrated to use junction configuration
- if (
- isFieldRelationOneToMany(fieldDefinition) &&
- ['taskTarget', 'noteTarget'].includes(
- fieldDefinition.metadata.relationObjectMetadataNameSingular,
- )
- ) {
- const fieldValue = store.get(
- recordStoreFamilySelector.selectorFamily({
- recordId,
- fieldName: fieldDefinition.metadata.fieldName,
- }),
- ) as FieldRelationValue<FieldRelationFromManyValue>;
-
- const activity = store.get(recordStoreFamilyState.atomFamily(recordId));
-
- const activityTargetObjectRecords = getActivityTargetObjectRecords({
- activityRecord: activity as Task | Note,
- objectMetadataItems,
- activityTargets: fieldValue as NoteTarget[] | TaskTarget[],
- });
-
- openActivityTargetCellEditMode({
- recordPickerInstanceId: getRecordFieldInputInstanceId({
- recordId,
- fieldName: fieldDefinition.metadata.fieldName,
- prefix,
- }),
- activityTargetObjectRecords,
- });
- return;
- }
-
if (isFieldRelationManyToOne(fieldDefinition)) {
openRelationToOneFieldInput({
fieldName: fieldDefinition.metadata.fieldName,
@@ -229,7 +183,6 @@ export const useOpenFieldInputEditMode = () => {
});
},
[
- openActivityTargetCellEditMode,
openFilesFieldInput,
openJunctionRelationFieldInput,
openMorphRelationManyToOneFieldInput,
diff --git a/packages/twenty-front/src/modules/object-record/record-field/ui/hooks/useOpenJunctionRelationFieldInput.ts b/packages/twenty-front/src/modules/object-record/record-field/ui/hooks/useOpenJunctionRelationFieldInput.ts
index db5c42a9253..8b595cf52b2 100644
--- a/packages/twenty-front/src/modules/object-record/record-field/ui/hooks/useOpenJunctionRelationFieldInput.ts
+++ b/packages/twenty-front/src/modules/object-record/record-field/ui/hooks/useOpenJunctionRelationFieldInput.ts
@@ -32,10 +32,12 @@ export const useOpenJunctionRelationFieldInput = () => {
fieldDefinition,
recordId,
prefix,
+ recordPickerInstanceId,
}: {
fieldDefinition: FieldDefinition<FieldRelationMetadata>;
recordId: string;
prefix?: string;
+ recordPickerInstanceId?: string;
}) => {
const objectMetadataItems = store.get(objectMetadataItemsSelector.atom);
@@ -49,6 +51,8 @@ export const useOpenJunctionRelationFieldInput = () => {
settings: fieldDefinition.metadata.settings,
relationObjectMetadataId:
fieldDefinition.metadata.relationObjectMetadataId,
+ relationTargetFieldMetadataId:
+ fieldDefinition.metadata.relationFieldMetadataId,
sourceObjectMetadataId,
objectMetadataItems,
});
@@ -63,11 +67,13 @@ export const useOpenJunctionRelationFieldInput = () => {
return;
}
- const recordPickerInstanceId = getRecordFieldInputInstanceId({
- recordId,
- fieldName: fieldDefinition.metadata.fieldName,
- prefix,
- });
+ const resolvedRecordPickerInstanceId =
+ recordPickerInstanceId ??
+ getRecordFieldInputInstanceId({
+ recordId,
+ fieldName: fieldDefinition.metadata.fieldName,
+ prefix,
+ });
const junctionRecords = store.get(
recordStoreFamilySelector.selectorFamily({
@@ -96,39 +102,39 @@ export const useOpenJunctionRelationFieldInput = () => {
store.set(
multipleRecordPickerPickableMorphItemsComponentState.atomFamily({
- instanceId: recordPickerInstanceId,
+ instanceId: resolvedRecordPickerInstanceId,
}),
pickableMorphItems,
);
store.set(
multipleRecordPickerSearchableObjectMetadataItemsComponentState.atomFamily(
- { instanceId: recordPickerInstanceId },
+ { instanceId: resolvedRecordPickerInstanceId },
),
searchableObjectMetadataItems,
);
store.set(
multipleRecordPickerSearchFilterComponentState.atomFamily({
- instanceId: recordPickerInstanceId,
+ instanceId: resolvedRecordPickerInstanceId,
}),
'',
);
- openMultipleRecordPicker(recordPickerInstanceId);
+ openMultipleRecordPicker(resolvedRecordPickerInstanceId);
performSearch({
- multipleRecordPickerInstanceId: recordPickerInstanceId,
+ multipleRecordPickerInstanceId: resolvedRecordPickerInstanceId,
forceSearchFilter: '',
forceSearchableObjectMetadataItems: searchableObjectMetadataItems,
forcePickableMorphItems: pickableMorphItems,
});
pushFocusItemToFocusStack({
- focusId: recordPickerInstanceId,
+ focusId: resolvedRecordPickerInstanceId,
component: {
type: FocusComponentType.DROPDOWN,
- instanceId: recordPickerInstanceId,
+ instanceId: resolvedRecordPickerInstanceId,
},
globalHotkeysConfig: {
enableGlobalHotkeysConflictingWithKeyboard: false,
diff --git a/packages/twenty-front/src/modules/object-record/record-field/ui/hooks/useUpdateJunctionRelationFromCell.ts b/packages/twenty-front/src/modules/object-record/record-field/ui/hooks/useUpdateJunctionRelationFromCell.ts
index ba194b6687d..658ebe9c800 100644
--- a/packages/twenty-front/src/modules/object-record/record-field/ui/hooks/useUpdateJunctionRelationFromCell.ts
+++ b/packages/twenty-front/src/modules/object-record/record-field/ui/hooks/useUpdateJunctionRelationFromCell.ts
@@ -45,6 +45,8 @@ export const useUpdateJunctionRelationFromCell = ({
const junctionConfig = getJunctionConfig({
settings: fieldMetadataItem.settings,
relationObjectMetadataId: fieldDefinition.metadata.relationObjectMetadataId,
+ relationTargetFieldMetadataId:
+ fieldMetadataItem.relation?.targetFieldMetadata.id,
sourceObjectMetadataId: sourceObjectMetadata?.id,
objectMetadataItems,
});
diff --git a/packages/twenty-front/src/modules/object-record/record-field/ui/meta-types/display/components/RelationFromManyFieldDisplay.tsx b/packages/twenty-front/src/modules/object-record/record-field/ui/meta-types/display/components/RelationFromManyFieldDisplay.tsx
index 98043a72918..9246c0b96c2 100644
--- a/packages/twenty-front/src/modules/object-record/record-field/ui/meta-types/display/components/RelationFromManyFieldDisplay.tsx
+++ b/packages/twenty-front/src/modules/object-record/record-field/ui/meta-types/display/components/RelationFromManyFieldDisplay.tsx
@@ -1,19 +1,14 @@
import { useContext } from 'react';
-import { useActivityTargetObjectRecords } from '@/activities/hooks/useActivityTargetObjectRecords';
-import { type NoteTarget } from '@/activities/types/NoteTarget';
-import { type TaskTarget } from '@/activities/types/TaskTarget';
import { useObjectMetadataItems } from '@/object-metadata/hooks/useObjectMetadataItems';
-import { CoreObjectNameSingular } from 'twenty-shared/types';
import { RecordChip } from '@/object-record/components/RecordChip';
-import { isActivityTargetField } from '@/object-record/record-field-list/utils/categorizeRelationFields';
import { FieldContext } from '@/object-record/record-field/ui/contexts/FieldContext';
import { useFieldFocus } from '@/object-record/record-field/ui/hooks/useFieldFocus';
import { MAX_RELATION_CHIPS_DISPLAYED_INLINE } from '@/object-record/record-field/ui/meta-types/display/constants/MaxRelationChipsDisplayedInline';
import { useRelationFromManyFieldDisplay } from '@/object-record/record-field/ui/meta-types/hooks/useRelationFromManyFieldDisplay';
import { extractTargetRecordsFromJunction } from '@/object-record/record-field/ui/utils/junction/extractTargetRecordsFromJunction';
import { getJunctionConfig } from '@/object-record/record-field/ui/utils/junction/getJunctionConfig';
-import { hasJunctionConfig } from '@/object-record/record-field/ui/utils/junction/hasJunctionConfig';
+import { getReverseJunctionConfig } from '@/object-record/record-field/ui/utils/junction/getReverseJunctionConfig';
import { ExpandableList } from '@/ui/layout/expandable-list/components/ExpandableList';
import { styled } from '@linaria/react';
@@ -38,15 +33,11 @@ export const RelationFromManyFieldDisplay = () => {
const { disableChipClick, triggerEvent } = useContext(FieldContext);
const { objectMetadataItems } = useObjectMetadataItems();
- const { fieldName, objectMetadataNameSingular } = fieldDefinition.metadata;
+ const { objectMetadataNameSingular } = fieldDefinition.metadata;
const relationObjectNameSingular =
fieldDefinition?.metadata.relationObjectMetadataNameSingular;
- const isJunctionRelation = hasJunctionConfig(
- fieldDefinition.metadata.settings,
- );
-
const sourceObjectMetadataId = objectMetadataItems.find(
(item) => item.nameSingular === objectMetadataNameSingular,
)?.id;
@@ -54,14 +45,17 @@ export const RelationFromManyFieldDisplay = () => {
const junctionConfig = getJunctionConfig({
settings: fieldDefinition.metadata.settings,
relationObjectMetadataId: fieldDefinition.metadata.relationObjectMetadataId,
+ relationTargetFieldMetadataId:
+ fieldDefinition.metadata.relationFieldMetadataId,
sourceObjectMetadataId,
objectMetadataItems,
});
- const { activityTargetObjectRecords } = useActivityTargetObjectRecords(
- '',
- fieldValue as NoteTarget[] | TaskTarget[],
- );
+ const reverseJunctionConfig = getReverseJunctionConfig({
+ junctionObjectMetadataId: fieldDefinition.metadata.relationObjectMetadataId,
+ sourceObjectMetadataId,
+ objectMetadataItems,
+ });
if (!isDefined(fieldValue)) {
return null;
@@ -75,59 +69,7 @@ export const RelationFromManyFieldDisplay = () => {
return null;
}
- const isRelationFromActivityTargets = isActivityTargetField(
- fieldName,
- objectMetadataNameSingular ?? '',
- );
-
- const isRelationFromManyActivities =
- (fieldName === 'noteTargets' &&
- objectMetadataNameSingular !== CoreObjectNameSingular.Note) ||
- (fieldName === 'taskTargets' &&
- objectMetadataNameSingular !== CoreObjectNameSingular.Task);
-
- if (isRelationFromManyActivities) {
- const objectNameSingular =
- fieldName === 'noteTargets'
- ? CoreObjectNameSingular.Note
- : CoreObjectNameSingular.Task;
- const relationFieldName = fieldName === 'noteTargets' ? 'note' : 'task';
-
- const chips = fieldValue
- .map((record) => {
- if (!isDefined(record) || !isDefined(record[relationFieldName])) {
- return undefined;
- }
- return (
- <RecordChip
- key={record.id}
- objectNameSingular={objectNameSingular}
- record={record[relationFieldName]}
- forceDisableClick={disableChipClick}
- />
- );
- })
- .filter(isDefined);
-
- if (isFocused) {
- return (
- <ExpandableList
- isChipCountDisplayed={isFocused}
- maxInlineCount={MAX_RELATION_CHIPS_DISPLAYED_INLINE}
- >
- {chips}
- </ExpandableList>
- );
- }
-
- return (
- <StyledContainer>
- {chips.slice(0, MAX_RELATION_CHIPS_DISPLAYED_INLINE)}
- </StyledContainer>
- );
- }
-
- if (isJunctionRelation && isDefined(junctionConfig)) {
+ if (isDefined(junctionConfig)) {
const { targetFields } = junctionConfig;
if (targetFields.length === 0) {
@@ -175,21 +117,44 @@ export const RelationFromManyFieldDisplay = () => {
);
}
- if (isRelationFromActivityTargets) {
- return (
- <ExpandableList
- isChipCountDisplayed={isFocused}
- maxInlineCount={MAX_RELATION_CHIPS_DISPLAYED_INLINE}
- >
- {activityTargetObjectRecords.filter(isDefined).map((record) => (
+ if (isDefined(reverseJunctionConfig)) {
+ const chips = fieldValue
+ .map((junctionRecord) => {
+ const relatedRecord =
+ junctionRecord?.[reverseJunctionConfig.relationFieldName];
+
+ if (!isDefined(junctionRecord) || !isDefined(relatedRecord)) {
+ return undefined;
+ }
+
+ return (
<RecordChip
- key={record.targetObject.id}
- objectNameSingular={record.targetObjectMetadataItem.nameSingular}
- record={record.targetObject}
+ key={junctionRecord.id}
+ objectNameSingular={
+ reverseJunctionConfig.relatedObjectMetadata.nameSingular
+ }
+ record={relatedRecord}
forceDisableClick={disableChipClick}
/>
- ))}
- </ExpandableList>
+ );
+ })
+ .filter(isDefined);
+
+ if (isFocused) {
+ return (
+ <ExpandableList
+ isChipCountDisplayed
+ maxInlineCount={MAX_RELATION_CHIPS_DISPLAYED_INLINE}
+ >
+ {chips}
+ </ExpandableList>
+ );
+ }
+
+ return (
+ <StyledContainer>
+ {chips.slice(0, MAX_RELATION_CHIPS_DISPLAYED_INLINE)}
+ </StyledContainer>
);
}
diff --git a/packages/twenty-front/src/modules/object-record/record-field/ui/meta-types/input/components/RelationOneToManyFieldInput.tsx b/packages/twenty-front/src/modules/object-record/record-field/ui/meta-types/input/components/RelationOneToManyFieldInput.tsx
index fdfe5680b1a..8f43e206bdb 100644
--- a/packages/twenty-front/src/modules/object-record/record-field/ui/meta-types/input/components/RelationOneToManyFieldInput.tsx
+++ b/packages/twenty-front/src/modules/object-record/record-field/ui/meta-types/input/components/RelationOneToManyFieldInput.tsx
@@ -2,20 +2,13 @@ import { useCallback, useContext } from 'react';
import { useStore } from 'jotai';
import { v4 } from 'uuid';
-import { useActivityTargetObjectRecords } from '@/activities/hooks/useActivityTargetObjectRecords';
-import { useUpdateActivityTargetFromCell } from '@/activities/inline-cell/hooks/useUpdateActivityTargetFromCell';
-import { type NoteTarget } from '@/activities/types/NoteTarget';
-import { type TaskTarget } from '@/activities/types/TaskTarget';
import { useObjectMetadataItem } from '@/object-metadata/hooks/useObjectMetadataItem';
import { useObjectMetadataItems } from '@/object-metadata/hooks/useObjectMetadataItems';
-import { type CoreObjectNameSingular } from 'twenty-shared/types';
import { getFieldMetadataItemById } from '@/object-metadata/utils/getFieldMetadataItemById';
import { useCreateOneRecord } from '@/object-record/hooks/useCreateOneRecord';
-import { isActivityTargetField } from '@/object-record/record-field-list/utils/categorizeRelationFields';
import { FieldContext } from '@/object-record/record-field/ui/contexts/FieldContext';
import { FieldInputEventContext } from '@/object-record/record-field/ui/contexts/FieldInputEventContext';
import { useUpdateJunctionRelationFromCell } from '@/object-record/record-field/ui/hooks/useUpdateJunctionRelationFromCell';
-import { useRelationField } from '@/object-record/record-field/ui/meta-types/hooks/useRelationField';
import { useAddNewRecordAndOpenSidePanel } from '@/object-record/record-field/ui/meta-types/input/hooks/useAddNewRecordAndOpenSidePanel';
import { useUpdateRelationOneToManyFieldInput } from '@/object-record/record-field/ui/meta-types/input/hooks/useUpdateRelationOneToManyFieldInput';
import { RecordFieldComponentInstanceContext } from '@/object-record/record-field/ui/states/contexts/RecordFieldComponentInstanceContext';
@@ -24,7 +17,6 @@ import { type FieldDefinition } from '@/object-record/record-field/ui/types/Fiel
import { type FieldRelationMetadata } from '@/object-record/record-field/ui/types/FieldMetadata';
import { getJunctionConfig } from '@/object-record/record-field/ui/utils/junction/getJunctionConfig';
import { getSourceJoinColumnName } from '@/object-record/record-field/ui/utils/junction/getSourceJoinColumnName';
-import { hasJunctionConfig } from '@/object-record/record-field/ui/utils/junction/hasJunctionConfig';
import { MultipleRecordPicker } from '@/object-record/record-picker/multiple-record-picker/components/MultipleRecordPicker';
import { useMultipleRecordPickerPerformSearch } from '@/object-record/record-picker/multiple-record-picker/hooks/useMultipleRecordPickerPerformSearch';
import { multipleRecordPickerPickableMorphItemsComponentState } from '@/object-record/record-picker/multiple-record-picker/states/multipleRecordPickerPickableMorphItemsComponentState';
@@ -48,7 +40,6 @@ export const RelationOneToManyFieldInput = () => {
const { onSubmit } = useContext(FieldInputEventContext);
const { updateRelation } = useUpdateRelationOneToManyFieldInput();
- const fieldName = fieldDefinition.metadata.fieldName;
const { objectMetadataItems } = useObjectMetadataItems();
const { fieldMetadataItem, objectMetadataItem } = getFieldMetadataItemById({
fieldMetadataId: fieldDefinition.fieldMetadataId,
@@ -60,34 +51,10 @@ export const RelationOneToManyFieldInput = () => {
'FIELD_METADATA_ITEM_OR_OBJECT_METADATA_ITEM_NOT_FOUND',
);
}
- const objectMetadataNameSingular =
- fieldDefinition.metadata.objectMetadataNameSingular;
-
- const { updateActivityTargetFromCell } = useUpdateActivityTargetFromCell({
- activityObjectNameSingular: objectMetadataNameSingular as
- | CoreObjectNameSingular.Note
- | CoreObjectNameSingular.Task,
- activityId: recordId,
- });
-
- const { fieldValue } = useRelationField();
-
const handleSubmit = () => {
onSubmit?.({ skipPersist: true });
};
- const isRelationFromActivityTargets = isActivityTargetField(
- fieldName,
- objectMetadataNameSingular ?? '',
- );
-
- const isJunctionRelation = hasJunctionConfig(fieldMetadataItem.settings);
-
- const { activityTargetObjectRecords } = useActivityTargetObjectRecords(
- recordId,
- fieldValue as NoteTarget[] | TaskTarget[],
- );
-
const relationFieldDefinition =
fieldDefinition as FieldDefinition<FieldRelationMetadata>;
@@ -98,16 +65,18 @@ export const RelationOneToManyFieldInput = () => {
recordId,
});
- const junctionConfig =
- isJunctionRelation && isJunctionConfigValid
- ? getJunctionConfig({
- settings: fieldMetadataItem.settings,
- relationObjectMetadataId:
- relationFieldDefinition.metadata.relationObjectMetadataId,
- sourceObjectMetadataId: objectMetadataItem.id,
- objectMetadataItems,
- })
- : null;
+ const junctionConfig = isJunctionConfigValid
+ ? getJunctionConfig({
+ settings: fieldMetadataItem.settings,
+ relationObjectMetadataId:
+ relationFieldDefinition.metadata.relationObjectMetadataId,
+ relationTargetFieldMetadataId:
+ fieldMetadataItem.relation?.targetFieldMetadata.id,
+ sourceObjectMetadataId: objectMetadataItem.id,
+ objectMetadataItems,
+ })
+ : null;
+ const isJunctionRelation = isDefined(junctionConfig);
const junctionTargetObjectMetadata = (() => {
if (!junctionConfig || junctionConfig.isMorphRelation) {
@@ -277,9 +246,8 @@ export const RelationOneToManyFieldInput = () => {
],
);
- // Disable "Add New" for activity targets and MORPH junction relations
- // (For MORPH, we don't know which object type to create)
- const canCreateNew = !isRelationFromActivityTargets && !isMorphJunction;
+ // For MORPH junctions, we don't know which object type to create.
+ const canCreateNew = !isMorphJunction;
// For junction relations, use the target object for "Add New", not the junction object
const objectMetadataItemIdForCreate =
@@ -293,13 +261,7 @@ export const RelationOneToManyFieldInput = () => {
componentInstanceId={instanceId}
onSubmit={handleSubmit}
onChange={(morphItem) => {
- if (isRelationFromActivityTargets) {
- updateActivityTargetFromCell({
- morphItem,
- activityTargetWithTargetRecords: activityTargetObjectRecords,
- recordPickerInstanceId: instanceId,
- });
- } else if (isJunctionRelation && isJunctionConfigValid) {
+ if (isJunctionRelation && isJunctionConfigValid) {
updateJunctionRelationFromCell({
morphItem,
});
diff --git a/packages/twenty-front/src/modules/object-record/record-field/ui/utils/__tests__/getJunctionConfig.test.ts b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/__tests__/getJunctionConfig.test.ts
index 5376ab7be57..88d3a86fa6c 100644
--- a/packages/twenty-front/src/modules/object-record/record-field/ui/utils/__tests__/getJunctionConfig.test.ts
+++ b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/__tests__/getJunctionConfig.test.ts
@@ -86,6 +86,72 @@ describe('getJunctionConfig', () => {
});
expect(result).toBeNull();
});
+
+ it('should infer a single morph target from the relation graph', () => {
+ const sourceField = createMockField({
+ id: 'source-field-id',
+ relation: createMockRelation('source-object-id', 'sourceObject'),
+ });
+ const morphTargetField = createMockField({
+ id: 'morph-target-field-id',
+ type: FieldMetadataType.MORPH_RELATION,
+ });
+ const labelIdentifierField = createMockField({
+ id: 'label-identifier-field-id',
+ type: FieldMetadataType.UUID,
+ });
+ const junctionObject = createMockObjectMetadata({
+ id: 'junction-id',
+ labelIdentifierFieldMetadataId: 'label-identifier-field-id',
+ fields: [sourceField, morphTargetField, labelIdentifierField],
+ });
+
+ const result = getJunctionConfig({
+ settings: undefined,
+ relationObjectMetadataId: 'junction-id',
+ relationTargetFieldMetadataId: 'source-field-id',
+ sourceObjectMetadataId: 'source-object-id',
+ objectMetadataItems: [junctionObject],
+ });
+
+ expect(result).toMatchObject({
+ sourceField: { id: 'source-field-id' },
+ targetFields: [{ id: 'morph-target-field-id' }],
+ isMorphRelation: true,
+ });
+ });
+
+ it('should not infer an ambiguous morph target', () => {
+ const sourceField = createMockField({
+ id: 'source-field-id',
+ relation: createMockRelation('source-object-id', 'sourceObject'),
+ });
+ const createMorphTargetField = (id: string) =>
+ createMockField({ id, type: FieldMetadataType.MORPH_RELATION });
+ const junctionObject = createMockObjectMetadata({
+ id: 'junction-id',
+ labelIdentifierFieldMetadataId: 'label-identifier-field-id',
+ fields: [
+ sourceField,
+ createMorphTargetField('first-morph-target-id'),
+ createMorphTargetField('second-morph-target-id'),
+ createMockField({
+ id: 'label-identifier-field-id',
+ type: FieldMetadataType.UUID,
+ }),
+ ],
+ });
+
+ expect(
+ getJunctionConfig({
+ settings: undefined,
+ relationObjectMetadataId: 'junction-id',
+ relationTargetFieldMetadataId: 'source-field-id',
+ sourceObjectMetadataId: 'source-object-id',
+ objectMetadataItems: [junctionObject],
+ }),
+ ).toBeNull();
+ });
});
describe('junctionTargetFieldId configuration', () => {
diff --git a/packages/twenty-front/src/modules/object-record/record-field/ui/utils/__tests__/isJunctionRelation.test.ts b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/__tests__/isJunctionRelation.test.ts
deleted file mode 100644
index 1b3f79f09de..00000000000
--- a/packages/twenty-front/src/modules/object-record/record-field/ui/utils/__tests__/isJunctionRelation.test.ts
+++ /dev/null
@@ -1,85 +0,0 @@
-import { hasJunctionConfig } from '@/object-record/record-field/ui/utils/junction/hasJunctionConfig';
-import { hasJunctionTargetFieldId } from '@/object-record/record-field/ui/utils/junction/hasJunctionTargetFieldId';
-import { isJunctionRelationField } from '@/object-record/record-field/ui/utils/junction/isJunctionRelationField';
-import { FieldMetadataType } from 'twenty-shared/types';
-
-describe('isJunctionRelation', () => {
- describe('hasJunctionTargetFieldId', () => {
- it.each([
- { settings: undefined, expected: false, desc: 'undefined' },
- { settings: null, expected: false, desc: 'null' },
- { settings: {}, expected: false, desc: 'empty object' },
- {
- settings: { junctionTargetFieldId: '' },
- expected: false,
- desc: 'empty string',
- },
- {
- settings: { junctionTargetFieldId: 'field-id' },
- expected: true,
- desc: 'valid value',
- },
- ])('returns $expected for $desc', ({ settings, expected }) => {
- expect(hasJunctionTargetFieldId(settings)).toBe(expected);
- });
-
- it('narrows type correctly', () => {
- const settings = { junctionTargetFieldId: 'field-id-1' };
- if (hasJunctionTargetFieldId(settings)) {
- expect(settings.junctionTargetFieldId).toBe('field-id-1');
- }
- });
- });
-
- describe('hasJunctionConfig', () => {
- it.each([
- { settings: undefined, expected: false, desc: 'undefined' },
- { settings: {}, expected: false, desc: 'empty object' },
- {
- settings: { junctionTargetFieldId: 'field-id' },
- expected: true,
- desc: 'fieldId set',
- },
- {
- settings: { junctionTargetFieldId: '' },
- expected: false,
- desc: 'empty fieldId',
- },
- ])('returns $expected for $desc', ({ settings, expected }) => {
- expect(hasJunctionConfig(settings)).toBe(expected);
- });
- });
-
- describe('isJunctionRelationField', () => {
- it.each([
- {
- field: { type: FieldMetadataType.TEXT, settings: null },
- expected: false,
- desc: 'non-relation field',
- },
- {
- field: { type: FieldMetadataType.RELATION, settings: null },
- expected: false,
- desc: 'relation without junction config',
- },
- {
- field: {
- type: FieldMetadataType.RELATION,
- settings: { junctionTargetFieldId: 'field-id' },
- },
- expected: true,
- desc: 'relation with junction config',
- },
- {
- field: {
- type: FieldMetadataType.MORPH_RELATION,
- settings: { junctionTargetFieldId: 'field-id' },
- },
- expected: false,
- desc: 'morph relation (not supported)',
- },
- ])('returns $expected for $desc', ({ field, expected }) => {
- expect(isJunctionRelationField(field)).toBe(expected);
- });
- });
-});
diff --git a/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/__tests__/getJunctionRecordsFromRecord.test.ts b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/__tests__/getJunctionRecordsFromRecord.test.ts
new file mode 100644
index 00000000000..54412e9eac5
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/__tests__/getJunctionRecordsFromRecord.test.ts
@@ -0,0 +1,29 @@
+import { getJunctionRecordsFromRecord } from '@/object-record/record-field/ui/utils/junction/getJunctionRecordsFromRecord';
+
+describe('getJunctionRecordsFromRecord', () => {
+ it('reads junction records from a runtime-named field', () => {
+ expect(
+ getJunctionRecordsFromRecord({
+ record: {
+ customTargets: [{ id: 'target-1' }, null, { invalid: true }],
+ },
+ junctionFieldName: 'customTargets',
+ }),
+ ).toEqual([{ id: 'target-1' }]);
+ });
+
+ it('returns an empty array for missing and non-array fields', () => {
+ expect(
+ getJunctionRecordsFromRecord({
+ record: undefined,
+ junctionFieldName: 'targets',
+ }),
+ ).toEqual([]);
+ expect(
+ getJunctionRecordsFromRecord({
+ record: { targets: null },
+ junctionFieldName: 'targets',
+ }),
+ ).toEqual([]);
+ });
+});
diff --git a/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/__tests__/getObjectMorphJunctionConfig.test.ts b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/__tests__/getObjectMorphJunctionConfig.test.ts
new file mode 100644
index 00000000000..0872e8308dd
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/__tests__/getObjectMorphJunctionConfig.test.ts
@@ -0,0 +1,122 @@
+import { getObjectMorphJunctionConfig } from '@/object-record/record-field/ui/utils/junction/getObjectMorphJunctionConfig';
+import { getMockFieldMetadataItemOrThrow } from '~/testing/utils/getMockFieldMetadataItemOrThrow';
+import { getMockObjectMetadataItemOrThrow } from '~/testing/utils/getMockObjectMetadataItemOrThrow';
+import { getTestEnrichedObjectMetadataItemsMock } from '~/testing/utils/getTestEnrichedObjectMetadataItemsMock';
+
+describe('getObjectMorphJunctionConfig', () => {
+ const objectMetadataItems = getTestEnrichedObjectMetadataItemsMock();
+
+ it.each([
+ {
+ objectNameSingular: 'note',
+ junctionFieldName: 'noteTargets',
+ junctionObjectNameSingular: 'noteTarget',
+ sourceFieldName: 'note',
+ sourceJoinColumnName: 'noteId',
+ },
+ {
+ objectNameSingular: 'task',
+ junctionFieldName: 'taskTargets',
+ junctionObjectNameSingular: 'taskTarget',
+ sourceFieldName: 'task',
+ sourceJoinColumnName: 'taskId',
+ },
+ ])(
+ 'resolves the morph junction of $objectNameSingular',
+ ({
+ objectNameSingular,
+ junctionFieldName,
+ junctionObjectNameSingular,
+ sourceFieldName,
+ sourceJoinColumnName,
+ }) => {
+ const result = getObjectMorphJunctionConfig({
+ objectMetadata: getMockObjectMetadataItemOrThrow(objectNameSingular),
+ objectMetadataItems,
+ });
+
+ expect(result).toMatchObject({
+ junctionObjectMetadata: { nameSingular: junctionObjectNameSingular },
+ junctionField: { name: junctionFieldName },
+ sourceField: { name: sourceFieldName },
+ sourceJoinColumnName,
+ isMorphRelation: true,
+ });
+ },
+ );
+
+ it('returns null for an object that reaches no junction', () => {
+ expect(
+ getObjectMorphJunctionConfig({
+ objectMetadata: getMockObjectMetadataItemOrThrow('noteTarget'),
+ objectMetadataItems,
+ }),
+ ).toBeNull();
+ });
+
+ it('returns null for an object whose junctions all target a single object', () => {
+ expect(
+ getObjectMorphJunctionConfig({
+ objectMetadata: getMockObjectMetadataItemOrThrow('person'),
+ objectMetadataItems,
+ }),
+ ).toBeNull();
+ });
+
+ it('infers an unambiguous morph junction without junction settings', () => {
+ const taskObjectMetadata = getMockObjectMetadataItemOrThrow('task');
+ const objectMetadataWithoutJunctionSettings = {
+ ...taskObjectMetadata,
+ fields: taskObjectMetadata.fields.map((field) =>
+ field.name === 'taskTargets'
+ ? { ...field, settings: undefined }
+ : field,
+ ),
+ };
+
+ expect(
+ getObjectMorphJunctionConfig({
+ objectMetadata: objectMetadataWithoutJunctionSettings,
+ objectMetadataItems,
+ }),
+ ).toMatchObject({
+ junctionObjectMetadata: { nameSingular: 'taskTarget' },
+ junctionField: { name: 'taskTargets' },
+ sourceField: { name: 'task' },
+ sourceJoinColumnName: 'taskId',
+ isMorphRelation: true,
+ });
+ });
+
+ it('does not guess between unconfigured morph junctions', () => {
+ const taskObjectMetadata = getMockObjectMetadataItemOrThrow('task');
+ const taskTargetsField = getMockFieldMetadataItemOrThrow({
+ objectMetadataItem: taskObjectMetadata,
+ fieldName: 'taskTargets',
+ });
+
+ const unconfiguredTaskTargetsField = {
+ ...taskTargetsField,
+ settings: undefined,
+ };
+
+ expect(
+ getObjectMorphJunctionConfig({
+ objectMetadata: {
+ ...taskObjectMetadata,
+ fields: [
+ ...taskObjectMetadata.fields.filter(
+ ({ name }) => name !== 'taskTargets',
+ ),
+ unconfiguredTaskTargetsField,
+ {
+ ...unconfiguredTaskTargetsField,
+ id: 'another-junction-field-id',
+ },
+ ],
+ },
+ objectMetadataItems,
+ }),
+ ).toBeNull();
+ });
+});
diff --git a/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/__tests__/getRelatedRecordFromJunction.test.ts b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/__tests__/getRelatedRecordFromJunction.test.ts
new file mode 100644
index 00000000000..628b95c34be
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/__tests__/getRelatedRecordFromJunction.test.ts
@@ -0,0 +1,52 @@
+import { getRelatedRecordFromJunction } from '@/object-record/record-field/ui/utils/junction/getRelatedRecordFromJunction';
+import { getRelatedRecordIdFromJunction } from '@/object-record/record-field/ui/utils/junction/getRelatedRecordIdFromJunction';
+
+describe('junction related record accessors', () => {
+ it('reads a related record from a runtime-named relation', () => {
+ expect(
+ getRelatedRecordFromJunction({
+ junctionRecord: { task: { id: 'task-1', title: 'Follow up' } },
+ relationFieldName: 'task',
+ }),
+ ).toEqual({ id: 'task-1', title: 'Follow up' });
+ });
+
+ it('prefers the join column when the nested record is absent or stale', () => {
+ expect(
+ getRelatedRecordIdFromJunction({
+ junctionRecord: {
+ taskId: 'task-from-join-column',
+ task: { id: 'task-from-nested-record' },
+ },
+ relationFieldName: 'task',
+ joinColumnName: 'taskId',
+ }),
+ ).toBe('task-from-join-column');
+ });
+
+ it('falls back to the nested related record id', () => {
+ expect(
+ getRelatedRecordIdFromJunction({
+ junctionRecord: { task: { id: 'task-2' } },
+ relationFieldName: 'task',
+ joinColumnName: 'taskId',
+ }),
+ ).toBe('task-2');
+ });
+
+ it('returns undefined for malformed junction records', () => {
+ expect(
+ getRelatedRecordFromJunction({
+ junctionRecord: { task: 'task-1' },
+ relationFieldName: 'task',
+ }),
+ ).toBeUndefined();
+ expect(
+ getRelatedRecordIdFromJunction({
+ junctionRecord: {},
+ relationFieldName: 'task',
+ joinColumnName: 'taskId',
+ }),
+ ).toBeUndefined();
+ });
+});
diff --git a/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/__tests__/getReverseJunctionConfig.test.ts b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/__tests__/getReverseJunctionConfig.test.ts
new file mode 100644
index 00000000000..ff3960a8bf2
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/__tests__/getReverseJunctionConfig.test.ts
@@ -0,0 +1,80 @@
+import { generateDepthRecordGqlFieldsFromFields } from '@/object-record/graphql/record-gql-fields/utils/generateDepthRecordGqlFieldsFromFields';
+import { getReverseJunctionConfig } from '@/object-record/record-field/ui/utils/junction/getReverseJunctionConfig';
+import { getTestEnrichedObjectMetadataItemsMock } from '~/testing/utils/getTestEnrichedObjectMetadataItemsMock';
+import { getMockFieldMetadataItemOrThrow } from '~/testing/utils/getMockFieldMetadataItemOrThrow';
+import { getMockObjectMetadataItemOrThrow } from '~/testing/utils/getMockObjectMetadataItemOrThrow';
+
+describe('getReverseJunctionConfig', () => {
+ const objectMetadataItems = getTestEnrichedObjectMetadataItemsMock();
+ const companyMetadata = getMockObjectMetadataItemOrThrow('company');
+ const noteTargetMetadata = getMockObjectMetadataItemOrThrow('noteTarget');
+ const taskTargetMetadata = getMockObjectMetadataItemOrThrow('taskTarget');
+
+ it.each([
+ {
+ junctionObjectMetadataId: noteTargetMetadata.id,
+ relatedObjectNameSingular: 'note',
+ relationFieldName: 'note',
+ },
+ {
+ junctionObjectMetadataId: taskTargetMetadata.id,
+ relatedObjectNameSingular: 'task',
+ relationFieldName: 'task',
+ },
+ ])(
+ 'resolves $relatedObjectNameSingular through configured junction metadata',
+ ({
+ junctionObjectMetadataId,
+ relatedObjectNameSingular,
+ relationFieldName,
+ }) => {
+ const result = getReverseJunctionConfig({
+ junctionObjectMetadataId,
+ sourceObjectMetadataId: companyMetadata.id,
+ objectMetadataItems,
+ });
+
+ expect(result).toMatchObject({
+ junctionObjectMetadata: { id: junctionObjectMetadataId },
+ relatedObjectMetadata: {
+ nameSingular: relatedObjectNameSingular,
+ },
+ relationFieldName,
+ });
+ },
+ );
+
+ it('returns null when no configured junction targets the source object', () => {
+ expect(
+ getReverseJunctionConfig({
+ junctionObjectMetadataId: noteTargetMetadata.id,
+ sourceObjectMetadataId: 'unsupported-object-id',
+ objectMetadataItems,
+ }),
+ ).toBeNull();
+ });
+
+ it('generates reverse relation fields without activity-specific names', () => {
+ const noteTargetsField = getMockFieldMetadataItemOrThrow({
+ objectMetadataItem: companyMetadata,
+ fieldName: 'noteTargets',
+ });
+
+ const result = generateDepthRecordGqlFieldsFromFields({
+ objectMetadataItems,
+ sourceObjectMetadataItem: companyMetadata,
+ fields: [noteTargetsField],
+ depth: 1,
+ });
+
+ expect(result).toMatchObject({
+ noteTargets: {
+ id: true,
+ note: {
+ id: true,
+ title: true,
+ },
+ },
+ });
+ });
+});
diff --git a/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/__tests__/isConfiguredJunctionRelationField.test.ts b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/__tests__/isConfiguredJunctionRelationField.test.ts
new file mode 100644
index 00000000000..b8735f117bc
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/__tests__/isConfiguredJunctionRelationField.test.ts
@@ -0,0 +1,31 @@
+import { isConfiguredJunctionRelationField } from '@/object-record/record-field/ui/utils/junction/isConfiguredJunctionRelationField';
+import { FieldMetadataType } from 'twenty-shared/types';
+
+describe('isConfiguredJunctionRelationField', () => {
+ it.each([
+ {
+ field: { type: FieldMetadataType.TEXT, settings: null },
+ expected: false,
+ },
+ {
+ field: { type: FieldMetadataType.RELATION, settings: null },
+ expected: false,
+ },
+ {
+ field: {
+ type: FieldMetadataType.RELATION,
+ settings: { junctionTargetFieldId: 'field-id' },
+ },
+ expected: true,
+ },
+ {
+ field: {
+ type: FieldMetadataType.MORPH_RELATION,
+ settings: { junctionTargetFieldId: 'field-id' },
+ },
+ expected: false,
+ },
+ ])('returns $expected for $field.type', ({ field, expected }) => {
+ expect(isConfiguredJunctionRelationField(field)).toBe(expected);
+ });
+});
diff --git a/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/getJunctionConfig.ts b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/getJunctionConfig.ts
index a043d6d0ee9..c2a2639d06f 100644
--- a/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/getJunctionConfig.ts
+++ b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/getJunctionConfig.ts
@@ -24,6 +24,7 @@ export type JunctionConfig = {
type GetJunctionConfigArgs = {
settings: FieldMetadataItem['settings'] | undefined;
relationObjectMetadataId: string;
+ relationTargetFieldMetadataId?: string;
sourceObjectMetadataId?: string;
objectMetadataItems: JunctionObjectMetadataItem[];
};
@@ -31,6 +32,7 @@ type GetJunctionConfigArgs = {
export const getJunctionConfig = ({
settings,
relationObjectMetadataId,
+ relationTargetFieldMetadataId,
sourceObjectMetadataId,
objectMetadataItems,
}: GetJunctionConfigArgs): JunctionConfig | null => {
@@ -71,13 +73,37 @@ export const getJunctionConfig = ({
);
};
- if (!hasJunctionTargetFieldId(settings)) {
- return null;
- }
+ const configuredTargetField = hasJunctionTargetFieldId(settings)
+ ? junctionObjectMetadata.fields.find(
+ (field) => field.id === settings.junctionTargetFieldId,
+ )
+ : undefined;
+ const relationSourceField = isDefined(relationTargetFieldMetadataId)
+ ? junctionObjectMetadata.fields.find(
+ (field) => field.id === relationTargetFieldMetadataId,
+ )
+ : undefined;
+ const sourceField =
+ relationSourceField ?? findSourceField(configuredTargetField?.id);
- const targetField = junctionObjectMetadata.fields.find(
- (field) => field.id === settings.junctionTargetFieldId,
+ // Legacy workspaces can lack the target marker. Only infer a pure junction:
+ // an unlabeled intermediate record with exactly one morph target.
+ const inferredMorphTargetFields = isDefined(configuredTargetField)
+ ? []
+ : junctionObjectMetadata.fields.filter(
+ (field) => field.type === FieldMetadataType.MORPH_RELATION,
+ );
+ const labelIdentifierField = junctionObjectMetadata.fields.find(
+ (field) =>
+ field.id === junctionObjectMetadata.labelIdentifierFieldMetadataId,
);
+ const targetField =
+ configuredTargetField ??
+ (sourceField?.type === FieldMetadataType.RELATION &&
+ labelIdentifierField?.type === FieldMetadataType.UUID &&
+ inferredMorphTargetFields.length === 1
+ ? inferredMorphTargetFields[0]
+ : undefined);
if (!isDefined(targetField)) {
return null;
@@ -92,7 +118,7 @@ export const getJunctionConfig = ({
return {
junctionObjectMetadata,
targetFields: [targetField],
- sourceField: findSourceField(settings.junctionTargetFieldId),
+ sourceField,
isMorphRelation,
};
};
diff --git a/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/getJunctionObjectMetadataIds.ts b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/getJunctionObjectMetadataIds.ts
new file mode 100644
index 00000000000..6beb7cc4f63
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/getJunctionObjectMetadataIds.ts
@@ -0,0 +1,31 @@
+import {
+ getJunctionConfig,
+ type JunctionObjectMetadataItem,
+} from '@/object-record/record-field/ui/utils/junction/getJunctionConfig';
+import { isDefined } from 'twenty-shared/utils';
+
+// A junction object carries no marker of its own, so the relation graph is walked to
+// collect every object resolved as a junction.
+export const getJunctionObjectMetadataIds = (
+ objectMetadataItems: JunctionObjectMetadataItem[],
+): Set<string> =>
+ new Set(
+ objectMetadataItems.flatMap((objectMetadataItem) =>
+ objectMetadataItem.fields
+ .filter((field) =>
+ isDefined(
+ getJunctionConfig({
+ settings: field.settings,
+ relationObjectMetadataId:
+ field.relation?.targetObjectMetadata.id ?? '',
+ relationTargetFieldMetadataId:
+ field.relation?.targetFieldMetadata.id,
+ sourceObjectMetadataId: objectMetadataItem.id,
+ objectMetadataItems,
+ }),
+ ),
+ )
+ .map((junctionField) => junctionField.relation?.targetObjectMetadata.id)
+ .filter(isDefined),
+ ),
+ );
diff --git a/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/getJunctionRecordsFromRecord.ts b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/getJunctionRecordsFromRecord.ts
new file mode 100644
index 00000000000..9ba295ff79b
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/getJunctionRecordsFromRecord.ts
@@ -0,0 +1,15 @@
+import { isObjectWithId } from '@/object-record/record-field/ui/utils/junction/isObjectWithId';
+import { type ObjectRecord } from '@/object-record/types/ObjectRecord';
+import { safeGetNestedProperty } from 'twenty-shared/utils';
+
+export const getJunctionRecordsFromRecord = ({
+ record,
+ junctionFieldName,
+}: {
+ record: object | null | undefined;
+ junctionFieldName: string;
+}): ObjectRecord[] => {
+ const fieldValue = safeGetNestedProperty(record, junctionFieldName);
+
+ return Array.isArray(fieldValue) ? fieldValue.filter(isObjectWithId) : [];
+};
diff --git a/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/getObjectMorphJunctionConfig.ts b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/getObjectMorphJunctionConfig.ts
new file mode 100644
index 00000000000..2c583a960f8
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/getObjectMorphJunctionConfig.ts
@@ -0,0 +1,83 @@
+import { type FieldMetadataItem } from '@/object-metadata/types/FieldMetadataItem';
+import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
+import {
+ getJunctionConfig,
+ type JunctionConfig,
+} from '@/object-record/record-field/ui/utils/junction/getJunctionConfig';
+import { getSourceJoinColumnName } from '@/object-record/record-field/ui/utils/junction/getSourceJoinColumnName';
+import { isConfiguredJunctionRelationField } from '@/object-record/record-field/ui/utils/junction/isConfiguredJunctionRelationField';
+import { isDefined } from 'twenty-shared/utils';
+
+type ObjectMorphJunctionConfig = JunctionConfig & {
+ // Field on the object holding the junction records, e.g. `note.noteTargets`
+ junctionField: FieldMetadataItem;
+ // Field on the junction pointing back at the object, e.g. `noteTarget.note`
+ sourceField: FieldMetadataItem;
+ // Join column of the object on the junction, e.g. `noteTarget.noteId`
+ sourceJoinColumnName: string;
+ junctionObjectMetadata: EnrichedObjectMetadataItem;
+};
+
+export const getObjectMorphJunctionConfig = ({
+ objectMetadata,
+ objectMetadataItems,
+}: {
+ objectMetadata: EnrichedObjectMetadataItem;
+ objectMetadataItems: EnrichedObjectMetadataItem[];
+}): ObjectMorphJunctionConfig | null => {
+ const inferredJunctionConfigs: ObjectMorphJunctionConfig[] = [];
+
+ for (const junctionField of objectMetadata.fields) {
+ const junctionConfig = getJunctionConfig({
+ settings: junctionField.settings,
+ relationObjectMetadataId:
+ junctionField.relation?.targetObjectMetadata.id ?? '',
+ relationTargetFieldMetadataId:
+ junctionField.relation?.targetFieldMetadata.id,
+ sourceObjectMetadataId: objectMetadata.id,
+ objectMetadataItems,
+ });
+
+ if (
+ !junctionConfig?.isMorphRelation ||
+ !isDefined(junctionConfig.sourceField)
+ ) {
+ continue;
+ }
+
+ const junctionObjectMetadata = objectMetadataItems.find(
+ ({ id }) => id === junctionConfig.junctionObjectMetadata.id,
+ );
+ const sourceJoinColumnName = getSourceJoinColumnName({
+ sourceField: junctionConfig.sourceField,
+ sourceObjectMetadata: objectMetadata,
+ });
+
+ if (
+ !isDefined(junctionObjectMetadata) ||
+ !isDefined(sourceJoinColumnName)
+ ) {
+ continue;
+ }
+
+ const resolvedJunctionConfig = {
+ ...junctionConfig,
+ junctionObjectMetadata,
+ junctionField,
+ sourceField: junctionConfig.sourceField,
+ sourceJoinColumnName,
+ };
+
+ if (isConfiguredJunctionRelationField(junctionField)) {
+ return resolvedJunctionConfig;
+ }
+
+ inferredJunctionConfigs.push(resolvedJunctionConfig);
+ }
+
+ // Older workspaces can lack the junction target marker. The relation graph is
+ // still authoritative when it describes exactly one morph junction.
+ return inferredJunctionConfigs.length === 1
+ ? inferredJunctionConfigs[0]
+ : null;
+};
diff --git a/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/getRelatedRecordFromJunction.ts b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/getRelatedRecordFromJunction.ts
new file mode 100644
index 00000000000..6232916594b
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/getRelatedRecordFromJunction.ts
@@ -0,0 +1,18 @@
+import { isObjectWithId } from '@/object-record/record-field/ui/utils/junction/isObjectWithId';
+import { type ObjectRecord } from '@/object-record/types/ObjectRecord';
+import { safeGetNestedProperty } from 'twenty-shared/utils';
+
+export const getRelatedRecordFromJunction = ({
+ junctionRecord,
+ relationFieldName,
+}: {
+ junctionRecord: object;
+ relationFieldName: string;
+}): ObjectRecord | undefined => {
+ const relatedRecord = safeGetNestedProperty(
+ junctionRecord,
+ relationFieldName,
+ );
+
+ return isObjectWithId(relatedRecord) ? relatedRecord : undefined;
+};
diff --git a/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/getRelatedRecordIdFromJunction.ts b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/getRelatedRecordIdFromJunction.ts
new file mode 100644
index 00000000000..32662eee132
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/getRelatedRecordIdFromJunction.ts
@@ -0,0 +1,23 @@
+import { isNonEmptyString } from '@sniptt/guards';
+
+import { getRelatedRecordFromJunction } from '@/object-record/record-field/ui/utils/junction/getRelatedRecordFromJunction';
+import { safeGetNestedProperty } from 'twenty-shared/utils';
+
+export const getRelatedRecordIdFromJunction = ({
+ junctionRecord,
+ relationFieldName,
+ joinColumnName,
+}: {
+ junctionRecord: object;
+ relationFieldName: string;
+ joinColumnName: string;
+}): string | undefined => {
+ const joinColumnValue = safeGetNestedProperty(junctionRecord, joinColumnName);
+
+ return isNonEmptyString(joinColumnValue)
+ ? joinColumnValue
+ : getRelatedRecordFromJunction({
+ junctionRecord,
+ relationFieldName,
+ })?.id;
+};
diff --git a/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/getReverseJunctionConfig.ts b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/getReverseJunctionConfig.ts
new file mode 100644
index 00000000000..1e0a92064fe
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/getReverseJunctionConfig.ts
@@ -0,0 +1,74 @@
+import {
+ getJunctionConfig,
+ type JunctionObjectMetadataItem,
+} from '@/object-record/record-field/ui/utils/junction/getJunctionConfig';
+import { getTargetObjectMetadataIdsFromField } from '@/object-record/record-field/ui/utils/junction/getTargetObjectMetadataIdsFromField';
+import { isDefined } from 'twenty-shared/utils';
+
+type ReverseJunctionConfig = {
+ junctionObjectMetadata: JunctionObjectMetadataItem;
+ relatedObjectMetadata: JunctionObjectMetadataItem;
+ relationFieldName: string;
+};
+
+type GetReverseJunctionConfigArgs = {
+ junctionObjectMetadataId?: string;
+ sourceObjectMetadataId?: string;
+ objectMetadataItems: JunctionObjectMetadataItem[];
+};
+
+// Only the owning side of a junction carries the junction settings, so reaching the owner
+// from one of its targets means looking for the object whose junction field points here.
+export const getReverseJunctionConfig = ({
+ junctionObjectMetadataId,
+ sourceObjectMetadataId,
+ objectMetadataItems,
+}: GetReverseJunctionConfigArgs): ReverseJunctionConfig | null => {
+ if (
+ !isDefined(junctionObjectMetadataId) ||
+ !isDefined(sourceObjectMetadataId)
+ ) {
+ return null;
+ }
+
+ for (const relatedObjectMetadata of objectMetadataItems) {
+ for (const forwardJunctionField of relatedObjectMetadata.fields) {
+ if (
+ forwardJunctionField.relation?.targetObjectMetadata.id !==
+ junctionObjectMetadataId
+ ) {
+ continue;
+ }
+
+ const junctionConfig = getJunctionConfig({
+ settings: forwardJunctionField.settings,
+ relationObjectMetadataId: junctionObjectMetadataId,
+ relationTargetFieldMetadataId:
+ forwardJunctionField.relation?.targetFieldMetadata.id,
+ sourceObjectMetadataId: relatedObjectMetadata.id,
+ objectMetadataItems,
+ });
+
+ if (!isDefined(junctionConfig?.sourceField)) {
+ continue;
+ }
+
+ const targetsSourceObject = junctionConfig.targetFields.some(
+ (targetField) =>
+ getTargetObjectMetadataIdsFromField(targetField).includes(
+ sourceObjectMetadataId,
+ ),
+ );
+
+ if (targetsSourceObject) {
+ return {
+ junctionObjectMetadata: junctionConfig.junctionObjectMetadata,
+ relatedObjectMetadata,
+ relationFieldName: junctionConfig.sourceField.name,
+ };
+ }
+ }
+ }
+
+ return null;
+};
diff --git a/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/isJunctionRelationField.ts b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/isConfiguredJunctionRelationField.ts
similarity index 88%
rename from packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/isJunctionRelationField.ts
rename to packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/isConfiguredJunctionRelationField.ts
index 332c0f78b06..7d9065ee0ea 100644
--- a/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/isJunctionRelationField.ts
+++ b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/isConfiguredJunctionRelationField.ts
@@ -2,7 +2,7 @@ import { type FieldMetadataItem } from '@/object-metadata/types/FieldMetadataIte
import { FieldMetadataType } from 'twenty-shared/types';
import { hasJunctionConfig } from './hasJunctionConfig';
-export const isJunctionRelationField = (
+export const isConfiguredJunctionRelationField = (
fieldMetadataItem: Pick<FieldMetadataItem, 'type' | 'settings'>,
): boolean =>
fieldMetadataItem.type === FieldMetadataType.RELATION &&
diff --git a/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/isJunctionRelationForbidden.ts b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/isJunctionRelationForbidden.ts
index ec5e7852311..1685678db3a 100644
--- a/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/isJunctionRelationForbidden.ts
+++ b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/isJunctionRelationForbidden.ts
@@ -2,7 +2,6 @@ import { type FieldMetadataItem } from '@/object-metadata/types/FieldMetadataIte
import { getObjectPermissionsForObject } from '@/object-metadata/utils/getObjectPermissionsForObject';
import { getJunctionConfig } from '@/object-record/record-field/ui/utils/junction/getJunctionConfig';
import { getTargetObjectMetadataIdsFromField } from '@/object-record/record-field/ui/utils/junction/getTargetObjectMetadataIdsFromField';
-import { hasJunctionConfig } from '@/object-record/record-field/ui/utils/junction/hasJunctionConfig';
import { type ObjectPermissions } from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
@@ -26,10 +25,6 @@ export const isJunctionRelationForbidden = ({
objectMetadataItems: JunctionObjectMetadataItem[];
objectPermissionsByObjectMetadataId: ObjectPermissionsByObjectMetadataId;
}): boolean => {
- if (!hasJunctionConfig(fieldMetadataItem.settings)) {
- return false;
- }
-
const junctionObjectMetadataId =
fieldMetadataItem.relation?.targetObjectMetadata.id;
@@ -37,18 +32,11 @@ export const isJunctionRelationForbidden = ({
return false;
}
- const junctionPermissions = getObjectPermissionsForObject(
- objectPermissionsByObjectMetadataId,
- junctionObjectMetadataId,
- );
-
- if (!junctionPermissions.canReadObjectRecords) {
- return true;
- }
-
const junctionConfig = getJunctionConfig({
settings: fieldMetadataItem.settings,
relationObjectMetadataId: junctionObjectMetadataId,
+ relationTargetFieldMetadataId:
+ fieldMetadataItem.relation?.targetFieldMetadata.id,
sourceObjectMetadataId,
objectMetadataItems,
});
@@ -57,6 +45,15 @@ export const isJunctionRelationForbidden = ({
return false;
}
+ const junctionPermissions = getObjectPermissionsForObject(
+ objectPermissionsByObjectMetadataId,
+ junctionObjectMetadataId,
+ );
+
+ if (!junctionPermissions.canReadObjectRecords) {
+ return true;
+ }
+
const targetObjectMetadataIds = junctionConfig.targetFields.flatMap(
getTargetObjectMetadataIdsFromField,
);
diff --git a/packages/twenty-front/src/modules/object-record/record-show/graphql/operations/factories/findOneRecordForShowPageOperationSignatureFactory.ts b/packages/twenty-front/src/modules/object-record/record-show/graphql/operations/factories/findOneRecordForShowPageOperationSignatureFactory.ts
index c66ef4c1a53..debe7c9041e 100644
--- a/packages/twenty-front/src/modules/object-record/record-show/graphql/operations/factories/findOneRecordForShowPageOperationSignatureFactory.ts
+++ b/packages/twenty-front/src/modules/object-record/record-show/graphql/operations/factories/findOneRecordForShowPageOperationSignatureFactory.ts
@@ -1,6 +1,4 @@
-import { CoreObjectNameSingular } from 'twenty-shared/types';
import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
-import { generateActivityTargetGqlFields } from '@/object-record/graphql/record-gql-fields/utils/generateActivityTargetGqlFields';
import { generateDepthRecordGqlFieldsFromObject } from '@/object-record/graphql/record-gql-fields/utils/generateDepthRecordGqlFieldsFromObject';
import { type RecordGqlOperationSignatureFactory } from '@/object-record/graphql/types/RecordGqlOperationSignatureFactory';
@@ -26,15 +24,5 @@ export const buildFindOneRecordForShowPageOperationSignature: RecordGqlOperation
objectMetadataItems,
depth: 1,
}),
- noteTargets: generateActivityTargetGqlFields({
- activityObjectNameSingular: CoreObjectNameSingular.Note,
- loadRelations: 'both',
- objectMetadataItems,
- }),
- taskTargets: generateActivityTargetGqlFields({
- activityObjectNameSingular: CoreObjectNameSingular.Task,
- loadRelations: 'both',
- objectMetadataItems,
- }),
},
});
diff --git a/packages/twenty-front/src/modules/object-record/record-table/record-table-cell/components/RecordTableCellFieldContextGeneric.tsx b/packages/twenty-front/src/modules/object-record/record-table/record-table-cell/components/RecordTableCellFieldContextGeneric.tsx
index 8587d851037..1a51efebcac 100644
--- a/packages/twenty-front/src/modules/object-record/record-table/record-table-cell/components/RecordTableCellFieldContextGeneric.tsx
+++ b/packages/twenty-front/src/modules/object-record/record-table/record-table-cell/components/RecordTableCellFieldContextGeneric.tsx
@@ -8,7 +8,6 @@ import { isFieldRelationManyToOne } from '@/object-record/record-field/ui/types/
import { isFieldRelationOneToMany } from '@/object-record/record-field/ui/types/guards/isFieldRelationOneToMany';
import { getJunctionConfig } from '@/object-record/record-field/ui/utils/junction/getJunctionConfig';
import { getTargetObjectMetadataIdsFromField } from '@/object-record/record-field/ui/utils/junction/getTargetObjectMetadataIdsFromField';
-import { hasJunctionConfig } from '@/object-record/record-field/ui/utils/junction/hasJunctionConfig';
import { useRecordIndexContextOrThrow } from '@/object-record/record-index/contexts/RecordIndexContext';
import { useRecordTableContextOrThrow } from '@/object-record/record-table/contexts/RecordTableContext';
import { useRecordTableRowContextOrThrow } from '@/object-record/record-table/contexts/RecordTableRowContext';
@@ -64,13 +63,12 @@ export const RecordTableCellFieldContextGeneric = ({
hasObjectReadPermissions = relationObjectPermissions.canReadObjectRecords;
- if (
- hasObjectReadPermissions &&
- hasJunctionConfig(fieldDefinition.metadata.settings)
- ) {
+ if (hasObjectReadPermissions) {
const junctionConfig = getJunctionConfig({
settings: fieldDefinition.metadata.settings,
relationObjectMetadataId,
+ relationTargetFieldMetadataId:
+ fieldDefinition.metadata.relationFieldMetadataId,
sourceObjectMetadataId: objectMetadataItem.id,
objectMetadataItems,
});
diff --git a/packages/twenty-front/src/modules/object-record/utils/isFieldCellSupported.ts b/packages/twenty-front/src/modules/object-record/utils/isFieldCellSupported.ts
index b258f1bbf8c..a9efa4b8bc3 100644
--- a/packages/twenty-front/src/modules/object-record/utils/isFieldCellSupported.ts
+++ b/packages/twenty-front/src/modules/object-record/utils/isFieldCellSupported.ts
@@ -1,8 +1,9 @@
-import { CoreObjectNameSingular } from 'twenty-shared/types';
import { type FieldMetadataItem } from '@/object-metadata/types/FieldMetadataItem';
import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
import { isHiddenSystemField } from '@/object-metadata/utils/isHiddenSystemField';
import { isObjectMetadataAvailableForRelation } from '@/object-metadata/utils/isObjectMetadataAvailableForRelation';
+import { getJunctionConfig } from '@/object-record/record-field/ui/utils/junction/getJunctionConfig';
+import { isDefined } from 'twenty-shared/utils';
import { FieldMetadataType } from '~/generated-metadata/graphql';
type IsFieldCellSupportedOptions = {
@@ -26,22 +27,19 @@ export const isFieldCellSupported = (
(item) => item.id === relationObjectMetadataItemId,
);
- // Hack to display targets on Notes and Tasks
- if (
- fieldMetadataItem.relation?.targetObjectMetadata?.nameSingular ===
- CoreObjectNameSingular.NoteTarget &&
- fieldMetadataItem.relation?.sourceObjectMetadata.nameSingular ===
- CoreObjectNameSingular.Note
- ) {
- return true;
- }
-
- if (
- fieldMetadataItem.relation?.targetObjectMetadata?.nameSingular ===
- CoreObjectNameSingular.TaskTarget &&
- fieldMetadataItem.relation?.sourceObjectMetadata.nameSingular ===
- CoreObjectNameSingular.Task
- ) {
+ // A junction object is a system object on purpose, so the relation holding its records
+ // is still cell-supported even though relations to system objects are not.
+ const junctionConfig = getJunctionConfig({
+ settings: fieldMetadataItem.settings,
+ relationObjectMetadataId: relationObjectMetadataItemId ?? '',
+ relationTargetFieldMetadataId:
+ fieldMetadataItem.relation?.targetFieldMetadata.id,
+ sourceObjectMetadataId:
+ fieldMetadataItem.relation?.sourceObjectMetadata.id,
+ objectMetadataItems,
+ });
+
+ if (isDefined(junctionConfig)) {
return true;
}
diff --git a/packages/twenty-front/src/modules/object-record/utils/isPlainManyToOneRelationField.ts b/packages/twenty-front/src/modules/object-record/utils/isPlainManyToOneRelationField.ts
index 604d7b2f846..e563a61387d 100644
--- a/packages/twenty-front/src/modules/object-record/utils/isPlainManyToOneRelationField.ts
+++ b/packages/twenty-front/src/modules/object-record/utils/isPlainManyToOneRelationField.ts
@@ -1,6 +1,6 @@
import { type FieldMetadataItem } from '@/object-metadata/types/FieldMetadataItem';
import { isManyToOneRelationField } from '@/object-metadata/utils/isManyToOneRelationField';
-import { isJunctionRelationField } from '@/object-record/record-field/ui/utils/junction/isJunctionRelationField';
+import { isConfiguredJunctionRelationField } from '@/object-record/record-field/ui/utils/junction/isConfiguredJunctionRelationField';
// Junction relation fields also carry MANY_TO_ONE metadata but render through
// a dedicated junction path, mirroring isPlainOneToManyRelationField.
@@ -10,4 +10,4 @@ export const isPlainManyToOneRelationField = (
relation: NonNullable<FieldMetadataItem['relation']>;
} =>
isManyToOneRelationField(fieldMetadataItem) &&
- !isJunctionRelationField(fieldMetadataItem);
+ !isConfiguredJunctionRelationField(fieldMetadataItem);
diff --git a/packages/twenty-front/src/modules/object-record/utils/isPlainOneToManyRelationField.ts b/packages/twenty-front/src/modules/object-record/utils/isPlainOneToManyRelationField.ts
index 4fb3dbdf600..2d7293d60b4 100644
--- a/packages/twenty-front/src/modules/object-record/utils/isPlainOneToManyRelationField.ts
+++ b/packages/twenty-front/src/modules/object-record/utils/isPlainOneToManyRelationField.ts
@@ -1,6 +1,6 @@
import { type FieldMetadataItem } from '@/object-metadata/types/FieldMetadataItem';
import { isOneToManyRelationField } from '@/object-metadata/utils/isOneToManyRelationField';
-import { isJunctionRelationField } from '@/object-record/record-field/ui/utils/junction/isJunctionRelationField';
+import { isConfiguredJunctionRelationField } from '@/object-record/record-field/ui/utils/junction/isConfiguredJunctionRelationField';
// Junction relation fields also carry ONE_TO_MANY metadata but render through
// a dedicated junction path, mirroring the backend's
@@ -11,4 +11,4 @@ export const isPlainOneToManyRelationField = (
relation: NonNullable<FieldMetadataItem['relation']>;
} =>
isOneToManyRelationField(fieldMetadataItem) &&
- !isJunctionRelationField(fieldMetadataItem);
+ !isConfiguredJunctionRelationField(fieldMetadataItem);
diff --git a/packages/twenty-front/src/modules/page-layout/widgets/field/components/FieldWidget.tsx b/packages/twenty-front/src/modules/page-layout/widgets/field/components/FieldWidget.tsx
index f3a5c52bf29..efc9328b949 100644
--- a/packages/twenty-front/src/modules/page-layout/widgets/field/components/FieldWidget.tsx
+++ b/packages/twenty-front/src/modules/page-layout/widgets/field/components/FieldWidget.tsx
@@ -1,11 +1,12 @@
import { useFieldMetadataItemById } from '@/object-metadata/hooks/useFieldMetadataItemById';
import { useObjectMetadataItem } from '@/object-metadata/hooks/useObjectMetadataItem';
+import { useObjectMetadataItems } from '@/object-metadata/hooks/useObjectMetadataItems';
import { formatFieldMetadataItemAsColumnDefinition } from '@/object-metadata/utils/formatFieldMetadataItemAsColumnDefinition';
import { isFieldMorphRelation } from '@/object-record/record-field/ui/types/guards/isFieldMorphRelation';
import { isFieldRelation } from '@/object-record/record-field/ui/types/guards/isFieldRelation';
import { isFieldRichText } from '@/object-record/record-field/ui/types/guards/isFieldRichText';
import { isFieldText } from '@/object-record/record-field/ui/types/guards/isFieldText';
-import { hasJunctionConfig } from '@/object-record/record-field/ui/utils/junction/hasJunctionConfig';
+import { getJunctionConfig } from '@/object-record/record-field/ui/utils/junction/getJunctionConfig';
import { recordStoreFamilySelector } from '@/object-record/record-store/states/selectors/recordStoreFamilySelector';
import { useResolveFieldMetadataIdFromNameOrId } from '@/page-layout/hooks/useResolveFieldMetadataIdFromNameOrId';
import { type PageLayoutWidget } from '@/page-layout/types/PageLayoutWidget';
@@ -55,6 +56,7 @@ export const FieldWidget = ({ widget }: FieldWidgetProps) => {
const { objectMetadataItem } = useObjectMetadataItem({
objectNameSingular: targetRecord.targetObjectNameSingular,
});
+ const { objectMetadataItems } = useObjectMetadataItems();
const fieldMetadataId = widget.configuration.fieldMetadataId;
@@ -123,8 +125,16 @@ export const FieldWidget = ({ widget }: FieldWidgetProps) => {
}
if (isFieldRelation(fieldDefinition)) {
- const isJunctionRelation = hasJunctionConfig(
- fieldDefinition.metadata.settings,
+ const isJunctionRelation = isDefined(
+ getJunctionConfig({
+ settings: fieldDefinition.metadata.settings,
+ relationObjectMetadataId:
+ fieldDefinition.metadata.relationObjectMetadataId,
+ relationTargetFieldMetadataId:
+ fieldDefinition.metadata.relationFieldMetadataId,
+ sourceObjectMetadataId: objectMetadataItem.id,
+ objectMetadataItems,
+ }),
);
if (isJunctionRelation) {
diff --git a/packages/twenty-front/src/modules/page-layout/widgets/field/components/FieldWidgetJunctionRelationCard.tsx b/packages/twenty-front/src/modules/page-layout/widgets/field/components/FieldWidgetJunctionRelationCard.tsx
index 90d5e352489..4f33584a04a 100644
--- a/packages/twenty-front/src/modules/page-layout/widgets/field/components/FieldWidgetJunctionRelationCard.tsx
+++ b/packages/twenty-front/src/modules/page-layout/widgets/field/components/FieldWidgetJunctionRelationCard.tsx
@@ -116,6 +116,7 @@ export const FieldWidgetJunctionRelationCard = ({
const junctionConfig = getJunctionConfig({
settings: fieldMetadata.settings,
relationObjectMetadataId: fieldMetadata.relationObjectMetadataId,
+ relationTargetFieldMetadataId: fieldMetadata.relationFieldMetadataId,
sourceObjectMetadataId,
objectMetadataItems,
});
diff --git a/packages/twenty-front/src/modules/page-layout/widgets/field/components/FieldWidgetJunctionRelationField.tsx b/packages/twenty-front/src/modules/page-layout/widgets/field/components/FieldWidgetJunctionRelationField.tsx
index 09db6ed9b51..152ee4ff893 100644
--- a/packages/twenty-front/src/modules/page-layout/widgets/field/components/FieldWidgetJunctionRelationField.tsx
+++ b/packages/twenty-front/src/modules/page-layout/widgets/field/components/FieldWidgetJunctionRelationField.tsx
@@ -41,6 +41,7 @@ export const FieldWidgetJunctionRelationField = ({
const junctionConfig = getJunctionConfig({
settings: fieldMetadata.settings,
relationObjectMetadataId: fieldMetadata.relationObjectMetadataId,
+ relationTargetFieldMetadataId: fieldMetadata.relationFieldMetadataId,
sourceObjectMetadataId,
objectMetadataItems,
});
diff --git a/packages/twenty-front/src/modules/page-layout/widgets/field/hooks/useFieldWidgetActionVisibility.ts b/packages/twenty-front/src/modules/page-layout/widgets/field/hooks/useFieldWidgetActionVisibility.ts
index 4a50ee0cf13..1f4797bf554 100644
--- a/packages/twenty-front/src/modules/page-layout/widgets/field/hooks/useFieldWidgetActionVisibility.ts
+++ b/packages/twenty-front/src/modules/page-layout/widgets/field/hooks/useFieldWidgetActionVisibility.ts
@@ -1,9 +1,10 @@
import { useGetIsMetadataItemFromStandardApplication } from '@/object-metadata/hooks/useGetIsMetadataItemFromStandardApplication';
+import { useObjectMetadataItems } from '@/object-metadata/hooks/useObjectMetadataItems';
import { useObjectPermissions } from '@/object-record/hooks/useObjectPermissions';
import { useIsRecordReadOnly } from '@/object-record/read-only/hooks/useIsRecordReadOnly';
import { isRecordFieldReadOnly } from '@/object-record/read-only/utils/isRecordFieldReadOnly';
import { isFieldRelation } from '@/object-record/record-field/ui/types/guards/isFieldRelation';
-import { hasJunctionConfig } from '@/object-record/record-field/ui/utils/junction/hasJunctionConfig';
+import { getJunctionConfig } from '@/object-record/record-field/ui/utils/junction/getJunctionConfig';
import { useIsPageLayoutInEditMode } from '@/page-layout/hooks/useIsPageLayoutInEditMode';
import { type PageLayoutWidget } from '@/page-layout/types/PageLayoutWidget';
import { useFieldWidgetFieldDefinition } from '@/page-layout/widgets/field/hooks/useFieldWidgetFieldDefinition';
@@ -27,6 +28,7 @@ export const useFieldWidgetActionVisibility = ({
useFieldWidgetFieldDefinition(widget);
const { objectPermissionsByObjectMetadataId } = useObjectPermissions();
+ const { objectMetadataItems } = useObjectMetadataItems();
const getIsMetadataItemFromStandardApplication =
useGetIsMetadataItemFromStandardApplication();
@@ -58,7 +60,18 @@ export const useFieldWidgetActionVisibility = ({
widget.configuration.nestedRelationFieldMetadataId,
);
- const isJunctionRelation = hasJunctionConfig(relationMetadata?.settings);
+ const isJunctionRelation = isDefined(
+ isDefined(relationMetadata)
+ ? getJunctionConfig({
+ settings: relationMetadata.settings,
+ relationObjectMetadataId: relationMetadata.relationObjectMetadataId,
+ relationTargetFieldMetadataId:
+ relationMetadata.relationFieldMetadataId,
+ sourceObjectMetadataId: objectMetadataItem.id,
+ objectMetadataItems,
+ })
+ : null,
+ );
const showSeeAll =
isOneToManyRelation && !isNestedRelationWidget && !isJunctionRelation;
diff --git a/packages/twenty-front/src/modules/page-layout/widgets/field/hooks/useFieldWidgetEligibleFields.ts b/packages/twenty-front/src/modules/page-layout/widgets/field/hooks/useFieldWidgetEligibleFields.ts
index 282bd83554c..4cca746a68b 100644
--- a/packages/twenty-front/src/modules/page-layout/widgets/field/hooks/useFieldWidgetEligibleFields.ts
+++ b/packages/twenty-front/src/modules/page-layout/widgets/field/hooks/useFieldWidgetEligibleFields.ts
@@ -1,5 +1,4 @@
import { useFieldListFieldMetadataItems } from '@/object-record/record-field-list/hooks/useFieldListFieldMetadataItems';
-import { isJunctionRelationField } from '@/object-record/record-field/ui/utils/junction/isJunctionRelationField';
import { useMemo } from 'react';
export const useFieldWidgetEligibleFields = (objectNameSingular: string) => {
@@ -15,8 +14,11 @@ export const useFieldWidgetEligibleFields = (objectNameSingular: string) => {
});
return useMemo(() => {
+ const junctionFieldIds = new Set(
+ junctionRelationFieldMetadataItems.map(({ id }) => id),
+ );
const eligibleInlineFields = inlineFieldMetadataItems.filter(
- (field) => !isJunctionRelationField(field),
+ ({ id }) => !junctionFieldIds.has(id),
);
return [
diff --git a/packages/twenty-front/src/modules/page-layout/widgets/field/hooks/useOpenFieldWidgetFieldInputEditMode.ts b/packages/twenty-front/src/modules/page-layout/widgets/field/hooks/useOpenFieldWidgetFieldInputEditMode.ts
index 638d049745f..7e6632a5843 100644
--- a/packages/twenty-front/src/modules/page-layout/widgets/field/hooks/useOpenFieldWidgetFieldInputEditMode.ts
+++ b/packages/twenty-front/src/modules/page-layout/widgets/field/hooks/useOpenFieldWidgetFieldInputEditMode.ts
@@ -1,38 +1,27 @@
-import { useOpenActivityTargetCellEditMode } from '@/activities/inline-cell/hooks/useOpenActivityTargetCellEditMode';
-import { type Note } from '@/activities/types/Note';
-import { type NoteTarget } from '@/activities/types/NoteTarget';
-import { type Task } from '@/activities/types/Task';
-import { type TaskTarget } from '@/activities/types/TaskTarget';
-import { getActivityTargetObjectRecords } from '@/activities/utils/getActivityTargetObjectRecords';
-import { objectMetadataItemsSelector } from '@/object-metadata/states/objectMetadataItemsSelector';
+import { useObjectMetadataItems } from '@/object-metadata/hooks/useObjectMetadataItems';
+import { useOpenJunctionRelationFieldInput } from '@/object-record/record-field/ui/hooks/useOpenJunctionRelationFieldInput';
import { useOpenMorphRelationManyToOneFieldInput } from '@/object-record/record-field/ui/meta-types/input/hooks/useOpenMorphRelationManyToOneFieldInput';
import { useOpenMorphRelationOneToManyFieldInput } from '@/object-record/record-field/ui/meta-types/input/hooks/useOpenMorphRelationOneToManyFieldInput';
import { useOpenRelationFromManyFieldInput } from '@/object-record/record-field/ui/meta-types/input/hooks/useOpenRelationFromManyFieldInput';
import { useOpenRelationToOneFieldInput } from '@/object-record/record-field/ui/meta-types/input/hooks/useOpenRelationToOneFieldInput';
import { RecordFieldComponentInstanceContext } from '@/object-record/record-field/ui/states/contexts/RecordFieldComponentInstanceContext';
import { type FieldDefinition } from '@/object-record/record-field/ui/types/FieldDefinition';
-import {
- type FieldMetadata,
- type FieldRelationFromManyValue,
- type FieldRelationValue,
-} from '@/object-record/record-field/ui/types/FieldMetadata';
+import { type FieldMetadata } from '@/object-record/record-field/ui/types/FieldMetadata';
import { isFieldMorphRelation } from '@/object-record/record-field/ui/types/guards/isFieldMorphRelation';
import { isFieldMorphRelationManyToOne } from '@/object-record/record-field/ui/types/guards/isFieldMorphRelationManyToOne';
import { isFieldMorphRelationOneToMany } from '@/object-record/record-field/ui/types/guards/isFieldMorphRelationOneToMany';
import { isFieldRelationManyToOne } from '@/object-record/record-field/ui/types/guards/isFieldRelationManyToOne';
import { isFieldRelationOneToMany } from '@/object-record/record-field/ui/types/guards/isFieldRelationOneToMany';
-import { recordStoreFamilyState } from '@/object-record/record-store/states/recordStoreFamilyState';
-import { recordStoreFamilySelector } from '@/object-record/record-store/states/selectors/recordStoreFamilySelector';
+import { getJunctionConfig } from '@/object-record/record-field/ui/utils/junction/getJunctionConfig';
import { usePushFocusItemToFocusStack } from '@/ui/utilities/focus/hooks/usePushFocusItemToFocusStack';
import { useRemoveFocusItemFromFocusStackById } from '@/ui/utilities/focus/hooks/useRemoveFocusItemFromFocusStackById';
import { FocusComponentType } from '@/ui/utilities/focus/types/FocusComponentType';
import { useAvailableComponentInstanceIdOrThrow } from '@/ui/utilities/state/component-state/hooks/useAvailableComponentInstanceIdOrThrow';
import { useCallback } from 'react';
import { isDefined } from 'twenty-shared/utils';
-import { useStore } from 'jotai';
export const useOpenFieldWidgetFieldInputEditMode = () => {
- const store = useStore();
+ const { objectMetadataItems } = useObjectMetadataItems();
const { openRelationToOneFieldInput } = useOpenRelationToOneFieldInput();
const { openRelationFromManyFieldInput } =
useOpenRelationFromManyFieldInput();
@@ -40,8 +29,8 @@ export const useOpenFieldWidgetFieldInputEditMode = () => {
const { openMorphRelationOneToManyFieldInput } =
useOpenMorphRelationOneToManyFieldInput();
- const { openActivityTargetCellEditMode } =
- useOpenActivityTargetCellEditMode();
+ const { openJunctionRelationFieldInput } =
+ useOpenJunctionRelationFieldInput();
const { openMorphRelationManyToOneFieldInput } =
useOpenMorphRelationManyToOneFieldInput();
@@ -62,30 +51,26 @@ export const useOpenFieldWidgetFieldInputEditMode = () => {
}) => {
if (
isFieldRelationOneToMany(fieldDefinition) &&
- ['taskTarget', 'noteTarget'].includes(
- fieldDefinition.metadata.relationObjectMetadataNameSingular,
+ isDefined(
+ getJunctionConfig({
+ settings: fieldDefinition.metadata.settings,
+ relationObjectMetadataId:
+ fieldDefinition.metadata.relationObjectMetadataId,
+ relationTargetFieldMetadataId:
+ fieldDefinition.metadata.relationFieldMetadataId,
+ sourceObjectMetadataId: objectMetadataItems.find(
+ ({ nameSingular }) =>
+ nameSingular ===
+ fieldDefinition.metadata.objectMetadataNameSingular,
+ )?.id,
+ objectMetadataItems,
+ }),
)
) {
- const fieldValue = store.get(
- recordStoreFamilySelector.selectorFamily({
- recordId,
- fieldName: fieldDefinition.metadata.fieldName,
- }),
- ) as FieldRelationValue<FieldRelationFromManyValue>;
-
- const activity = store.get(recordStoreFamilyState.atomFamily(recordId));
-
- const objectMetadataItems = store.get(objectMetadataItemsSelector.atom);
-
- const activityTargetObjectRecords = getActivityTargetObjectRecords({
- activityRecord: activity as Task | Note,
- objectMetadataItems,
- activityTargets: fieldValue as NoteTarget[] | TaskTarget[],
- });
-
- openActivityTargetCellEditMode({
+ openJunctionRelationFieldInput({
+ fieldDefinition,
+ recordId,
recordPickerInstanceId: instanceId,
- activityTargetObjectRecords,
});
return;
}
@@ -149,14 +134,14 @@ export const useOpenFieldWidgetFieldInputEditMode = () => {
});
},
[
+ objectMetadataItems,
instanceId,
- openActivityTargetCellEditMode,
+ openJunctionRelationFieldInput,
openMorphRelationManyToOneFieldInput,
openMorphRelationOneToManyFieldInput,
openRelationFromManyFieldInput,
openRelationToOneFieldInput,
pushFocusItemToFocusStack,
- store,
],
);
diff --git a/packages/twenty-front/src/modules/page-layout/widgets/fields/components/FieldsWidgetFieldItem.tsx b/packages/twenty-front/src/modules/page-layout/widgets/fields/components/FieldsWidgetFieldItem.tsx
index de51bb64e2d..a5a2ce2ac63 100644
--- a/packages/twenty-front/src/modules/page-layout/widgets/fields/components/FieldsWidgetFieldItem.tsx
+++ b/packages/twenty-front/src/modules/page-layout/widgets/fields/components/FieldsWidgetFieldItem.tsx
@@ -1,10 +1,8 @@
-import { ActivityTargetsInlineCell } from '@/activities/inline-cell/components/ActivityTargetsInlineCell';
import { useGetIsMetadataItemFromStandardApplication } from '@/object-metadata/hooks/useGetIsMetadataItemFromStandardApplication';
import { type FieldMetadataItem } from '@/object-metadata/types/FieldMetadataItem';
import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
import { formatFieldMetadataItemAsColumnDefinition } from '@/object-metadata/utils/formatFieldMetadataItemAsColumnDefinition';
import { isRecordFieldReadOnly } from '@/object-record/read-only/utils/isRecordFieldReadOnly';
-import { isActivityTargetField } from '@/object-record/record-field-list/utils/categorizeRelationFields';
import {
FieldContext,
type RecordUpdateHook,
@@ -14,16 +12,12 @@ import { isJunctionRelationForbidden } from '@/object-record/record-field/ui/uti
import { RecordInlineCell } from '@/object-record/record-inline-cell/components/RecordInlineCell';
import { getRecordFieldInputInstanceId } from '@/object-record/utils/getRecordFieldInputId';
import { getObjectPermissionsFromMapByObjectMetadataId } from '@/settings/roles/role-permissions/objects-permissions/utils/getObjectPermissionsFromMapByObjectMetadataId';
-import {
- type CoreObjectNameSingular,
- type ObjectPermissions,
-} from 'twenty-shared/types';
+import { type ObjectPermissions } from 'twenty-shared/types';
type FieldsWidgetFieldItemProps = {
fieldMetadataItem: FieldMetadataItem;
globalIndex: number;
recordId: string;
- targetObjectNameSingular: string;
objectMetadataItem: EnrichedObjectMetadataItem;
objectMetadataItems: EnrichedObjectMetadataItem[];
objectPermissionsByObjectMetadataId: Record<
@@ -41,7 +35,6 @@ export const FieldsWidgetFieldItem = ({
fieldMetadataItem,
globalIndex,
recordId,
- targetObjectNameSingular,
objectMetadataItem,
objectMetadataItems,
objectPermissionsByObjectMetadataId,
@@ -54,11 +47,6 @@ export const FieldsWidgetFieldItem = ({
const getIsMetadataItemFromStandardApplication =
useGetIsMetadataItemFromStandardApplication();
- const isActivityTarget = isActivityTargetField(
- fieldMetadataItem.name,
- targetObjectNameSingular,
- );
-
const fieldDefinition = formatFieldMetadataItemAsColumnDefinition({
field: fieldMetadataItem,
position: globalIndex,
@@ -107,35 +95,17 @@ export const FieldsWidgetFieldItem = ({
}),
}}
>
- {isActivityTarget ? (
- <ActivityTargetsInlineCell
- componentInstanceId={getRecordFieldInputInstanceId({
+ <RecordFieldComponentInstanceContext.Provider
+ value={{
+ instanceId: getRecordFieldInputInstanceId({
recordId,
fieldName: fieldMetadataItem.name,
prefix: instanceId,
- })}
- activityObjectNameSingular={
- targetObjectNameSingular as
- | CoreObjectNameSingular.Note
- | CoreObjectNameSingular.Task
- }
- activityRecordId={recordId}
- showLabel={true}
- maxWidth={200}
- />
- ) : (
- <RecordFieldComponentInstanceContext.Provider
- value={{
- instanceId: getRecordFieldInputInstanceId({
- recordId,
- fieldName: fieldMetadataItem.name,
- prefix: instanceId,
- }),
- }}
- >
- <RecordInlineCell loading={recordLoading} />
- </RecordFieldComponentInstanceContext.Provider>
- )}
+ }),
+ }}
+ >
+ <RecordInlineCell loading={recordLoading} />
+ </RecordFieldComponentInstanceContext.Provider>
</FieldContext.Provider>
);
};
diff --git a/packages/twenty-front/src/modules/page-layout/widgets/fields/components/FieldsWidgetFieldList.tsx b/packages/twenty-front/src/modules/page-layout/widgets/fields/components/FieldsWidgetFieldList.tsx
index fd643b8945e..f0b70a93d7e 100644
--- a/packages/twenty-front/src/modules/page-layout/widgets/fields/components/FieldsWidgetFieldList.tsx
+++ b/packages/twenty-front/src/modules/page-layout/widgets/fields/components/FieldsWidgetFieldList.tsx
@@ -52,7 +52,6 @@ export const FieldsWidgetFieldList = ({
fieldMetadataItem={fieldMetadataItem}
globalIndex={globalIndex}
recordId={targetRecord.id}
- targetObjectNameSingular={targetRecord.targetObjectNameSingular}
objectMetadataItem={objectMetadataItem}
objectMetadataItems={objectMetadataItems}
objectPermissionsByObjectMetadataId={objectPermissionsByObjectMetadataId}
diff --git a/packages/twenty-front/src/modules/side-panel/pages/search/hooks/useSidePanelSearchRecordPreviewFields.ts b/packages/twenty-front/src/modules/side-panel/pages/search/hooks/useSidePanelSearchRecordPreviewFields.ts
index 062121fcb32..e533e451996 100644
--- a/packages/twenty-front/src/modules/side-panel/pages/search/hooks/useSidePanelSearchRecordPreviewFields.ts
+++ b/packages/twenty-front/src/modules/side-panel/pages/search/hooks/useSidePanelSearchRecordPreviewFields.ts
@@ -26,7 +26,6 @@ export const useSidePanelSearchRecordPreviewFields = (
const readableActiveFields = objectMetadataItem.readableFields.filter(
(fieldMetadata) =>
isActiveFieldMetadataItem({
- objectNameSingular: objectMetadataItem.nameSingular,
fieldMetadata,
}),
);
diff --git a/packages/twenty-front/src/pages/settings/data-model/SettingsObjectFieldEdit.tsx b/packages/twenty-front/src/pages/settings/data-model/SettingsObjectFieldEdit.tsx
index f5d5d9cd3cb..726e8b1a818 100644
--- a/packages/twenty-front/src/pages/settings/data-model/SettingsObjectFieldEdit.tsx
+++ b/packages/twenty-front/src/pages/settings/data-model/SettingsObjectFieldEdit.tsx
@@ -10,11 +10,11 @@ import { useFilteredObjectMetadataItems } from '@/object-metadata/hooks/useFilte
import { useGetIsMetadataItemCustom } from '@/object-metadata/hooks/useGetIsMetadataItemCustom';
import { useGetRelationMetadata } from '@/object-metadata/hooks/useGetRelationMetadata';
import { useUpdateOneFieldMetadataItem } from '@/object-metadata/hooks/useUpdateOneFieldMetadataItem';
-import { CoreObjectNamePlural } from '@/object-metadata/types/CoreObjectNamePlural';
import { formatFieldMetadataItemInput } from '@/object-metadata/utils/formatFieldMetadataItemInput';
import { isLabelIdentifierField } from '@/object-metadata/utils/isLabelIdentifierField';
import { isDDLLockedState } from '@/client-config/states/isDDLLockedState';
import { isObjectMetadataReadOnly } from '@/object-record/read-only/utils/isObjectMetadataReadOnly';
+import { getReverseJunctionConfig } from '@/object-record/record-field/ui/utils/junction/getReverseJunctionConfig';
import { SaveAndCancelButtons } from '@/settings/components/SaveAndCancelButtons/SaveAndCancelButtons';
import { SettingsPageContainer } from '@/settings/components/SettingsPageContainer';
import { FIELD_NAME_MAXIMUM_LENGTH } from '@/settings/data-model/constants/FieldNameMaximumLength';
@@ -79,7 +79,7 @@ export const SettingsObjectFieldEdit = () => {
const { objectNamePlural = '', fieldName = '' } = useParams();
- const { findObjectMetadataItemByNamePlural } =
+ const { findObjectMetadataItemByNamePlural, objectMetadataItems } =
useFilteredObjectMetadataItems();
const objectMetadataItem =
@@ -109,6 +109,15 @@ export const SettingsObjectFieldEdit = () => {
fieldMetadataItem.name === newNameDuringSave,
);
+ const isReverseJunctionRelation = isDefined(
+ getReverseJunctionConfig({
+ junctionObjectMetadataId:
+ fieldMetadataItem?.relation?.targetObjectMetadata.id,
+ sourceObjectMetadataId: objectMetadataItem?.id,
+ objectMetadataItems,
+ }),
+ );
+
const getRelationMetadata = useGetRelationMetadata();
const { updateOneFieldMetadataItem } = useUpdateOneFieldMetadataItem();
const getIsMetadataItemCustom = useGetIsMetadataItemCustom();
@@ -356,33 +365,27 @@ export const SettingsObjectFieldEdit = () => {
readonly={readonly}
/>
</Section>
- {
- //patch - awaiting refacto on many to many relations - https://github.com/twentyhq/core-team-issues/issues/186
- fieldMetadataItem.name !== CoreObjectNamePlural.NoteTarget &&
- fieldMetadataItem.name !== CoreObjectNamePlural.TaskTarget && (
- <>
- <Section>
- {fieldMetadataItem.isUnique ? (
- <H2Title
- title={t`Values`}
- description={t`The values of this field must be unique`}
- />
- ) : (
- <H2Title
- title={t`Values`}
- description={t`The values of this field`}
- />
- )}
- <SettingsDataModelFieldSettingsFormCard
- fieldType={fieldMetadataItem.type}
- existingFieldMetadataId={fieldMetadataItem.id}
- objectNameSingular={objectMetadataItem.nameSingular}
- disabled={readonly}
- />
- </Section>
- </>
- )
- }
+ {!isReverseJunctionRelation && (
+ <Section>
+ {fieldMetadataItem.isUnique ? (
+ <H2Title
+ title={t`Values`}
+ description={t`The values of this field must be unique`}
+ />
+ ) : (
+ <H2Title
+ title={t`Values`}
+ description={t`The values of this field`}
+ />
+ )}
+ <SettingsDataModelFieldSettingsFormCard
+ fieldType={fieldMetadataItem.type}
+ existingFieldMetadataId={fieldMetadataItem.id}
+ objectNameSingular={objectMetadataItem.nameSingular}
+ disabled={readonly}
+ />
+ </Section>
+ )}
<Section>
<H2Title
title={t`Description`}
diff --git a/packages/twenty-front/src/testing/graphqlMocks.ts b/packages/twenty-front/src/testing/graphqlMocks.ts
index b8acce5c16d..68a8bbd856b 100644
--- a/packages/twenty-front/src/testing/graphqlMocks.ts
+++ b/packages/twenty-front/src/testing/graphqlMocks.ts
@@ -27,6 +27,7 @@ import { mockedRoles } from '~/testing/mock-data/generated/metadata/roles/mock-r
import { mockedCommandMenuItems } from '~/testing/mock-data/generated/metadata/command-menu-items/mock-command-menu-items-data';
import { type Task } from '@/activities/types/Task';
+import { getJunctionRecordsFromRecord } from '@/object-record/record-field/ui/utils/junction/getJunctionRecordsFromRecord';
import { FIND_MINIMAL_METADATA } from '@/metadata-store/graphql/queries/findMinimalMetadata';
import {
getConnectionTypename,
@@ -446,16 +447,16 @@ export const graphqlMocks = {
});
}),
graphql.query('FindManyTaskTargets', () => {
- const taskTargetNodes = flatTaskRecords.flatMap(
- (task) => task.taskTargets ?? [],
+ const taskTargetNodes = flatTaskRecords.flatMap((task) =>
+ getJunctionRecordsFromRecord({
+ record: task,
+ junctionFieldName: 'taskTargets',
+ }),
);
return HttpResponse.json({
data: {
- taskTargets: wrapRecordsAsConnection(
- 'taskTarget',
- taskTargetNodes as Record<string, unknown>[],
- ),
+ taskTargets: wrapRecordsAsConnection('taskTarget', taskTargetNodes),
},
});
}),
diff --git a/packages/twenty-front/src/testing/mock-data/generated/metadata/objects/mock-objects-metadata.ts b/packages/twenty-front/src/testing/mock-data/generated/metadata/objects/mock-objects-metadata.ts
index 512191e4941..3e5e903e01b 100644
--- a/packages/twenty-front/src/testing/mock-data/generated/metadata/objects/mock-objects-metadata.ts
+++ b/packages/twenty-front/src/testing/mock-data/generated/metadata/objects/mock-objects-metadata.ts
@@ -14024,7 +14024,8 @@ export const mockedStandardObjectMetadataQueryResult: ObjectMetadataItemsQuery =
"defaultValue": null,
"options": null,
"settings": {
- "relationType": "ONE_TO_MANY"
+ "relationType": "ONE_TO_MANY",
+ "junctionTargetFieldId": "02f05d27-8a15-4035-8bb3-8b6c7ee7b959"
},
"isLabelSyncedWithName": false,
"morphId": null,
@@ -18134,7 +18135,8 @@ export const mockedStandardObjectMetadataQueryResult: ObjectMetadataItemsQuery =
"defaultValue": null,
"options": null,
"settings": {
- "relationType": "ONE_TO_MANY"
+ "relationType": "ONE_TO_MANY",
+ "junctionTargetFieldId": "0199b767-c816-43e5-ba5a-4bb7d4c25d23"
},
"isLabelSyncedWithName": false,
"morphId": null,