Skip to content

The open alternative to Salesforce, designed for AI.

Support nested relation create with morph target selection (#25174)

Félix Malfait44c15bfb24ea
diff --git a/packages/twenty-front/src/modules/object-record/hooks/useBuildRecordInputFromRLSPredicates.ts b/packages/twenty-front/src/modules/object-record/hooks/useBuildRecordInputFromRLSPredicates.ts
index 7c4defdec6b..2bb85f6857a 100644
--- a/packages/twenty-front/src/modules/object-record/hooks/useBuildRecordInputFromRLSPredicates.ts
+++ b/packages/twenty-front/src/modules/object-record/hooks/useBuildRecordInputFromRLSPredicates.ts
@@ -24,10 +24,10 @@ const mergeCompositeValues = (existingValue: unknown, incomingValue: unknown) =>
: incomingValue;
export const useBuildRecordInputFromRLSPredicates = ({
- objectMetadataItem,
+ objectMetadataItem: defaultObjectMetadataItem,
}: {
- objectMetadataItem: EnrichedObjectMetadataItem;
-}) => {
+ objectMetadataItem?: EnrichedObjectMetadataItem;
+} = {}) => {
const currentWorkspaceMember = useAtomStateValue(currentWorkspaceMemberState);
const { userTimezone } = useUserTimezone();
@@ -43,11 +43,6 @@ export const useBuildRecordInputFromRLSPredicates = ({
});
const { objectPermissionsByObjectMetadataId } = useObjectPermissions();
- const objectPermissions = getObjectPermissionsForObject(
- objectPermissionsByObjectMetadataId,
- objectMetadataItem.id,
- );
-
const getRecordInputFieldName = (fieldMetadataItem: {
name: string;
type: string;
@@ -101,7 +96,19 @@ export const useBuildRecordInputFromRLSPredicates = ({
return workspaceMemberFieldValue;
};
- const buildRecordInputFromRLSPredicates = (): Partial<ObjectRecord> => {
+ const buildRecordInputFromRLSPredicates = ({
+ objectMetadataItem = defaultObjectMetadataItem,
+ }: {
+ objectMetadataItem?: EnrichedObjectMetadataItem;
+ } = {}): Partial<ObjectRecord> => {
+ if (!isDefined(objectMetadataItem)) {
+ throw new Error('Object metadata item is required to build RLS defaults');
+ }
+
+ const objectPermissions = getObjectPermissionsForObject(
+ objectPermissionsByObjectMetadataId,
+ objectMetadataItem.id,
+ );
const rlsPredicates = objectPermissions.rowLevelPermissionPredicates.filter(
(predicate) => predicate.objectMetadataId === objectMetadataItem.id,
);
diff --git a/packages/twenty-front/src/modules/object-record/read-only/utils/__tests__/isRecordFieldReadOnly.test.ts b/packages/twenty-front/src/modules/object-record/read-only/utils/__tests__/isRecordFieldReadOnly.test.ts
index 4d297cbdd69..48633a2f8e8 100644
--- a/packages/twenty-front/src/modules/object-record/read-only/utils/__tests__/isRecordFieldReadOnly.test.ts
+++ b/packages/twenty-front/src/modules/object-record/read-only/utils/__tests__/isRecordFieldReadOnly.test.ts
@@ -11,19 +11,17 @@ describe('isRecordFieldReadOnly', () => {
const mockParams = {
isRecordReadOnly: false,
objectPermissions: mockObjectPermissions,
- fieldMetadataId: 'field-123',
- fieldMetadataType: FieldMetadataType.TEXT,
- isUIEditable: true,
+ fieldMetadataItem: {
+ id: 'field-123',
+ isUIEditable: true,
+ type: FieldMetadataType.TEXT,
+ },
};
it('should return true when record is read-only', () => {
const result = isRecordFieldReadOnly({
...mockParams,
isRecordReadOnly: true,
- fieldMetadataItem: {
- id: 'field-123',
- isUIEditable: true,
- },
});
expect(result).toBe(true);
@@ -36,10 +34,6 @@ describe('isRecordFieldReadOnly', () => {
...mockObjectPermissions,
canUpdateObjectRecords: false,
},
- fieldMetadataItem: {
- id: 'field-123',
- isUIEditable: true,
- },
});
expect(result).toBe(true);
@@ -54,10 +48,6 @@ describe('isRecordFieldReadOnly', () => {
'field-123': { canUpdate: false },
},
},
- fieldMetadataItem: {
- id: 'field-123',
- isUIEditable: true,
- },
});
expect(result).toBe(true);
@@ -67,7 +57,7 @@ describe('isRecordFieldReadOnly', () => {
const result = isRecordFieldReadOnly({
...mockParams,
fieldMetadataItem: {
- id: 'field-123',
+ ...mockParams.fieldMetadataItem,
isUIEditable: false,
},
});
@@ -78,10 +68,6 @@ describe('isRecordFieldReadOnly', () => {
it('should return false when all conditions allow editing', () => {
const result = isRecordFieldReadOnly({
...mockParams,
- fieldMetadataItem: {
- id: 'field-123',
- isUIEditable: true,
- },
});
expect(result).toBe(false);
@@ -92,10 +78,6 @@ describe('isRecordFieldReadOnly', () => {
...mockParams,
isSystemObject: true,
isFieldFromStandardApplication: true,
- fieldMetadataItem: {
- id: 'field-123',
- isUIEditable: true,
- },
});
expect(result).toBe(true);
@@ -106,10 +88,6 @@ describe('isRecordFieldReadOnly', () => {
...mockParams,
isSystemObject: true,
isFieldFromStandardApplication: false,
- fieldMetadataItem: {
- id: 'field-123',
- isUIEditable: true,
- },
});
expect(result).toBe(false);
@@ -119,10 +97,6 @@ describe('isRecordFieldReadOnly', () => {
const result = isRecordFieldReadOnly({
...mockParams,
isSystemObject: true,
- fieldMetadataItem: {
- id: 'field-123',
- isUIEditable: true,
- },
});
expect(result).toBe(true);
@@ -134,8 +108,7 @@ describe('isRecordFieldReadOnly', () => {
isSystemObject: true,
isFieldFromStandardApplication: true,
fieldMetadataItem: {
- id: 'field-123',
- isUIEditable: true,
+ ...mockParams.fieldMetadataItem,
type: FieldMetadataType.RELATION,
settings: { junctionTargetFieldId: 'target-field-123' },
},
@@ -150,8 +123,7 @@ describe('isRecordFieldReadOnly', () => {
isSystemObject: true,
isFieldFromStandardApplication: true,
fieldMetadataItem: {
- id: 'field-123',
- isUIEditable: true,
+ ...mockParams.fieldMetadataItem,
type: FieldMetadataType.RELATION,
settings: { relationType: RelationType.ONE_TO_MANY },
},
@@ -166,8 +138,7 @@ describe('isRecordFieldReadOnly', () => {
isRecordReadOnly: true,
isSystemObject: true,
fieldMetadataItem: {
- id: 'field-123',
- isUIEditable: true,
+ ...mockParams.fieldMetadataItem,
type: FieldMetadataType.RELATION,
settings: { junctionTargetFieldId: 'target-field-123' },
},
@@ -179,10 +150,6 @@ describe('isRecordFieldReadOnly', () => {
it('should return false when isSystemObject is not provided', () => {
const result = isRecordFieldReadOnly({
...mockParams,
- fieldMetadataItem: {
- id: 'field-123',
- isUIEditable: true,
- },
});
expect(result).toBe(false);
diff --git a/packages/twenty-front/src/modules/object-record/read-only/utils/isRecordFieldReadOnly.ts b/packages/twenty-front/src/modules/object-record/read-only/utils/isRecordFieldReadOnly.ts
index 3a9559bcdfd..3437727b1d4 100644
--- a/packages/twenty-front/src/modules/object-record/read-only/utils/isRecordFieldReadOnly.ts
+++ b/packages/twenty-front/src/modules/object-record/read-only/utils/isRecordFieldReadOnly.ts
@@ -17,8 +17,10 @@ type IsRecordFieldReadOnlyParams = {
isRecordReadOnly: boolean;
isSystemObject?: boolean;
isFieldFromStandardApplication?: boolean;
- fieldMetadataItem: Pick<FieldMetadataItem, 'id' | 'isUIEditable'> &
- Partial<Pick<FieldMetadataItem, 'type' | 'settings'>>;
+ fieldMetadataItem: Pick<
+ FieldMetadataItem,
+ 'id' | 'isUIEditable' | 'type' | 'settings'
+ >;
objectPermissions: ObjectPermission;
fieldDefinition?: FieldDefinition<FieldMetadata>;
objectPermissionsByObjectMetadataId?: ObjectPermissionsByObjectMetadataId;
@@ -49,12 +51,10 @@ export const isRecordFieldReadOnly = ({
// A junction target field carries links the workspace owns, not data synced
// from the provider, so it is exempt from the system-object lock below.
// Record-level read-only still wins.
- const isJunctionTargetField =
- isDefined(fieldMetadataItem.type) &&
- isConfiguredJunctionRelationField({
- type: fieldMetadataItem.type,
- settings: fieldMetadataItem.settings,
- });
+ const isJunctionTargetField = isConfiguredJunctionRelationField({
+ type: fieldMetadataItem.type,
+ settings: fieldMetadataItem.settings,
+ });
// Keep system-object standard fields read-only. If the application origin
// cannot be resolved yet, fail closed until metadata finishes loading.
diff --git a/packages/twenty-front/src/modules/object-record/record-board/record-board-card/components/RecordBoardCardBody.tsx b/packages/twenty-front/src/modules/object-record/record-board/record-board-card/components/RecordBoardCardBody.tsx
index 990814b675a..658a8ae8e53 100644
--- a/packages/twenty-front/src/modules/object-record/record-board/record-board-card/components/RecordBoardCardBody.tsx
+++ b/packages/twenty-front/src/modules/object-record/record-board/record-board-card/components/RecordBoardCardBody.tsx
@@ -31,6 +31,7 @@ export const RecordBoardCardBody = () => {
const {
labelIdentifierFieldMetadataItem,
+ fieldMetadataItemByFieldMetadataItemId,
fieldDefinitionByFieldMetadataItemId,
objectPermissionsByObjectMetadataId,
} = useRecordIndexContextOrThrow();
@@ -70,8 +71,15 @@ export const RecordBoardCardBody = () => {
{visibleRecordFieldsExceptLabelIdentifier.map((recordField, index) => {
const correspondingFieldDefinition =
fieldDefinitionByFieldMetadataItemId[recordField.fieldMetadataItemId];
+ const fieldMetadataItem =
+ fieldMetadataItemByFieldMetadataItemId[
+ recordField.fieldMetadataItemId
+ ];
- if (!isDefined(correspondingFieldDefinition)) {
+ if (
+ !isDefined(correspondingFieldDefinition) ||
+ !isDefined(fieldMetadataItem)
+ ) {
return null;
}
@@ -91,12 +99,7 @@ export const RecordBoardCardBody = () => {
correspondingFieldDefinition.metadata.applicationId,
}),
objectPermissions,
- fieldMetadataItem: {
- id: recordField.fieldMetadataItemId,
- isUIEditable:
- correspondingFieldDefinition.metadata.isUIEditable ??
- true,
- },
+ fieldMetadataItem,
fieldDefinition: correspondingFieldDefinition,
objectPermissionsByObjectMetadataId,
}),
diff --git a/packages/twenty-front/src/modules/object-record/record-calendar/record-calendar-card/components/RecordCalendarCardBody.tsx b/packages/twenty-front/src/modules/object-record/record-calendar/record-calendar-card/components/RecordCalendarCardBody.tsx
index ef5b831668a..b4c401e1799 100644
--- a/packages/twenty-front/src/modules/object-record/record-calendar/record-calendar-card/components/RecordCalendarCardBody.tsx
+++ b/packages/twenty-front/src/modules/object-record/record-calendar/record-calendar-card/components/RecordCalendarCardBody.tsx
@@ -19,6 +19,7 @@ import { getRecordFieldInputInstanceId } from '@/object-record/utils/getRecordFi
import { useAtomComponentSelectorValue } from '@/ui/utilities/state/jotai/hooks/useAtomComponentSelectorValue';
import { useSetAtomComponentState } from '@/ui/utilities/state/jotai/hooks/useSetAtomComponentState';
import { themeCssVariables } from 'twenty-ui/theme-constants';
+import { isDefined } from 'twenty-shared/utils';
type RecordCalendarCardBodyProps = {
recordId: string;
@@ -53,6 +54,7 @@ export const RecordCalendarCardBody = ({
const {
labelIdentifierFieldMetadataItem,
+ fieldMetadataItemByFieldMetadataItemId,
fieldDefinitionByFieldMetadataItemId,
objectPermissionsByObjectMetadataId,
} = useRecordIndexContextOrThrow();
@@ -83,6 +85,17 @@ export const RecordCalendarCardBody = ({
{visibleRecordFieldsExceptLabelIdentifier.map((recordField, index) => {
const correspondingFieldDefinition =
fieldDefinitionByFieldMetadataItemId[recordField.fieldMetadataItemId];
+ const fieldMetadataItem =
+ fieldMetadataItemByFieldMetadataItemId[
+ recordField.fieldMetadataItemId
+ ];
+
+ if (
+ !isDefined(correspondingFieldDefinition) ||
+ !isDefined(fieldMetadataItem)
+ ) {
+ return null;
+ }
return (
<StopPropagationContainer key={recordField.fieldMetadataItemId}>
@@ -100,12 +113,7 @@ export const RecordCalendarCardBody = ({
correspondingFieldDefinition.metadata.applicationId,
}),
objectPermissions,
- fieldMetadataItem: {
- id: recordField.fieldMetadataItemId,
- isUIEditable:
- correspondingFieldDefinition.metadata.isUIEditable ??
- true,
- },
+ fieldMetadataItem,
fieldDefinition: correspondingFieldDefinition,
objectPermissionsByObjectMetadataId,
}),
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 69ba67352af..916a80955e5 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
@@ -119,10 +119,7 @@ export const RecordFieldList = ({
}),
isFieldFromStandardApplication:
getIsMetadataItemFromStandardApplication(fieldMetadataItem),
- fieldMetadataItem: {
- id: fieldMetadataItem.id,
- isUIEditable: fieldMetadataItem.isUIEditable ?? true,
- },
+ fieldMetadataItem,
fieldDefinition,
objectPermissionsByObjectMetadataId,
}),
@@ -196,10 +193,7 @@ export const RecordFieldList = ({
}),
isFieldFromStandardApplication:
getIsMetadataItemFromStandardApplication(fieldMetadataItem),
- fieldMetadataItem: {
- id: fieldMetadataItem.id,
- isUIEditable: fieldMetadataItem.isUIEditable ?? true,
- },
+ fieldMetadataItem,
fieldDefinition,
objectPermissionsByObjectMetadataId,
}),
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 8f9ccfec20e..66c748db96e 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
@@ -1,20 +1,17 @@
-import { useStore } from 'jotai';
import { type ReactNode, useCallback, useContext } from 'react';
-import { v4 } from 'uuid';
import { useObjectMetadataItem } from '@/object-metadata/hooks/useObjectMetadataItem';
import { useObjectMetadataItems } from '@/object-metadata/hooks/useObjectMetadataItems';
import { getFieldMetadataItemById } from '@/object-metadata/utils/getFieldMetadataItemById';
-import { useCreateOneRecord } from '@/object-record/hooks/useCreateOneRecord';
import { useRecordFieldsScopeContextOrThrow } from '@/object-record/record-field-list/contexts/RecordFieldsScopeContext';
import { FieldContext } from '@/object-record/record-field/ui/contexts/FieldContext';
+import { useCreateJunctionRecordWithNestedTarget } from '@/object-record/record-field/ui/hooks/useCreateJunctionRecordWithNestedTarget';
import { useUpdateJunctionRelationFromCell } from '@/object-record/record-field/ui/hooks/useUpdateJunctionRelationFromCell';
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 { type FieldDefinition } from '@/object-record/record-field/ui/types/FieldDefinition';
import { type FieldRelationMetadata } from '@/object-record/record-field/ui/types/FieldMetadata';
import { getJunctionRelationPickerData } from '@/object-record/record-field/ui/utils/junction/getJunctionRelationPickerData';
-import { getSourceJoinColumnName } from '@/object-record/record-field/ui/utils/junction/getSourceJoinColumnName';
import { isUsableJunctionConfig } from '@/object-record/record-field/ui/utils/junction/isUsableJunctionConfig';
import { MultipleRecordPicker } from '@/object-record/record-picker/multiple-record-picker/components/MultipleRecordPicker';
import { useMultipleRecordPickerOpen } from '@/object-record/record-picker/multiple-record-picker/hooks/useMultipleRecordPickerOpen';
@@ -25,19 +22,13 @@ import { multipleRecordPickerSearchableObjectMetadataItemsComponentState } from
import { getRecordFieldCardRelationPickerDropdownId } from '@/object-record/record-show/utils/getRecordFieldCardRelationPickerDropdownId';
import { recordStoreFamilySelector } from '@/object-record/record-store/states/selectors/recordStoreFamilySelector';
import { type ObjectRecord } from '@/object-record/types/ObjectRecord';
-import { buildRecordLabelPayload } from '@/object-record/utils/buildRecordLabelPayload';
import { Dropdown } from '@/ui/layout/dropdown/components/Dropdown';
import { useCloseDropdown } from '@/ui/layout/dropdown/hooks/useCloseDropdown';
import { dropdownPlacementComponentState } from '@/ui/layout/dropdown/states/dropdownPlacementComponentState';
-import { useAtomComponentStateCallbackState } from '@/ui/utilities/state/jotai/hooks/useAtomComponentStateCallbackState';
import { useAtomComponentStateValue } from '@/ui/utilities/state/jotai/hooks/useAtomComponentStateValue';
import { useAtomFamilySelectorValue } from '@/ui/utilities/state/jotai/hooks/useAtomFamilySelectorValue';
import { useSetAtomComponentState } from '@/ui/utilities/state/jotai/hooks/useSetAtomComponentState';
-import {
- computeRelationGqlFieldJoinColumnName,
- CustomError,
- isDefined,
-} from 'twenty-shared/utils';
+import { CustomError, isDefined } from 'twenty-shared/utils';
import { IconPlus } from 'twenty-ui/icon';
import { LightIconButton } from 'twenty-ui/input';
@@ -48,7 +39,6 @@ type RecordDetailRelationSectionDropdownToManyProps = {
export const RecordDetailRelationSectionDropdownToMany = ({
dropdownTriggerClickableComponent,
}: RecordDetailRelationSectionDropdownToManyProps) => {
- const store = useStore();
const { scopeInstanceId } = useRecordFieldsScopeContextOrThrow();
const { recordId, fieldDefinition } = useContext(FieldContext);
const { fieldMetadataId } = fieldDefinition;
@@ -85,18 +75,6 @@ export const RecordDetailRelationSectionDropdownToMany = ({
const isInvalidJunctionRelation =
isDefined(junctionConfig) && !isJunctionRelation;
- const firstJunctionTargetField =
- junctionConfig && !junctionConfig.isMorphRelation
- ? junctionConfig.targetFields[0]
- : undefined;
-
- const junctionTargetObjectMetadata = objectMetadataItems.find(
- (item) =>
- item.id === firstJunctionTargetField?.relation?.targetObjectMetadata.id,
- );
-
- const isMorphJunction = junctionConfig?.isMorphRelation ?? false;
-
const { objectMetadataItem: relationObjectMetadataItem } =
useObjectMetadataItem({
objectNameSingular: relationObjectMetadataNameSingular,
@@ -166,12 +144,6 @@ export const RecordDetailRelationSectionDropdownToMany = ({
dropdownId,
);
- const multipleRecordPickerPickableMorphItemsCallbackState =
- useAtomComponentStateCallbackState(
- multipleRecordPickerPickableMorphItemsComponentState,
- dropdownId,
- );
-
const { performSearch: multipleRecordPickerPerformSearch } =
useMultipleRecordPickerPerformSearch();
@@ -192,16 +164,14 @@ export const RecordDetailRelationSectionDropdownToMany = ({
recordId,
});
- const { createOneRecord: createTargetRecord } = useCreateOneRecord({
- objectNameSingular:
- junctionTargetObjectMetadata?.nameSingular ??
- relationObjectMetadataNameSingular,
- });
-
- const { createOneRecord: createJunctionRecord } = useCreateOneRecord({
- objectNameSingular:
- junctionConfig?.junctionObjectMetadata?.nameSingular ??
- relationObjectMetadataNameSingular,
+ const {
+ createJunctionRecordWithNestedTarget,
+ loading: isCreatingJunctionRecord,
+ } = useCreateJunctionRecordWithNestedTarget({
+ sourceRecordId: recordId,
+ sourceFieldName: fieldName,
+ sourceObjectMetadataItem: objectMetadataItem,
+ junctionConfig: isJunctionRelation ? junctionConfig : undefined,
});
const handleOpenRelationPickerDropdown = () => {
@@ -222,112 +192,34 @@ export const RecordDetailRelationSectionDropdownToMany = ({
};
const handleCreateNew = useCallback(
- async (searchString?: string) => {
- const updatePickerState = (
- newRecordId: string,
- targetObjectMetadataId: string,
- ) => {
- const currentMorphItems = store.get(
- multipleRecordPickerPickableMorphItemsCallbackState,
- );
-
- const newMorphItems = currentMorphItems.concat({
- recordId: newRecordId,
- objectMetadataId: targetObjectMetadataId,
- isSelected: true,
- isMatchingSearchFilter: true,
- });
-
- store.set(
- multipleRecordPickerPickableMorphItemsCallbackState,
- newMorphItems,
- );
-
- multipleRecordPickerPerformSearch({
- multipleRecordPickerInstanceId: dropdownId,
- forceSearchFilter: searchString,
- forceSearchableObjectMetadataItems: searchableObjectMetadataItems,
- forcePickableMorphItems: newMorphItems,
- });
- };
-
- if (
- isJunctionRelation &&
- isDefined(junctionConfig) &&
- !isMorphJunction &&
- isDefined(junctionTargetObjectMetadata)
- ) {
- const { targetFields, sourceField } = junctionConfig;
- const targetField = targetFields[0];
-
- if (!isDefined(targetField) || !isDefined(sourceField)) {
- return;
- }
-
- const sourceJoinColumnName = getSourceJoinColumnName({
- sourceField,
- sourceObjectMetadata: objectMetadataItem,
- });
-
- const targetJoinColumnName = computeRelationGqlFieldJoinColumnName({
- name: targetField.name,
- });
-
- if (!sourceJoinColumnName) {
- return;
- }
-
- const newTargetId = v4();
- const targetPayload = buildRecordLabelPayload({
- id: newTargetId,
- searchInput: searchString,
- objectMetadataItem: junctionTargetObjectMetadata,
- });
-
- await createTargetRecord(targetPayload);
-
- // The junction is already attached to the source record's field by
- // useCreateOneRecord's post-optimistic effect; appending it here as
- // well would render the same target twice until a reload
- await createJunctionRecord({
- id: v4(),
- [sourceJoinColumnName]: recordId,
- [targetJoinColumnName]: newTargetId,
+ async ({
+ searchInput,
+ objectMetadataItemId,
+ }: {
+ searchInput?: string;
+ objectMetadataItemId: string;
+ }) => {
+ if (isJunctionRelation) {
+ return createJunctionRecordWithNestedTarget({
+ searchInput,
+ targetObjectMetadataItemId: objectMetadataItemId,
});
-
- updatePickerState(newTargetId, junctionTargetObjectMetadata.id);
- return;
}
closeDropdown(dropdownId);
- createNewRecordAndOpenSidePanel?.(searchString);
+ await createNewRecordAndOpenSidePanel?.(searchInput);
+
+ return undefined;
},
[
closeDropdown,
- createJunctionRecord,
createNewRecordAndOpenSidePanel,
- createTargetRecord,
+ createJunctionRecordWithNestedTarget,
dropdownId,
- isMorphJunction,
isJunctionRelation,
- junctionConfig,
- junctionTargetObjectMetadata,
- multipleRecordPickerPickableMorphItemsCallbackState,
- multipleRecordPickerPerformSearch,
- objectMetadataItem,
- recordId,
- searchableObjectMetadataItems,
- store,
],
);
- const canCreateNew = !isMorphJunction;
-
- const objectMetadataItemIdForCreate =
- isJunctionRelation && isDefined(junctionTargetObjectMetadata)
- ? junctionTargetObjectMetadata.id
- : relationObjectMetadataItem.id;
-
const handleChange = useCallback(
(morphItem: Parameters<typeof updateRelation>[0]) => {
if (isJunctionRelation) {
@@ -362,8 +254,12 @@ export const RecordDetailRelationSectionDropdownToMany = ({
<MultipleRecordPicker
focusId={dropdownId}
componentInstanceId={dropdownId}
- onCreate={canCreateNew ? handleCreateNew : undefined}
- objectMetadataItemIdForCreate={objectMetadataItemIdForCreate}
+ onCreate={
+ isJunctionRelation || isDefined(createNewRecordAndOpenSidePanel)
+ ? handleCreateNew
+ : undefined
+ }
+ isCreatePending={isCreatingJunctionRecord}
onChange={handleChange}
onSubmit={() => {
closeDropdown(dropdownId);
diff --git a/packages/twenty-front/src/modules/object-record/record-field/ui/hooks/useCreateJunctionRecordWithNestedTarget.ts b/packages/twenty-front/src/modules/object-record/record-field/ui/hooks/useCreateJunctionRecordWithNestedTarget.ts
new file mode 100644
index 00000000000..1028d7346bc
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-record/record-field/ui/hooks/useCreateJunctionRecordWithNestedTarget.ts
@@ -0,0 +1,166 @@
+import { useCallback, useState } from 'react';
+import { CombinedGraphQLErrors } from '@apollo/client/errors';
+import { t } from '@lingui/core/macro';
+import { useStore } from 'jotai';
+import { v4 } from 'uuid';
+
+import { getObjectTypename } from '@/object-record/cache/utils/getObjectTypename';
+import { useObjectMetadataItems } from '@/object-metadata/hooks/useObjectMetadataItems';
+import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
+import { useBuildRecordInputFromRLSPredicates } from '@/object-record/hooks/useBuildRecordInputFromRLSPredicates';
+import { useCreateOneRecord } from '@/object-record/hooks/useCreateOneRecord';
+import { upsertJunctionRecordInSourceRecordStore } from '@/object-record/record-field/ui/utils/junction/upsertJunctionRecordInSourceRecordStore';
+import { type ValidJunctionConfig } from '@/object-record/record-field/ui/utils/junction/types/ValidJunctionConfig';
+import { findTargetFieldInfo } from '@/object-record/record-field/ui/utils/junction/findTargetFieldInfo';
+import { getSourceJoinColumnName } from '@/object-record/record-field/ui/utils/junction/getSourceJoinColumnName';
+import { type RecordPickerPickableMorphItem } from '@/object-record/record-picker/types/RecordPickerPickableMorphItem';
+import { type ObjectRecord } from '@/object-record/types/ObjectRecord';
+import { buildRecordLabelPayload } from '@/object-record/utils/buildRecordLabelPayload';
+import { sanitizeRecordInput } from '@/object-record/utils/sanitizeRecordInput';
+import { useSnackBar } from '@/ui/feedback/snack-bar-manager/hooks/useSnackBar';
+import { isDefined } from 'twenty-shared/utils';
+
+type UseCreateJunctionRecordWithNestedTargetArgs = {
+ sourceRecordId: string;
+ sourceFieldName: string;
+ sourceObjectMetadataItem: EnrichedObjectMetadataItem;
+ junctionConfig?: ValidJunctionConfig;
+};
+
+export const useCreateJunctionRecordWithNestedTarget = ({
+ sourceRecordId,
+ sourceFieldName,
+ sourceObjectMetadataItem,
+ junctionConfig,
+}: UseCreateJunctionRecordWithNestedTargetArgs) => {
+ const store = useStore();
+ const [loading, setLoading] = useState(false);
+ const { objectMetadataItems } = useObjectMetadataItems();
+ const { enqueueErrorSnackBar } = useSnackBar();
+ const { buildRecordInputFromRLSPredicates } =
+ useBuildRecordInputFromRLSPredicates();
+ const { createOneRecord: createJunctionRecord } = useCreateOneRecord({
+ objectNameSingular:
+ junctionConfig?.junctionObjectMetadata.nameSingular ??
+ sourceObjectMetadataItem.nameSingular,
+ });
+
+ const createJunctionRecordWithNestedTarget = useCallback(
+ async ({
+ searchInput,
+ targetObjectMetadataItemId,
+ }: {
+ searchInput?: string;
+ targetObjectMetadataItemId: string;
+ }): Promise<RecordPickerPickableMorphItem | undefined> => {
+ if (!isDefined(junctionConfig?.sourceField)) {
+ return undefined;
+ }
+
+ const targetObjectMetadataItem = objectMetadataItems.find(
+ ({ id }) => id === targetObjectMetadataItemId,
+ );
+ const targetFieldInfo = findTargetFieldInfo(
+ junctionConfig.targetFields,
+ targetObjectMetadataItemId,
+ objectMetadataItems,
+ );
+ const sourceJoinColumnName = getSourceJoinColumnName({
+ sourceField: junctionConfig.sourceField,
+ sourceObjectMetadata: sourceObjectMetadataItem,
+ });
+
+ if (
+ !isDefined(targetObjectMetadataItem) ||
+ !isDefined(targetFieldInfo) ||
+ !isDefined(sourceJoinColumnName)
+ ) {
+ enqueueErrorSnackBar({
+ message: t`The relation configuration could not be resolved.`,
+ });
+ return undefined;
+ }
+
+ setLoading(true);
+
+ try {
+ const targetRecordId = v4();
+ const targetRecordInput = {
+ ...sanitizeRecordInput({
+ objectMetadataItem: targetObjectMetadataItem,
+ recordInput: {
+ ...buildRecordInputFromRLSPredicates({
+ objectMetadataItem: targetObjectMetadataItem,
+ }),
+ ...buildRecordLabelPayload({
+ id: targetRecordId,
+ searchInput,
+ objectMetadataItem: targetObjectMetadataItem,
+ }),
+ },
+ }),
+ id: targetRecordId,
+ };
+
+ const createdJunctionRecord = await createJunctionRecord({
+ id: v4(),
+ [sourceJoinColumnName]: sourceRecordId,
+ [targetFieldInfo.fieldName]: { create: targetRecordInput },
+ });
+
+ const createdTargetRecord = createdJunctionRecord[
+ targetFieldInfo.fieldName
+ ] as ObjectRecord | undefined;
+ const targetRecord = {
+ ...targetRecordInput,
+ ...(createdTargetRecord ?? {}),
+ __typename:
+ createdTargetRecord?.__typename ??
+ getObjectTypename(targetObjectMetadataItem.nameSingular),
+ };
+ const junctionRecordForStore = {
+ ...createdJunctionRecord,
+ [targetFieldInfo.fieldName]: targetRecord,
+ };
+
+ upsertJunctionRecordInSourceRecordStore({
+ store,
+ sourceRecordId,
+ sourceFieldName,
+ junctionRecord: junctionRecordForStore,
+ });
+
+ return {
+ recordId: targetRecordId,
+ objectMetadataId: targetObjectMetadataItem.id,
+ isSelected: true,
+ isMatchingSearchFilter: true,
+ };
+ } catch (error) {
+ enqueueErrorSnackBar(
+ CombinedGraphQLErrors.is(error)
+ ? { apolloError: error }
+ : error instanceof Error
+ ? { message: error.message }
+ : {},
+ );
+ return undefined;
+ } finally {
+ setLoading(false);
+ }
+ },
+ [
+ buildRecordInputFromRLSPredicates,
+ createJunctionRecord,
+ enqueueErrorSnackBar,
+ junctionConfig,
+ objectMetadataItems,
+ sourceObjectMetadataItem,
+ sourceFieldName,
+ sourceRecordId,
+ store,
+ ],
+ );
+
+ return { createJunctionRecordWithNestedTarget, loading };
+};
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 1fe43809d93..471a7fc83e2 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
@@ -15,6 +15,7 @@ import {
type FieldRelationMetadata,
type FieldRelationValue,
} from '@/object-record/record-field/ui/types/FieldMetadata';
+import { upsertJunctionRecordInSourceRecordStore } from '@/object-record/record-field/ui/utils/junction/upsertJunctionRecordInSourceRecordStore';
import { findJunctionRecordByTargetId } from '@/object-record/record-field/ui/utils/junction/findJunctionRecordByTargetId';
import { findTargetFieldInfo } from '@/object-record/record-field/ui/utils/junction/findTargetFieldInfo';
import { getSourceJoinColumnName } from '@/object-record/record-field/ui/utils/junction/getSourceJoinColumnName';
@@ -190,24 +191,12 @@ export const useUpdateJunctionRelationFromCell = ({
[targetFieldName]: targetRecord,
};
- store.set(
- recordStoreFamilyState.atomFamily(recordId),
- (currentRecord: Record<string, unknown> | null | undefined) => {
- if (!isDefined(currentRecord)) {
- return currentRecord;
- }
-
- const currentFieldValue = currentRecord[fieldName];
- const updatedJunctionRecords = Array.isArray(currentFieldValue)
- ? [...currentFieldValue, junctionRecordForStore]
- : [junctionRecordForStore];
-
- return {
- ...currentRecord,
- [fieldName]: updatedJunctionRecords,
- } as ObjectRecord;
- },
- );
+ upsertJunctionRecordInSourceRecordStore({
+ store,
+ sourceRecordId: recordId,
+ sourceFieldName: fieldName,
+ junctionRecord: junctionRecordForStore,
+ });
const removeOptimisticJunctionRecord = () =>
store.set(
@@ -257,40 +246,16 @@ export const useUpdateJunctionRelationFromCell = ({
recordNode: persistedJunctionRecordNode,
});
- store.set(
- recordStoreFamilyState.atomFamily(recordId),
- (currentRecord: Record<string, unknown> | null | undefined) => {
- if (!isDefined(currentRecord)) {
- return currentRecord;
- }
-
- const currentFieldValue = currentRecord[fieldName];
-
- if (!Array.isArray(currentFieldValue)) {
- return currentRecord as ObjectRecord;
- }
-
- const junctionRecordsWithoutOptimistic = currentFieldValue.filter(
- (junctionRecord) => junctionRecord.id !== optimisticJunctionId,
- );
-
- const isPersistedJunctionRecordAlreadyInStore =
- junctionRecordsWithoutOptimistic.some(
- (junctionRecord) =>
- junctionRecord.id === persistedJunctionRecord.id,
- );
-
- return {
- ...currentRecord,
- [fieldName]: isPersistedJunctionRecordAlreadyInStore
- ? junctionRecordsWithoutOptimistic
- : [
- ...junctionRecordsWithoutOptimistic,
- { ...junctionRecordForStore, ...persistedJunctionRecord },
- ],
- } as ObjectRecord;
+ removeOptimisticJunctionRecord();
+ upsertJunctionRecordInSourceRecordStore({
+ store,
+ sourceRecordId: recordId,
+ sourceFieldName: fieldName,
+ junctionRecord: {
+ ...junctionRecordForStore,
+ ...persistedJunctionRecord,
},
- );
+ });
}
},
[
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 1fabdf9c88f..d0809159fb8 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
@@ -1,13 +1,11 @@
import { useCallback, useContext } from 'react';
-import { useStore } from 'jotai';
-import { v4 } from 'uuid';
import { useObjectMetadataItem } from '@/object-metadata/hooks/useObjectMetadataItem';
import { useObjectMetadataItems } from '@/object-metadata/hooks/useObjectMetadataItems';
import { getFieldMetadataItemById } from '@/object-metadata/utils/getFieldMetadataItemById';
-import { useCreateOneRecord } from '@/object-record/hooks/useCreateOneRecord';
import { FieldContext } from '@/object-record/record-field/ui/contexts/FieldContext';
import { FieldInputEventContext } from '@/object-record/record-field/ui/contexts/FieldInputEventContext';
+import { useCreateJunctionRecordWithNestedTarget } from '@/object-record/record-field/ui/hooks/useCreateJunctionRecordWithNestedTarget';
import { useUpdateJunctionRelationFromCell } from '@/object-record/record-field/ui/hooks/useUpdateJunctionRelationFromCell';
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';
@@ -15,22 +13,12 @@ import { RecordFieldComponentInstanceContext } from '@/object-record/record-fiel
import { recordFieldInputLayoutDirectionComponentState } from '@/object-record/record-field/ui/states/recordFieldInputLayoutDirectionComponentState';
import { type FieldDefinition } from '@/object-record/record-field/ui/types/FieldDefinition';
import { type FieldRelationMetadata } from '@/object-record/record-field/ui/types/FieldMetadata';
-import { getSourceJoinColumnName } from '@/object-record/record-field/ui/utils/junction/getSourceJoinColumnName';
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';
-import { buildRecordLabelPayload } from '@/object-record/utils/buildRecordLabelPayload';
import { useAvailableComponentInstanceIdOrThrow } from '@/ui/utilities/state/component-state/hooks/useAvailableComponentInstanceIdOrThrow';
-import { useAtomComponentStateCallbackState } from '@/ui/utilities/state/jotai/hooks/useAtomComponentStateCallbackState';
import { useAtomComponentStateValue } from '@/ui/utilities/state/jotai/hooks/useAtomComponentStateValue';
-import {
- computeRelationGqlFieldJoinColumnName,
- CustomError,
- isDefined,
-} from 'twenty-shared/utils';
+import { CustomError, isDefined } from 'twenty-shared/utils';
export const RelationOneToManyFieldInput = () => {
- const store = useStore();
const { fieldDefinition, recordId } = useContext(FieldContext);
const instanceId = useAvailableComponentInstanceIdOrThrow(
RecordFieldComponentInstanceContext,
@@ -67,18 +55,6 @@ export const RelationOneToManyFieldInput = () => {
const isJunctionRelation = junctionConfig?.isValid === true;
const isInvalidJunctionRelation = junctionConfig?.isValid === false;
- const junctionTargetObjectMetadata = (() => {
- if (!junctionConfig || junctionConfig.isMorphRelation) {
- return undefined;
- }
- const firstTargetField = junctionConfig.targetFields[0];
- return objectMetadataItems.find(
- (item) => item.id === firstTargetField?.relation?.targetObjectMetadata.id,
- );
- })();
-
- const isMorphJunction = junctionConfig?.isMorphRelation ?? false;
-
const { objectMetadataItem: relationObjectMetadataItem } =
useObjectMetadataItem({
objectNameSingular:
@@ -105,145 +81,55 @@ export const RelationOneToManyFieldInput = () => {
recordId,
});
- const { createOneRecord: createTargetRecord } = useCreateOneRecord({
- objectNameSingular:
- junctionTargetObjectMetadata?.nameSingular ??
- relationFieldDefinition.metadata.relationObjectMetadataNameSingular,
- });
- const { createOneRecord: createJunctionRecord } = useCreateOneRecord({
- objectNameSingular:
- junctionConfig?.junctionObjectMetadata?.nameSingular ??
- relationFieldDefinition.metadata.relationObjectMetadataNameSingular,
+ const {
+ createJunctionRecordWithNestedTarget,
+ loading: isCreatingJunctionRecord,
+ } = useCreateJunctionRecordWithNestedTarget({
+ sourceRecordId: recordId,
+ sourceFieldName: relationFieldDefinition.metadata.fieldName,
+ sourceObjectMetadataItem: objectMetadataItem,
+ junctionConfig: isJunctionRelation ? junctionConfig : undefined,
});
const recordFieldInputLayoutDirection = useAtomComponentStateValue(
recordFieldInputLayoutDirectionComponentState,
);
- const multipleRecordPickerPickableMorphItemsCallbackState =
- useAtomComponentStateCallbackState(
- multipleRecordPickerPickableMorphItemsComponentState,
- instanceId,
- );
- const { performSearch: multipleRecordPickerPerformSearch } =
- useMultipleRecordPickerPerformSearch();
-
const handleCreateNew = useCallback(
- async (searchInput?: string) => {
- const updatePickerState = (
- newRecordId: string,
- targetObjectMetadataId: string,
- searchableObjectMetadataItems: (typeof relationObjectMetadataItem)[],
- ) => {
- const currentMorphItems = store.get(
- multipleRecordPickerPickableMorphItemsCallbackState,
- );
-
- const newMorphItems = currentMorphItems.concat({
- recordId: newRecordId,
- objectMetadataId: targetObjectMetadataId,
- isSelected: true,
- isMatchingSearchFilter: true,
- });
-
- store.set(
- multipleRecordPickerPickableMorphItemsCallbackState,
- newMorphItems,
- );
-
- multipleRecordPickerPerformSearch({
- multipleRecordPickerInstanceId: instanceId,
- forceSearchFilter: searchInput,
- forceSearchableObjectMetadataItems: searchableObjectMetadataItems,
- forcePickableMorphItems: newMorphItems,
- });
- };
-
- if (
- isJunctionRelation &&
- isDefined(junctionConfig) &&
- !isMorphJunction &&
- isDefined(junctionTargetObjectMetadata)
- ) {
- const { targetFields, sourceField } = junctionConfig;
- const targetField = targetFields[0];
-
- if (!isDefined(targetField) || !isDefined(sourceField)) {
- return;
- }
-
- const sourceJoinColumnName = getSourceJoinColumnName({
- sourceField,
- sourceObjectMetadata: objectMetadataItem,
- });
-
- const targetJoinColumnName = computeRelationGqlFieldJoinColumnName({
- name: targetField.name,
- });
-
- if (!sourceJoinColumnName) {
- return;
- }
-
- const newTargetId = v4();
- const targetPayload = buildRecordLabelPayload({
- id: newTargetId,
+ async ({
+ searchInput,
+ objectMetadataItemId,
+ }: {
+ searchInput?: string;
+ objectMetadataItemId: string;
+ }) => {
+ if (isJunctionRelation) {
+ return createJunctionRecordWithNestedTarget({
searchInput,
- objectMetadataItem: junctionTargetObjectMetadata,
- });
-
- await createTargetRecord(targetPayload);
-
- // The junction is already attached to the source record's field by
- // useCreateOneRecord's post-optimistic effect; appending it here as
- // well would render the same target twice until a reload
- await createJunctionRecord({
- id: v4(),
- [sourceJoinColumnName]: recordId,
- [targetJoinColumnName]: newTargetId,
+ targetObjectMetadataItemId: objectMetadataItemId,
});
-
- updatePickerState(newTargetId, junctionTargetObjectMetadata.id, [
- junctionTargetObjectMetadata,
- ]);
- return;
}
const newRecordId = await createNewRecordAndOpenSidePanel?.(searchInput);
if (isDefined(newRecordId)) {
- updatePickerState(newRecordId, relationObjectMetadataItem.id, [
- relationObjectMetadataItem,
- ]);
+ return {
+ recordId: newRecordId,
+ objectMetadataId: objectMetadataItemId,
+ isSelected: true,
+ isMatchingSearchFilter: true,
+ };
}
+
+ return undefined;
},
[
createNewRecordAndOpenSidePanel,
- createTargetRecord,
- createJunctionRecord,
- instanceId,
- isMorphJunction,
+ createJunctionRecordWithNestedTarget,
isJunctionRelation,
- junctionConfig,
- junctionTargetObjectMetadata,
- multipleRecordPickerPickableMorphItemsCallbackState,
- multipleRecordPickerPerformSearch,
- objectMetadataItem,
- recordId,
- relationObjectMetadataItem,
- store,
],
);
- // 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 =
- isJunctionRelation && isDefined(junctionTargetObjectMetadata)
- ? junctionTargetObjectMetadata.id
- : relationObjectMetadataItem.id;
-
if (isInvalidJunctionRelation) {
return null;
}
@@ -262,8 +148,12 @@ export const RelationOneToManyFieldInput = () => {
updateRelation(morphItem);
}
}}
- onCreate={canCreateNew ? handleCreateNew : undefined}
- objectMetadataItemIdForCreate={objectMetadataItemIdForCreate}
+ onCreate={
+ isJunctionRelation || isDefined(createNewRecordAndOpenSidePanel)
+ ? handleCreateNew
+ : undefined
+ }
+ isCreatePending={isCreatingJunctionRecord}
onClickOutside={handleSubmit}
layoutDirection={
recordFieldInputLayoutDirection === 'downward'
diff --git a/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/__tests__/upsertJunctionRecordInSourceRecordStore.test.ts b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/__tests__/upsertJunctionRecordInSourceRecordStore.test.ts
new file mode 100644
index 00000000000..d22744ec62e
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/__tests__/upsertJunctionRecordInSourceRecordStore.test.ts
@@ -0,0 +1,65 @@
+import { createStore } from 'jotai';
+
+import { upsertJunctionRecordInSourceRecordStore } from '@/object-record/record-field/ui/utils/junction/upsertJunctionRecordInSourceRecordStore';
+import { recordStoreFamilyState } from '@/object-record/record-store/states/recordStoreFamilyState';
+
+describe('upsertJunctionRecordInSourceRecordStore', () => {
+ it('appends a new junction without replacing existing junctions', () => {
+ const store = createStore();
+ const sourceRecordId = 'source-record-id';
+ const existingJunction = {
+ id: 'existing-junction-id',
+ __typename: 'Junction',
+ };
+ const newJunction = { id: 'new-junction-id', __typename: 'Junction' };
+
+ store.set(recordStoreFamilyState.atomFamily(sourceRecordId), {
+ id: sourceRecordId,
+ __typename: 'Source',
+ junctions: [existingJunction],
+ });
+
+ upsertJunctionRecordInSourceRecordStore({
+ store,
+ sourceRecordId,
+ sourceFieldName: 'junctions',
+ junctionRecord: newJunction,
+ });
+
+ expect(
+ store.get(recordStoreFamilyState.atomFamily(sourceRecordId))?.junctions,
+ ).toEqual([existingJunction, newJunction]);
+ });
+
+ it('enriches an optimistic junction instead of ignoring the same id', () => {
+ const store = createStore();
+ const sourceRecordId = 'source-record-id';
+
+ store.set(recordStoreFamilyState.atomFamily(sourceRecordId), {
+ id: sourceRecordId,
+ __typename: 'Source',
+ junctions: [{ id: 'junction-id', __typename: 'Junction' }],
+ });
+
+ upsertJunctionRecordInSourceRecordStore({
+ store,
+ sourceRecordId,
+ sourceFieldName: 'junctions',
+ junctionRecord: {
+ id: 'junction-id',
+ __typename: 'Junction',
+ target: { id: 'target-id', __typename: 'Target' },
+ },
+ });
+
+ expect(
+ store.get(recordStoreFamilyState.atomFamily(sourceRecordId))?.junctions,
+ ).toEqual([
+ {
+ id: 'junction-id',
+ __typename: 'Junction',
+ target: { id: 'target-id', __typename: 'Target' },
+ },
+ ]);
+ });
+});
diff --git a/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/upsertJunctionRecordInSourceRecordStore.ts b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/upsertJunctionRecordInSourceRecordStore.ts
new file mode 100644
index 00000000000..d2b1b04a59b
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-record/record-field/ui/utils/junction/upsertJunctionRecordInSourceRecordStore.ts
@@ -0,0 +1,50 @@
+import { type Store } from 'jotai/vanilla/store';
+import { isDefined } from 'twenty-shared/utils';
+
+import { recordStoreFamilyState } from '@/object-record/record-store/states/recordStoreFamilyState';
+import { type ObjectRecord } from '@/object-record/types/ObjectRecord';
+
+export const upsertJunctionRecordInSourceRecordStore = ({
+ store,
+ sourceRecordId,
+ sourceFieldName,
+ junctionRecord,
+}: {
+ store: Store;
+ sourceRecordId: string;
+ sourceFieldName: string;
+ junctionRecord: ObjectRecord;
+}) => {
+ store.set(
+ recordStoreFamilyState.atomFamily(sourceRecordId),
+ (currentRecord) => {
+ if (!isDefined(currentRecord)) {
+ return currentRecord;
+ }
+
+ const currentJunctionRecords = Array.isArray(
+ currentRecord[sourceFieldName],
+ )
+ ? currentRecord[sourceFieldName]
+ : [];
+ const existingJunctionIndex = currentJunctionRecords.findIndex(
+ ({ id }) => id === junctionRecord.id,
+ );
+ const nextJunctionRecords = [...currentJunctionRecords];
+
+ if (existingJunctionIndex === -1) {
+ nextJunctionRecords.push(junctionRecord);
+ } else {
+ nextJunctionRecords[existingJunctionIndex] = {
+ ...nextJunctionRecords[existingJunctionIndex],
+ ...junctionRecord,
+ };
+ }
+
+ return {
+ ...currentRecord,
+ [sourceFieldName]: nextJunctionRecords,
+ } as ObjectRecord;
+ },
+ );
+};
diff --git a/packages/twenty-front/src/modules/object-record/record-picker/multiple-record-picker/components/MultipleRecordPicker.tsx b/packages/twenty-front/src/modules/object-record/record-picker/multiple-record-picker/components/MultipleRecordPicker.tsx
index d6ecc1baa56..b0a86089be5 100644
--- a/packages/twenty-front/src/modules/object-record/record-picker/multiple-record-picker/components/MultipleRecordPicker.tsx
+++ b/packages/twenty-front/src/modules/object-record/record-picker/multiple-record-picker/components/MultipleRecordPicker.tsx
@@ -1,16 +1,21 @@
-import { useCallback, useRef } from 'react';
+import { useCallback, useRef, useState } from 'react';
import { useStore } from 'jotai';
-import { useObjectMetadataItems } from '@/object-metadata/hooks/useObjectMetadataItems';
-import { useObjectPermissionsForObject } from '@/object-record/hooks/useObjectPermissionsForObject';
+import { getObjectPermissionsForObject } from '@/object-metadata/utils/getObjectPermissionsForObject';
+import { useObjectPermissions } from '@/object-record/hooks/useObjectPermissions';
import { canCreateRecordsForObjectMetadataItem } from '@/object-record/utils/canCreateRecordsForObjectMetadataItem';
+import { MultipleRecordPickerCreateTargetSelect } from '@/object-record/record-picker/multiple-record-picker/components/MultipleRecordPickerCreateTargetSelect';
import { MultipleRecordPickerItemsDisplay } from '@/object-record/record-picker/multiple-record-picker/components/MultipleRecordPickerItemsDisplay';
import { MultipleRecordPickerOnClickOutsideEffect } from '@/object-record/record-picker/multiple-record-picker/components/MultipleRecordPickerOnClickOutsideEffect';
import { MultipleRecordPickerSearchInput } from '@/object-record/record-picker/multiple-record-picker/components/MultipleRecordPickerSearchInput';
+import { useMultipleRecordPickerPerformSearch } from '@/object-record/record-picker/multiple-record-picker/hooks/useMultipleRecordPickerPerformSearch';
import { MultipleRecordPickerComponentInstanceContext } from '@/object-record/record-picker/multiple-record-picker/states/contexts/MultipleRecordPickerComponentInstanceContext';
+import { multipleRecordPickerIsLoadingComponentState } from '@/object-record/record-picker/multiple-record-picker/states/multipleRecordPickerIsLoadingComponentState';
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 { getMultipleRecordPickerSelectableListId } from '@/object-record/record-picker/multiple-record-picker/utils/getMultipleRecordPickerSelectableListId';
+import { upsertMorphItem } from '@/object-record/record-picker/multiple-record-picker/utils/upsertMorphItem';
import { type RecordPickerLayoutDirection } from '@/object-record/record-picker/types/RecordPickerLayoutDirection';
import { type RecordPickerPickableMorphItem } from '@/object-record/record-picker/types/RecordPickerPickableMorphItem';
import { CreateNewButton } from '@/ui/input/relation-picker/components/CreateNewButton';
@@ -19,20 +24,25 @@ import { DropdownMenuItemsContainer } from '@/ui/layout/dropdown/components/Drop
import { useSelectableList } from '@/ui/layout/selectable-list/hooks/useSelectableList';
import { useHotkeysOnFocusedElement } from '@/ui/utilities/hotkey/hooks/useHotkeysOnFocusedElement';
import { useAtomComponentStateCallbackState } from '@/ui/utilities/state/jotai/hooks/useAtomComponentStateCallbackState';
+import { useAtomComponentStateValue } from '@/ui/utilities/state/jotai/hooks/useAtomComponentStateValue';
import { Key } from 'ts-key-enum';
import { isDefined } from 'twenty-shared/utils';
import { t } from '@lingui/core/macro';
import { IconPlus } from 'twenty-ui/icon';
+import { logError } from '~/utils/logError';
type MultipleRecordPickerProps = {
onChange?: (morphItem: RecordPickerPickableMorphItem) => void;
onSubmit?: () => void;
- onCreate?: ((searchInput?: string) => void) | (() => void);
+ onCreate?: (options: {
+ searchInput?: string;
+ objectMetadataItemId: string;
+ }) => Promise<RecordPickerPickableMorphItem | undefined>;
+ isCreatePending?: boolean;
layoutDirection?: RecordPickerLayoutDirection;
componentInstanceId: string;
onClickOutside: () => void;
focusId: string;
- objectMetadataItemIdForCreate?: string;
dropdownWidth?: number;
};
@@ -44,9 +54,12 @@ export const MultipleRecordPicker = ({
layoutDirection = 'search-bar-on-bottom',
componentInstanceId,
focusId,
- objectMetadataItemIdForCreate,
dropdownWidth,
+ isCreatePending = false,
}: MultipleRecordPickerProps) => {
+ const [isSelectingCreateTarget, setIsSelectingCreateTarget] = useState(false);
+ // oxlint-disable-next-line twenty/no-state-useref
+ const createInFlightRef = useRef(false);
const selectableListComponentInstanceId =
getMultipleRecordPickerSelectableListId(componentInstanceId);
@@ -66,71 +79,157 @@ export const MultipleRecordPicker = ({
componentInstanceId,
);
+ const multipleRecordPickerSearchableObjectMetadataItems =
+ useAtomComponentStateValue(
+ multipleRecordPickerSearchableObjectMetadataItemsComponentState,
+ componentInstanceId,
+ );
+
+ const multipleRecordPickerIsLoadingState = useAtomComponentStateCallbackState(
+ multipleRecordPickerIsLoadingComponentState,
+ componentInstanceId,
+ );
+
+ const { objectPermissionsByObjectMetadataId } = useObjectPermissions();
+ const { performSearch } = useMultipleRecordPickerPerformSearch();
+
const store = useStore();
const resetState = useCallback(() => {
store.set(multipleRecordPickerPickableMorphItemsState, []);
store.set(multipleRecordPickerSearchFilterState, '');
+ setIsSelectingCreateTarget(false);
}, [
multipleRecordPickerPickableMorphItemsState,
multipleRecordPickerSearchFilterState,
store,
]);
- const handleSubmit = () => {
+ const handleSubmit = useCallback(() => {
onSubmit?.();
resetSelectedItem();
resetState();
- };
+ }, [onSubmit, resetSelectedItem, resetState]);
- const handleClickOutside = () => {
+ const handleClickOutside = useCallback(() => {
onClickOutside();
+ resetSelectedItem();
resetState();
- };
+ }, [onClickOutside, resetSelectedItem, resetState]);
+
+ const handleBackToRecordSelect = useCallback(() => {
+ resetSelectedItem();
+ setIsSelectingCreateTarget(false);
+ }, [resetSelectedItem]);
useHotkeysOnFocusedElement({
keys: [Key.Escape],
callback: () => {
- handleSubmit();
+ if (isSelectingCreateTarget) {
+ handleBackToRecordSelect();
+ } else {
+ handleSubmit();
+ }
},
focusId,
- dependencies: [handleSubmit],
+ dependencies: [
+ handleBackToRecordSelect,
+ handleSubmit,
+ isSelectingCreateTarget,
+ ],
});
const containerRef = useRef<HTMLDivElement>(null);
- const handleCreateNewButtonClick = useCallback(() => {
- const recordPickerSearchFilter = store.get(
- multipleRecordPickerSearchFilterState,
- );
- onCreate?.(recordPickerSearchFilter);
- }, [multipleRecordPickerSearchFilterState, onCreate, store]);
+ const creatableObjectMetadataItems = isDefined(onCreate)
+ ? multipleRecordPickerSearchableObjectMetadataItems.filter(
+ (objectMetadataItem) =>
+ canCreateRecordsForObjectMetadataItem({
+ objectPermissions: getObjectPermissionsForObject(
+ objectPermissionsByObjectMetadataId,
+ objectMetadataItem.id,
+ ),
+ objectMetadataItem,
+ }),
+ )
+ : [];
- const objectPermissionsForCreate = useObjectPermissionsForObject(
- objectMetadataItemIdForCreate ?? '',
- );
+ const handleCreate = async (objectMetadataItemId: string) => {
+ if (isCreatePending || createInFlightRef.current || !isDefined(onCreate)) {
+ return;
+ }
- const { objectMetadataItems } = useObjectMetadataItems();
+ createInFlightRef.current = true;
+ const searchInput = store.get(multipleRecordPickerSearchFilterState);
- const objectMetadataItemForCreate = objectMetadataItems.find(
- (objectMetadataItem) =>
- objectMetadataItem.id === objectMetadataItemIdForCreate,
- );
+ try {
+ const createdMorphItem = await onCreate({
+ searchInput,
+ objectMetadataItemId,
+ });
- const canCreateRecordForCreate =
- isDefined(objectMetadataItemForCreate) &&
- canCreateRecordsForObjectMetadataItem({
- objectPermissions: objectPermissionsForCreate,
- objectMetadataItem: objectMetadataItemForCreate,
- });
+ if (!isDefined(createdMorphItem)) {
+ return;
+ }
+
+ const currentMorphItems = store.get(
+ multipleRecordPickerPickableMorphItemsState,
+ );
+ const newMorphItems = upsertMorphItem(
+ currentMorphItems,
+ createdMorphItem,
+ );
+
+ store.set(multipleRecordPickerPickableMorphItemsState, newMorphItems);
+ resetSelectedItem();
+ setIsSelectingCreateTarget(false);
+
+ await performSearch({
+ multipleRecordPickerInstanceId: componentInstanceId,
+ forceSearchFilter: searchInput,
+ forceSearchableObjectMetadataItems:
+ multipleRecordPickerSearchableObjectMetadataItems,
+ forcePickableMorphItems: newMorphItems,
+ });
+
+ store.set(
+ multipleRecordPickerPickableMorphItemsState,
+ upsertMorphItem(
+ store.get(multipleRecordPickerPickableMorphItemsState),
+ createdMorphItem,
+ ),
+ );
+ } catch (error) {
+ store.set(multipleRecordPickerIsLoadingState, false);
+ logError(error);
+ } finally {
+ createInFlightRef.current = false;
+ }
+ };
+
+ const handleCreateNewButtonClick = () => {
+ if (isCreatePending) {
+ return;
+ }
+
+ if (creatableObjectMetadataItems.length === 1) {
+ void handleCreate(creatableObjectMetadataItems[0].id);
+ return;
+ }
+
+ resetSelectedItem();
+ setIsSelectingCreateTarget(true);
+ };
const createNewButtonSection =
- isDefined(onCreate) && canCreateRecordForCreate ? (
+ creatableObjectMetadataItems.length > 0 ? (
<DropdownMenuItemsContainer scrollable={false}>
<CreateNewButton
onClick={handleCreateNewButtonClick}
+ disabled={isCreatePending}
LeftIcon={IconPlus}
text={t`Add New`}
+ hasSubMenu={creatableObjectMetadataItems.length > 1}
/>
</DropdownMenuItemsContainer>
) : null;
@@ -144,23 +243,38 @@ export const MultipleRecordPicker = ({
onClickOutside={handleClickOutside}
/>
<DropdownContent ref={containerRef} widthInPixels={dropdownWidth}>
- {layoutDirection === 'search-bar-on-bottom' && (
- <>
- {createNewButtonSection}
- <MultipleRecordPickerItemsDisplay
- onChange={onChange}
- focusId={focusId}
- />
- </>
- )}
- <MultipleRecordPickerSearchInput />
- {layoutDirection === 'search-bar-on-top' && (
+ {isSelectingCreateTarget ? (
+ <MultipleRecordPickerCreateTargetSelect
+ objectMetadataItems={creatableObjectMetadataItems}
+ selectableListInstanceId={selectableListComponentInstanceId}
+ focusId={focusId}
+ disabled={isCreatePending}
+ onBack={handleBackToRecordSelect}
+ onSelect={(objectMetadataItemId) => {
+ void handleCreate(objectMetadataItemId);
+ }}
+ />
+ ) : (
<>
- <MultipleRecordPickerItemsDisplay
- onChange={onChange}
- focusId={focusId}
- />
- {createNewButtonSection}
+ {layoutDirection === 'search-bar-on-bottom' && (
+ <>
+ {createNewButtonSection}
+ <MultipleRecordPickerItemsDisplay
+ onChange={onChange}
+ focusId={focusId}
+ />
+ </>
+ )}
+ <MultipleRecordPickerSearchInput />
+ {layoutDirection === 'search-bar-on-top' && (
+ <>
+ <MultipleRecordPickerItemsDisplay
+ onChange={onChange}
+ focusId={focusId}
+ />
+ {createNewButtonSection}
+ </>
+ )}
</>
)}
</DropdownContent>
diff --git a/packages/twenty-front/src/modules/object-record/record-picker/multiple-record-picker/components/MultipleRecordPickerCreateTargetSelect.tsx b/packages/twenty-front/src/modules/object-record/record-picker/multiple-record-picker/components/MultipleRecordPickerCreateTargetSelect.tsx
new file mode 100644
index 00000000000..cf68ab0067d
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-record/record-picker/multiple-record-picker/components/MultipleRecordPickerCreateTargetSelect.tsx
@@ -0,0 +1,87 @@
+import { ObjectMetadataIcon } from '@/object-metadata/components/ObjectMetadataIcon';
+import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
+import { DropdownMenuHeader } from '@/ui/layout/dropdown/components/DropdownMenuHeader/DropdownMenuHeader';
+import { DropdownMenuHeaderLeftComponent } from '@/ui/layout/dropdown/components/DropdownMenuHeader/internal/DropdownMenuHeaderLeftComponent';
+import { DropdownMenuItemsContainer } from '@/ui/layout/dropdown/components/DropdownMenuItemsContainer';
+import { DropdownMenuSeparator } from '@/ui/layout/dropdown/components/DropdownMenuSeparator';
+import { useWorkspaceSurfaceScopedComponentInstanceId } from '@/ui/layout/hooks/useWorkspaceSurfaceScopedComponentInstanceId';
+import { SelectableList } from '@/ui/layout/selectable-list/components/SelectableList';
+import { SelectableListItem } from '@/ui/layout/selectable-list/components/SelectableListItem';
+import { selectedItemIdComponentState } from '@/ui/layout/selectable-list/states/selectedItemIdComponentState';
+import { useAtomComponentStateValue } from '@/ui/utilities/state/jotai/hooks/useAtomComponentStateValue';
+import { t } from '@lingui/core/macro';
+import { IconChevronLeft } from 'twenty-ui/icon';
+import { MenuItem } from 'twenty-ui/navigation';
+
+type MultipleRecordPickerCreateTargetSelectProps = {
+ objectMetadataItems: EnrichedObjectMetadataItem[];
+ selectableListInstanceId: string;
+ focusId: string;
+ disabled: boolean;
+ onBack: () => void;
+ onSelect: (objectMetadataItemId: string) => void;
+};
+
+export const MultipleRecordPickerCreateTargetSelect = ({
+ objectMetadataItems,
+ selectableListInstanceId,
+ focusId,
+ disabled,
+ onBack,
+ onSelect,
+}: MultipleRecordPickerCreateTargetSelectProps) => {
+ const scopedSelectableListInstanceId =
+ useWorkspaceSurfaceScopedComponentInstanceId(selectableListInstanceId);
+ const selectedItemId = useAtomComponentStateValue(
+ selectedItemIdComponentState,
+ scopedSelectableListInstanceId,
+ );
+
+ const handleSelect = (objectMetadataItemId: string) => {
+ if (!disabled) {
+ onSelect(objectMetadataItemId);
+ }
+ };
+
+ return (
+ <>
+ <DropdownMenuHeader
+ StartComponent={
+ <DropdownMenuHeaderLeftComponent
+ Icon={IconChevronLeft}
+ onClick={onBack}
+ />
+ }
+ >
+ {t`Select a record type`}
+ </DropdownMenuHeader>
+ <DropdownMenuSeparator />
+ <DropdownMenuItemsContainer hasMaxHeight>
+ <SelectableList
+ selectableListInstanceId={selectableListInstanceId}
+ selectableItemIdArray={objectMetadataItems.map(({ id }) => id)}
+ focusId={focusId}
+ shouldPreselectFirstItem
+ >
+ {objectMetadataItems.map((objectMetadataItem) => (
+ <SelectableListItem
+ key={objectMetadataItem.id}
+ itemId={objectMetadataItem.id}
+ onEnter={() => handleSelect(objectMetadataItem.id)}
+ >
+ <MenuItem
+ LeftComponent={
+ <ObjectMetadataIcon objectMetadataItem={objectMetadataItem} />
+ }
+ text={objectMetadataItem.labelSingular}
+ focused={selectedItemId === objectMetadataItem.id}
+ disabled={disabled}
+ onClick={() => handleSelect(objectMetadataItem.id)}
+ />
+ </SelectableListItem>
+ ))}
+ </SelectableList>
+ </DropdownMenuItemsContainer>
+ </>
+ );
+};
diff --git a/packages/twenty-front/src/modules/object-record/record-picker/multiple-record-picker/utils/__tests__/upsertMorphItem.test.ts b/packages/twenty-front/src/modules/object-record/record-picker/multiple-record-picker/utils/__tests__/upsertMorphItem.test.ts
new file mode 100644
index 00000000000..ce75b3a580f
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-record/record-picker/multiple-record-picker/utils/__tests__/upsertMorphItem.test.ts
@@ -0,0 +1,37 @@
+import { upsertMorphItem } from '@/object-record/record-picker/multiple-record-picker/utils/upsertMorphItem';
+
+describe('upsertMorphItem', () => {
+ const createdItem = {
+ recordId: 'new-record-id',
+ objectMetadataId: 'object-metadata-id',
+ isSelected: true,
+ isMatchingSearchFilter: true,
+ };
+
+ it('replaces stale search state without changing its sorted position', () => {
+ const firstItem = {
+ ...createdItem,
+ recordId: 'first-record-id',
+ };
+
+ expect(
+ upsertMorphItem(
+ [firstItem, { ...createdItem, isSelected: false }],
+ createdItem,
+ ),
+ ).toEqual([firstItem, createdItem]);
+ });
+
+ it('prepends a missing selected item', () => {
+ const existingItem = {
+ ...createdItem,
+ recordId: 'existing-record-id',
+ isSelected: false,
+ };
+
+ expect(upsertMorphItem([existingItem], createdItem)).toEqual([
+ createdItem,
+ existingItem,
+ ]);
+ });
+});
diff --git a/packages/twenty-front/src/modules/object-record/record-picker/multiple-record-picker/utils/upsertMorphItem.ts b/packages/twenty-front/src/modules/object-record/record-picker/multiple-record-picker/utils/upsertMorphItem.ts
new file mode 100644
index 00000000000..bbb66c2128d
--- /dev/null
+++ b/packages/twenty-front/src/modules/object-record/record-picker/multiple-record-picker/utils/upsertMorphItem.ts
@@ -0,0 +1,18 @@
+import { type RecordPickerPickableMorphItem } from '@/object-record/record-picker/types/RecordPickerPickableMorphItem';
+
+export const upsertMorphItem = (
+ morphItems: RecordPickerPickableMorphItem[],
+ morphItem: RecordPickerPickableMorphItem,
+) => {
+ const existingIndex = morphItems.findIndex(
+ ({ recordId }) => recordId === morphItem.recordId,
+ );
+
+ if (existingIndex === -1) {
+ return [morphItem, ...morphItems];
+ }
+
+ return morphItems.map((existingItem, index) =>
+ index === existingIndex ? morphItem : existingItem,
+ );
+};
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 6aa9b0a4464..3cc9b131bcc 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
@@ -37,16 +37,23 @@ export const RecordTableCellFieldContextGeneric = ({
const {
objectPermissionsByObjectMetadataId,
+ fieldMetadataItemByFieldMetadataItemId,
fieldDefinitionByFieldMetadataItemId,
} = useRecordIndexContextOrThrow();
const fieldDefinition =
fieldDefinitionByFieldMetadataItemId[recordField.fieldMetadataItemId];
+ const fieldMetadataItem =
+ fieldMetadataItemByFieldMetadataItemId[recordField.fieldMetadataItemId];
const updateRecord = useContext(RecordTableUpdateContext);
const getIsMetadataItemFromStandardApplication =
useGetIsMetadataItemFromStandardApplication();
+ if (!isDefined(fieldMetadataItem)) {
+ return null;
+ }
+
let hasObjectReadPermissions = objectPermissions.canReadObjectRecords;
let isInvalidJunctionRelation = false;
@@ -125,10 +132,7 @@ export const RecordTableCellFieldContextGeneric = ({
applicationId: fieldDefinition.metadata.applicationId,
}),
objectPermissions,
- fieldMetadataItem: {
- id: fieldDefinition.fieldMetadataId,
- isUIEditable: fieldDefinition.metadata.isUIEditable ?? true,
- },
+ fieldMetadataItem,
fieldDefinition,
objectPermissionsByObjectMetadataId,
}),
diff --git a/packages/twenty-front/src/modules/object-record/record-table/record-table-cell/components/RecordTableCellFieldContextLabelIdentifier.tsx b/packages/twenty-front/src/modules/object-record/record-table/record-table-cell/components/RecordTableCellFieldContextLabelIdentifier.tsx
index e72ace579f9..b92f0cb990c 100644
--- a/packages/twenty-front/src/modules/object-record/record-table/record-table-cell/components/RecordTableCellFieldContextLabelIdentifier.tsx
+++ b/packages/twenty-front/src/modules/object-record/record-table/record-table-cell/components/RecordTableCellFieldContextLabelIdentifier.tsx
@@ -10,6 +10,7 @@ import { RecordTableUpdateContext } from '@/object-record/record-table/contexts/
import { isRecordTableCellsNonEditableComponentState } from '@/object-record/record-table/states/isRecordTableCellsNonEditableComponentState';
import { useAtomComponentStateValue } from '@/ui/utilities/state/jotai/hooks/useAtomComponentStateValue';
import { useContext, type ReactNode } from 'react';
+import { isDefined } from 'twenty-shared/utils';
type RecordTableCellFieldContextLabelIdentifierProps = {
children: ReactNode;
@@ -20,6 +21,7 @@ export const RecordTableCellFieldContextLabelIdentifier = ({
}: RecordTableCellFieldContextLabelIdentifierProps) => {
const {
objectPermissionsByObjectMetadataId,
+ fieldMetadataItemByFieldMetadataItemId,
fieldDefinitionByFieldMetadataItemId,
} = useRecordIndexContextOrThrow();
const { recordId, isRecordReadOnly, rowIndex } =
@@ -46,6 +48,12 @@ export const RecordTableCellFieldContextLabelIdentifier = ({
const fieldDefinition =
fieldDefinitionByFieldMetadataItemId[recordField.fieldMetadataItemId];
+ const fieldMetadataItem =
+ fieldMetadataItemByFieldMetadataItemId[recordField.fieldMetadataItemId];
+
+ if (!isDefined(fieldMetadataItem)) {
+ return null;
+ }
const handleChipClick = () => {
onRecordIdentifierClick?.(rowIndex, recordId);
@@ -69,10 +77,7 @@ export const RecordTableCellFieldContextLabelIdentifier = ({
applicationId: fieldDefinition.metadata.applicationId,
}),
objectPermissions,
- fieldMetadataItem: {
- id: recordField.fieldMetadataItemId,
- isUIEditable: fieldDefinition.metadata.isUIEditable ?? true,
- },
+ fieldMetadataItem,
fieldDefinition,
objectPermissionsByObjectMetadataId,
}),
diff --git a/packages/twenty-front/src/modules/object-record/utils/__tests__/computeOptimisticRecordFromInput.test.ts b/packages/twenty-front/src/modules/object-record/utils/__tests__/computeOptimisticRecordFromInput.test.ts
index 4f43c2c5e77..fe64e9f424c 100644
--- a/packages/twenty-front/src/modules/object-record/utils/__tests__/computeOptimisticRecordFromInput.test.ts
+++ b/packages/twenty-front/src/modules/object-record/utils/__tests__/computeOptimisticRecordFromInput.test.ts
@@ -302,4 +302,19 @@ describe('computeOptimisticRecordFromInput', () => {
city: 'Paris',
});
});
+
+ it('preserves nested create operations on to-one relations', () => {
+ const personObjectMetadataItem = getMockObjectMetadataItemOrThrow('person');
+
+ expect(
+ sanitizeRecordInput({
+ objectMetadataItem: personObjectMetadataItem,
+ recordInput: {
+ company: { create: { id: 'new-company-id', name: 'New company' } },
+ },
+ }),
+ ).toEqual({
+ company: { create: { id: 'new-company-id', name: 'New company' } },
+ });
+ });
});
diff --git a/packages/twenty-front/src/modules/object-record/utils/sanitizeRecordInput.ts b/packages/twenty-front/src/modules/object-record/utils/sanitizeRecordInput.ts
index b5ac39d2ab0..15b875bbd6b 100644
--- a/packages/twenty-front/src/modules/object-record/utils/sanitizeRecordInput.ts
+++ b/packages/twenty-front/src/modules/object-record/utils/sanitizeRecordInput.ts
@@ -67,7 +67,8 @@ export const sanitizeRecordInput = ({
if (
isDefined(fieldMetadataItem) &&
isManyToOneRelationField(fieldMetadataItem) &&
- !isDefined(recordInput[fieldMetadataItem.name]?.connect?.where)
+ !isDefined(recordInput[fieldMetadataItem.name]?.connect?.where) &&
+ !isDefined(recordInput[fieldMetadataItem.name]?.create)
) {
return undefined;
}
diff --git a/packages/twenty-front/src/modules/page-layout/widgets/components/WidgetActionFieldEdit.tsx b/packages/twenty-front/src/modules/page-layout/widgets/components/WidgetActionFieldEdit.tsx
index f4aad03013a..44341acf1fc 100644
--- a/packages/twenty-front/src/modules/page-layout/widgets/components/WidgetActionFieldEdit.tsx
+++ b/packages/twenty-front/src/modules/page-layout/widgets/components/WidgetActionFieldEdit.tsx
@@ -99,12 +99,7 @@ export const WidgetActionFieldEdit = ({
}),
isFieldFromStandardApplication:
getIsMetadataItemFromStandardApplication(fieldMetadataItem),
- fieldMetadataItem: {
- id: fieldMetadataItem.id,
- isUIEditable: fieldMetadataItem.isUIEditable ?? true,
- type: fieldMetadataItem.type,
- settings: fieldMetadataItem.settings,
- },
+ fieldMetadataItem,
fieldDefinition,
objectPermissionsByObjectMetadataId,
}),
diff --git a/packages/twenty-front/src/modules/page-layout/widgets/field/components/FieldWidgetDisplay.tsx b/packages/twenty-front/src/modules/page-layout/widgets/field/components/FieldWidgetDisplay.tsx
index 6cf0c1e46b0..a3fd1325622 100644
--- a/packages/twenty-front/src/modules/page-layout/widgets/field/components/FieldWidgetDisplay.tsx
+++ b/packages/twenty-front/src/modules/page-layout/widgets/field/components/FieldWidgetDisplay.tsx
@@ -100,12 +100,7 @@ export const FieldWidgetDisplay = ({
}),
isFieldFromStandardApplication:
getIsMetadataItemFromStandardApplication(fieldMetadataItem),
- fieldMetadataItem: {
- id: fieldMetadataItem.id,
- isUIEditable: fieldMetadataItem.isUIEditable ?? true,
- type: fieldMetadataItem.type,
- settings: fieldMetadataItem.settings,
- },
+ fieldMetadataItem,
fieldDefinition,
objectPermissionsByObjectMetadataId,
}),
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 650e837ea03..c5369406711 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
@@ -84,12 +84,7 @@ export const useFieldWidgetActionVisibility = ({
}),
isFieldFromStandardApplication:
getIsMetadataItemFromStandardApplication(fieldMetadataItem),
- fieldMetadataItem: {
- id: fieldMetadataItem.id,
- isUIEditable: fieldMetadataItem.isUIEditable ?? true,
- type: fieldMetadataItem.type,
- settings: fieldMetadataItem.settings,
- },
+ fieldMetadataItem,
fieldDefinition,
objectPermissionsByObjectMetadataId,
});
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 5d7c394cac9..8b65aac2b2f 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
@@ -74,12 +74,7 @@ export const FieldsWidgetFieldItem = ({
}),
isFieldFromStandardApplication:
getIsMetadataItemFromStandardApplication(fieldMetadataItem),
- fieldMetadataItem: {
- id: fieldMetadataItem.id,
- isUIEditable: fieldMetadataItem.isUIEditable ?? true,
- type: fieldMetadataItem.type,
- settings: fieldMetadataItem.settings,
- },
+ fieldMetadataItem,
fieldDefinition,
objectPermissionsByObjectMetadataId,
}),
diff --git a/packages/twenty-front/src/pages/settings/data-model/utils/__tests__/computeMetadataNameFromLabel.test.ts b/packages/twenty-front/src/pages/settings/data-model/utils/__tests__/computeMetadataNameFromLabel.test.ts
index a655d6a16e1..b4c054a0d60 100644
--- a/packages/twenty-front/src/pages/settings/data-model/utils/__tests__/computeMetadataNameFromLabel.test.ts
+++ b/packages/twenty-front/src/pages/settings/data-model/utils/__tests__/computeMetadataNameFromLabel.test.ts
@@ -23,6 +23,11 @@ describe('computeMetadataNameFromLabel', () => {
expect(computeMetadataNameFromLabel('Plan')).toEqual('planCustom');
expect(computeMetadataNameFromLabel('Event')).toEqual('eventCustom');
expect(computeMetadataNameFromLabel('User')).toEqual('userCustom');
+ expect(computeMetadataNameFromLabel('Connect')).toEqual('connectCustom');
+ expect(computeMetadataNameFromLabel('Create')).toEqual('createCustom');
+ expect(computeMetadataNameFromLabel('Disconnect')).toEqual(
+ 'disconnectCustom',
+ );
});
it('adds "Custom" suffix to plural reserved keywords', () => {
diff --git a/packages/twenty-server/src/engine/api/common/common-args-processors/data-arg-processor/data-arg-processor.service.ts b/packages/twenty-server/src/engine/api/common/common-args-processors/data-arg-processor/data-arg-processor.service.ts
index 1a376773d9b..508f8518b43 100644
--- a/packages/twenty-server/src/engine/api/common/common-args-processors/data-arg-processor/data-arg-processor.service.ts
+++ b/packages/twenty-server/src/engine/api/common/common-args-processors/data-arg-processor/data-arg-processor.service.ts
@@ -256,7 +256,7 @@ export class DataArgProcessorService {
if (isDefined(joinColumnName) && !isRelationNestedOperation(value)) {
throw new CommonQueryRunnerException(
- `Relation "${key}" requires connect or disconnect operation`,
+ `Relation "${key}" requires create, connect, or disconnect operation`,
CommonQueryRunnerExceptionCode.INVALID_ARGS_DATA,
{ userFriendlyMessage: STANDARD_ERROR_MESSAGE },
);
diff --git a/packages/twenty-server/src/engine/api/common/common-args-processors/data-arg-processor/utils/is-relation-nested-operation.util.ts b/packages/twenty-server/src/engine/api/common/common-args-processors/data-arg-processor/utils/is-relation-nested-operation.util.ts
index 3527d40a9f2..652ebd2a423 100644
--- a/packages/twenty-server/src/engine/api/common/common-args-processors/data-arg-processor/utils/is-relation-nested-operation.util.ts
+++ b/packages/twenty-server/src/engine/api/common/common-args-processors/data-arg-processor/utils/is-relation-nested-operation.util.ts
@@ -2,7 +2,7 @@ import { isObject } from '@sniptt/guards';
import { RELATION_NESTED_QUERY_KEYWORDS } from 'twenty-shared/constants';
import { isDefined } from 'twenty-shared/utils';
-const { CONNECT, DISCONNECT } = RELATION_NESTED_QUERY_KEYWORDS;
+const { CONNECT, CREATE, DISCONNECT } = RELATION_NESTED_QUERY_KEYWORDS;
export const isRelationNestedOperation = (value: unknown): boolean => {
if (!isObject(value)) {
@@ -13,6 +13,7 @@ export const isRelationNestedOperation = (value: unknown): boolean => {
return (
(CONNECT in obj && isDefined(obj[CONNECT])) ||
+ (CREATE in obj && isDefined(obj[CREATE])) ||
(DISCONNECT in obj && isDefined(obj[DISCONNECT]))
);
};
diff --git a/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/process-nested-relations.helper.ts b/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/process-nested-relations.helper.ts
index a7f5455da78..b7a066ac38f 100644
--- a/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/process-nested-relations.helper.ts
+++ b/packages/twenty-server/src/engine/api/common/common-nested-relations-processor/process-nested-relations.helper.ts
@@ -53,6 +53,7 @@ type ProcessNestedRelationsArgs<T extends ObjectRecord = ObjectRecord> = {
authContext: WorkspaceAuthContext;
useReplica?: boolean;
rolePermissionConfig?: RolePermissionConfig;
+ repository?: WorkspaceRepository;
// oxlint-disable-next-line typescript/no-explicit-any
selectedFields: Record<string, any>;
};
@@ -85,6 +86,7 @@ export class ProcessNestedRelationsHelper {
authContext,
useReplica = false,
rolePermissionConfig,
+ repository,
selectedFields,
}: ProcessNestedRelationsArgs<T>,
relationQueryLimiter: ConcurrencyLimiter,
@@ -104,6 +106,7 @@ export class ProcessNestedRelationsHelper {
authContext,
useReplica,
rolePermissionConfig,
+ repository,
relationQueryLimiter,
selectedFields:
selectedFields[sourceFieldName] instanceof Object
@@ -128,6 +131,7 @@ export class ProcessNestedRelationsHelper {
authContext,
useReplica,
rolePermissionConfig,
+ repository,
relationQueryLimiter,
selectedFields,
}: {
@@ -144,6 +148,7 @@ export class ProcessNestedRelationsHelper {
authContext: WorkspaceAuthContext;
useReplica: boolean;
rolePermissionConfig?: RolePermissionConfig;
+ repository?: WorkspaceRepository;
relationQueryLimiter: ConcurrencyLimiter;
selectedFields: Record<string, unknown>;
}): Promise<void> {
@@ -192,11 +197,13 @@ export class ProcessNestedRelationsHelper {
fieldMaps,
});
- const targetObjectRepository = this.workspaceOrmManager.getRepository(
- targetObjectMetadata.nameSingular,
- rolePermissionConfig,
- { useReplica },
- );
+ const targetObjectRepository = repository
+ ? repository.getRepositoryForObjectMetadataId(targetObjectMetadata.id)
+ : this.workspaceOrmManager.getRepository(
+ targetObjectMetadata.nameSingular,
+ rolePermissionConfig,
+ { useReplica },
+ );
const targetObjectNameSingular = targetObjectMetadata.nameSingular;
@@ -305,6 +312,7 @@ export class ProcessNestedRelationsHelper {
authContext,
useReplica,
rolePermissionConfig,
+ repository,
selectedFields,
},
relationQueryLimiter,
diff --git a/packages/twenty-server/src/engine/api/common/common-query-runners/common-base-query-runner.service.ts b/packages/twenty-server/src/engine/api/common/common-query-runners/common-base-query-runner.service.ts
index a3ecfd427c9..61348a953d4 100644
--- a/packages/twenty-server/src/engine/api/common/common-query-runners/common-base-query-runner.service.ts
+++ b/packages/twenty-server/src/engine/api/common/common-query-runners/common-base-query-runner.service.ts
@@ -7,7 +7,6 @@ import {
type ObjectRecord,
} from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
-import { type ObjectLiteral } from 'typeorm';
import { type ObjectRecordFilter } from 'src/engine/api/graphql/workspace-query-builder/interfaces/object-record.interface';
@@ -141,7 +140,9 @@ export abstract class CommonBaseQueryRunnerService<
flatFieldMetadataMaps,
} = queryRunnerContext;
- await this.throttleQueryExecution(authContext);
+ if ((queryRunnerContext.nestedOperationDepth ?? 0) === 0) {
+ await this.throttleQueryExecution(authContext);
+ }
this.recordApiUsage(authContext);
@@ -268,6 +269,7 @@ export abstract class CommonBaseQueryRunnerService<
flatObjectMetadata: queryRunnerContext.flatObjectMetadata,
flatObjectMetadataMaps: queryRunnerContext.flatObjectMetadataMaps,
flatFieldMetadataMaps: queryRunnerContext.flatFieldMetadataMaps,
+ transactionScope: queryRunnerContext.transactionScope,
});
}
@@ -278,6 +280,7 @@ export abstract class CommonBaseQueryRunnerService<
flatObjectMetadata,
flatObjectMetadataMaps,
flatFieldMetadataMaps,
+ transactionScope,
}: {
results: Output;
operationName: CommonQueryNames;
@@ -285,6 +288,7 @@ export abstract class CommonBaseQueryRunnerService<
flatObjectMetadata: FlatObjectMetadata;
flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
flatFieldMetadataMaps: FlatEntityMaps<OrmFlatFieldMetadata>;
+ transactionScope: CommonBaseQueryRunnerContext['transactionScope'];
}): Promise<Output> {
const resultWithGetters = await this.processQueryResult(
results,
@@ -294,12 +298,19 @@ export abstract class CommonBaseQueryRunnerService<
authContext,
);
- await this.workspaceQueryHookService.executePostQueryHooks(
- authContext,
- flatObjectMetadata.nameSingular,
- operationName,
- resultWithGetters as QueryResultFieldValue,
- );
+ const executePostQueryHooks = () =>
+ this.workspaceQueryHookService.executePostQueryHooks(
+ authContext,
+ flatObjectMetadata.nameSingular,
+ operationName,
+ resultWithGetters as QueryResultFieldValue,
+ );
+
+ if (isDefined(transactionScope)) {
+ transactionScope.afterCommit(executePostQueryHooks);
+ } else {
+ await executePostQueryHooks();
+ }
return resultWithGetters as Output;
}
@@ -364,11 +375,16 @@ export abstract class CommonBaseQueryRunnerService<
);
}
- const repository = this.workspaceOrmManager.getRepository<ObjectLiteral>(
- queryRunnerContext.flatObjectMetadata.nameSingular,
- rolePermissionConfig,
- { useReplica: this.isReadOnly },
- );
+ const repository = isDefined(queryRunnerContext.transactionScope)
+ ? queryRunnerContext.transactionScope.getRepository<ObjectRecord>(
+ queryRunnerContext.flatObjectMetadata.nameSingular,
+ rolePermissionConfig,
+ )
+ : this.workspaceOrmManager.getRepository<ObjectRecord>(
+ queryRunnerContext.flatObjectMetadata.nameSingular,
+ rolePermissionConfig,
+ { useReplica: this.isReadOnly },
+ );
return {
...queryRunnerContext,
@@ -383,11 +399,10 @@ export abstract class CommonBaseQueryRunnerService<
// and everything else the primary, keeping root read and nested-relation
// loading consistent.
protected getReadRepository({
- rolePermissionConfig,
- flatObjectMetadata,
+ repository,
}: Pick<
CommonExtendedQueryRunnerContext,
- 'rolePermissionConfig' | 'flatObjectMetadata'
+ 'repository'
>): WorkspaceRepository {
this.metricsService.incrementCounterBy({
key: MetricsKeys.OrmV2ReadPathUsed,
@@ -395,20 +410,14 @@ export abstract class CommonBaseQueryRunnerService<
attributes: { operation: this.operationName },
});
- return this.workspaceOrmManager.getRepository(
- flatObjectMetadata.nameSingular,
- rolePermissionConfig,
- { useReplica: this.isReadOnly },
- );
+ return repository;
}
- // Writes always hit the primary, so useReplica is pinned false regardless of isReadOnly.
protected getWriteRepository({
- rolePermissionConfig,
- flatObjectMetadata,
+ repository,
}: Pick<
CommonExtendedQueryRunnerContext,
- 'rolePermissionConfig' | 'flatObjectMetadata'
+ 'repository'
>): WorkspaceRepository {
this.metricsService.incrementCounterBy({
key: MetricsKeys.OrmV2WritePathUsed,
@@ -416,10 +425,7 @@ export abstract class CommonBaseQueryRunnerService<
attributes: { operation: this.operationName },
});
- return this.workspaceOrmManager.getRepository(
- flatObjectMetadata.nameSingular,
- rolePermissionConfig,
- );
+ return repository;
}
protected async runFilteredMutation({
@@ -480,20 +486,20 @@ export abstract class CommonBaseQueryRunnerService<
records,
queryRunnerContext,
writeRepository,
+ createRecords,
}: {
records: Partial<ObjectRecord>[];
queryRunnerContext: CommonExtendedQueryRunnerContext;
writeRepository: WorkspaceRepository;
+ createRecords?: (options: {
+ targetObjectMetadata: FlatObjectMetadata;
+ records: Partial<ObjectRecord>[];
+ }) => Promise<ObjectRecord[]>;
}): Promise<Partial<ObjectRecord>[]> {
- const { flatObjectMetadata, flatFieldMetadataMaps, rolePermissionConfig } =
- queryRunnerContext;
+ const { flatObjectMetadata, flatFieldMetadataMaps } = queryRunnerContext;
const nameSingular = flatObjectMetadata.nameSingular;
- const relationNestedQueries = new RelationNestedQueries(
- writeRepository.getInternalContext(),
- this.workspaceOrmManager,
- rolePermissionConfig,
- );
+ const relationNestedQueries = new RelationNestedQueries(writeRepository);
const relationNestedConfig =
relationNestedQueries.prepareNestedRelationQueries(records, nameSingular);
@@ -506,6 +512,8 @@ export abstract class CommonBaseQueryRunnerService<
await relationNestedQueries.processRelationNestedQueries({
entities: records,
relationNestedConfig,
+ target: nameSingular,
+ createRecords,
});
const { fieldIdByName } = buildFieldMapsFromFlatObjectMetadata(
diff --git a/packages/twenty-server/src/engine/api/common/common-query-runners/common-create-many-query-runner/common-create-many-query-runner.service.ts b/packages/twenty-server/src/engine/api/common/common-query-runners/common-create-many-query-runner/common-create-many-query-runner.service.ts
index b02ace091bc..514a92c5fd4 100644
--- a/packages/twenty-server/src/engine/api/common/common-query-runners/common-create-many-query-runner/common-create-many-query-runner.service.ts
+++ b/packages/twenty-server/src/engine/api/common/common-query-runners/common-create-many-query-runner/common-create-many-query-runner.service.ts
@@ -48,6 +48,10 @@ import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object
import { assertMutationNotOnRemoteObject } from 'src/engine/metadata-modules/object-metadata/utils/assert-mutation-not-on-remote-object.util';
import { WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace-repository';
import { RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';
+import { containsNestedRelationCreate } from 'src/engine/twenty-orm/utils/contains-nested-relation-create.util';
+import { getNestedRelationFieldNames } from 'src/engine/twenty-orm/utils/get-nested-relation-field-names.util';
+
+const MAX_NESTED_RELATION_CREATE_DEPTH = 5;
@Injectable()
export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerService<
@@ -64,6 +68,29 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSer
args: CommonExtendedInput<CreateManyQueryArgs>,
queryRunnerContext: CommonExtendedQueryRunnerContext,
): Promise<ObjectRecord[]> {
+ if (
+ !isDefined(queryRunnerContext.transactionScope) &&
+ containsNestedRelationCreate(
+ args.data,
+ getNestedRelationFieldNames({
+ flatObjectMetadata: queryRunnerContext.flatObjectMetadata,
+ flatFieldMetadataMaps: queryRunnerContext.flatFieldMetadataMaps,
+ }),
+ )
+ ) {
+ return this.workspaceOrmManager.runInWorkspaceTransaction(
+ (transactionScope) =>
+ this.run(args, {
+ ...queryRunnerContext,
+ transactionScope,
+ repository: transactionScope.getRepository(
+ queryRunnerContext.flatObjectMetadata.nameSingular,
+ queryRunnerContext.rolePermissionConfig,
+ ),
+ }),
+ );
+ }
+
if (args.data.length > QUERY_MAX_RECORDS) {
throw new CommonQueryRunnerException(
`Maximum number of records to upsert is ${QUERY_MAX_RECORDS}.`,
@@ -120,6 +147,7 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSer
flatFieldMetadataMaps,
authContext,
rolePermissionConfig,
+ repository,
nestedRelationsReadPathOptions: this.getNestedRelationsReadPathOptions(),
});
@@ -134,6 +162,7 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSer
flatFieldMetadataMaps,
authContext,
rolePermissionConfig,
+ repository,
nestedRelationsReadPathOptions,
}: {
args: CommonExtendedInput<CreateManyQueryArgs>;
@@ -143,6 +172,7 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSer
flatFieldMetadataMaps: FlatEntityMaps<OrmFlatFieldMetadata>;
authContext: WorkspaceAuthContext;
rolePermissionConfig?: RolePermissionConfig;
+ repository: WorkspaceRepository<ObjectRecord>;
nestedRelationsReadPathOptions: NestedRelationsReadPathOptions;
}): Promise<void> {
if (!args.selectedFieldsResult.relations) {
@@ -161,6 +191,7 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSer
limit: QUERY_MAX_RECORDS,
authContext,
rolePermissionConfig,
+ repository,
selectedFields: args.selectedFieldsResult.select,
...nestedRelationsReadPathOptions,
});
@@ -238,7 +269,7 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSer
const writeRepository = this.getWriteRepository(queryRunnerContext);
return writeRepository.runInsert({
- records: await this.resolveNestedRelations({
+ records: await this.resolveNestedRelationsForCreate({
records: args.data,
queryRunnerContext,
writeRepository,
@@ -461,7 +492,7 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSer
}));
const writeRepository = this.getWriteRepository(queryRunnerContext);
- const resolvedData = await this.resolveNestedRelations({
+ const resolvedData = await this.resolveNestedRelationsForCreate({
records: updateInputs.map((input) => input.data),
queryRunnerContext,
writeRepository,
@@ -501,7 +532,7 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSer
const writeRepository = this.getWriteRepository(queryRunnerContext);
const insertResult = await writeRepository.runInsert({
- records: await this.resolveNestedRelations({
+ records: await this.resolveNestedRelationsForCreate({
records: recordsToInsert,
queryRunnerContext,
writeRepository,
@@ -514,6 +545,67 @@ export class CommonCreateManyQueryRunnerService extends CommonBaseQueryRunnerSer
result.raw.push(...insertResult.raw);
}
+ private resolveNestedRelationsForCreate({
+ records,
+ queryRunnerContext,
+ writeRepository,
+ }: {
+ records: Partial<ObjectRecord>[];
+ queryRunnerContext: CommonExtendedQueryRunnerContext;
+ writeRepository: WorkspaceRepository;
+ }): Promise<Partial<ObjectRecord>[]> {
+ const nestedCreateRecordsCounter =
+ (queryRunnerContext.nestedCreateRecordsCounter ??= { count: 0 });
+
+ return this.resolveNestedRelations({
+ records,
+ queryRunnerContext,
+ writeRepository,
+ createRecords: async ({
+ targetObjectMetadata,
+ records: targetRecords,
+ }) => {
+ nestedCreateRecordsCounter.count += targetRecords.length;
+
+ if (nestedCreateRecordsCounter.count > QUERY_MAX_RECORDS) {
+ throw new CommonQueryRunnerException(
+ `Maximum number of nested records to create is ${QUERY_MAX_RECORDS}.`,
+ CommonQueryRunnerExceptionCode.TOO_MANY_RECORDS_TO_UPDATE,
+ {
+ userFriendlyMessage: msg`Maximum number of nested records to create is ${QUERY_MAX_RECORDS}.`,
+ },
+ );
+ }
+
+ const nestedOperationDepth =
+ (queryRunnerContext.nestedOperationDepth ?? 0) + 1;
+
+ if (nestedOperationDepth > MAX_NESTED_RELATION_CREATE_DEPTH) {
+ throw new CommonQueryRunnerException(
+ `Nested relation create depth cannot exceed ${MAX_NESTED_RELATION_CREATE_DEPTH}`,
+ CommonQueryRunnerExceptionCode.INVALID_ARGS_DATA,
+ { userFriendlyMessage: STANDARD_ERROR_MESSAGE },
+ );
+ }
+
+ const { results } = await this.execute(
+ {
+ data: targetRecords,
+ selectedFields: { id: true },
+ },
+ {
+ ...queryRunnerContext,
+ flatObjectMetadata: targetObjectMetadata,
+ nestedCreateRecordsCounter,
+ nestedOperationDepth,
+ },
+ );
+
+ return results;
+ },
+ });
+ }
+
private async fetchUpsertedRecords({
objectRecords,
flatObjectMetadata,
diff --git a/packages/twenty-server/src/engine/api/common/types/common-base-query-runner-context.type.ts b/packages/twenty-server/src/engine/api/common/types/common-base-query-runner-context.type.ts
index 3c015f766d3..f9a30e77738 100644
--- a/packages/twenty-server/src/engine/api/common/types/common-base-query-runner-context.type.ts
+++ b/packages/twenty-server/src/engine/api/common/types/common-base-query-runner-context.type.ts
@@ -4,6 +4,7 @@ import { type OrmFlatFieldMetadata } from 'src/engine/metadata-modules/flat-fiel
import { type FlatIndexMetadata } from 'src/engine/metadata-modules/flat-index-metadata/types/flat-index-metadata.type';
import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
import { type RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';
+import { type WorkspaceTransactionScope } from 'src/engine/twenty-orm/types/workspace-transaction-scope.type';
export type CommonBaseQueryRunnerContext = {
authContext: WorkspaceAuthContext;
@@ -13,4 +14,7 @@ export type CommonBaseQueryRunnerContext = {
flatIndexMaps?: FlatEntityMaps<FlatIndexMetadata>;
objectIdByNameSingular: Record<string, string>;
rolePermissionConfig?: RolePermissionConfig;
+ transactionScope?: WorkspaceTransactionScope;
+ nestedOperationDepth?: number;
+ nestedCreateRecordsCounter?: { count: number };
};
diff --git a/packages/twenty-server/src/engine/api/common/types/common-extended-query-runner-context.type.ts b/packages/twenty-server/src/engine/api/common/types/common-extended-query-runner-context.type.ts
index 733681f75f6..bf11e437dde 100644
--- a/packages/twenty-server/src/engine/api/common/types/common-extended-query-runner-context.type.ts
+++ b/packages/twenty-server/src/engine/api/common/types/common-extended-query-runner-context.type.ts
@@ -1,5 +1,4 @@
-import { type ObjectLiteral } from 'typeorm';
-import { type FeatureFlagKey } from 'twenty-shared/types';
+import { type FeatureFlagKey, type ObjectRecord } from 'twenty-shared/types';
import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
import { type CommonBaseQueryRunnerContext } from 'src/engine/api/common/types/common-base-query-runner-context.type';
@@ -13,7 +12,7 @@ export type CommonExtendedQueryRunnerContext = Omit<
> & {
authContext: WorkspaceAuthContext;
rolePermissionConfig: RolePermissionConfig;
- repository: WorkspaceRepository<ObjectLiteral>;
+ repository: WorkspaceRepository<ObjectRecord>;
commonQueryParser: GraphqlQueryParser;
featureFlagsMap: Record<FeatureFlagKey, boolean>;
};
diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-schema-builder/graphql-type-generators/input-types/relation-connect-gql-input-type.generator.ts b/packages/twenty-server/src/engine/api/graphql/workspace-schema-builder/graphql-type-generators/input-types/relation-connect-gql-input-type.generator.ts
index 79146dc9b48..934e930115b 100644
--- a/packages/twenty-server/src/engine/api/graphql/workspace-schema-builder/graphql-type-generators/input-types/relation-connect-gql-input-type.generator.ts
+++ b/packages/twenty-server/src/engine/api/graphql/workspace-schema-builder/graphql-type-generators/input-types/relation-connect-gql-input-type.generator.ts
@@ -12,8 +12,10 @@ import { compositeTypeDefinitions } from 'twenty-shared/types';
import { getUniqueConstraintsFields, pascalCase } from 'twenty-shared/utils';
import { TypeMapperService } from 'src/engine/api/graphql/workspace-schema-builder/services/type-mapper.service';
+import { GqlInputTypeDefinitionKind } from 'src/engine/api/graphql/workspace-schema-builder/enums/gql-input-type-definition-kind.enum';
import { GqlTypesStorage } from 'src/engine/api/graphql/workspace-schema-builder/storages/gql-types.storage';
import { type SchemaGenerationContext } from 'src/engine/api/graphql/workspace-schema-builder/types/schema-generation-context.type';
+import { computeObjectMetadataInputTypeKey } from 'src/engine/api/graphql/workspace-schema-builder/utils/compute-stored-gql-type-key-utils/compute-object-metadata-input-type.util';
import { computeRelationConnectInputTypeKey } from 'src/engine/api/graphql/workspace-schema-builder/utils/compute-stored-gql-type-key-utils/compute-relation-connect-input-type-key.util';
import { findManyFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-many-flat-entity-by-id-in-flat-entity-maps.util';
import { isCompositeFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/utils/is-composite-field-metadata-type.util';
@@ -49,23 +51,42 @@ export class RelationConnectGqlInputTypeGenerator {
): GraphQLInputObjectType {
return new GraphQLInputObjectType({
name: `${pascalCase(flatObjectMetadata.nameSingular)}RelationInput`,
- fields: () => ({
- [RELATION_NESTED_QUERY_KEYWORDS.CONNECT]: {
- type: new GraphQLInputObjectType({
- name: `${pascalCase(flatObjectMetadata.nameSingular)}ConnectInput`,
- fields: this.generateRelationWhereInputType(
- flatObjectMetadata,
- fields,
- context,
- ),
- }),
- description: `Connect to a ${flatObjectMetadata.nameSingular} record`,
- },
- [RELATION_NESTED_QUERY_KEYWORDS.DISCONNECT]: {
- type: GraphQLBoolean,
- description: `Disconnect from a ${flatObjectMetadata.nameSingular} record`,
- },
- }),
+ fields: () => {
+ const createInputType = this.gqlTypesStorage.getGqlTypeByKey(
+ computeObjectMetadataInputTypeKey(
+ flatObjectMetadata.nameSingular,
+ GqlInputTypeDefinitionKind.Create,
+ ),
+ );
+
+ if (!(createInputType instanceof GraphQLInputObjectType)) {
+ throw new Error(
+ `Create input type not found for ${flatObjectMetadata.nameSingular}`,
+ );
+ }
+
+ return {
+ [RELATION_NESTED_QUERY_KEYWORDS.CONNECT]: {
+ type: new GraphQLInputObjectType({
+ name: `${pascalCase(flatObjectMetadata.nameSingular)}ConnectInput`,
+ fields: this.generateRelationWhereInputType(
+ flatObjectMetadata,
+ fields,
+ context,
+ ),
+ }),
+ description: `Connect to a ${flatObjectMetadata.nameSingular} record`,
+ },
+ [RELATION_NESTED_QUERY_KEYWORDS.CREATE]: {
+ type: createInputType,
+ description: `Create and connect a ${flatObjectMetadata.nameSingular} record`,
+ },
+ [RELATION_NESTED_QUERY_KEYWORDS.DISCONNECT]: {
+ type: GraphQLBoolean,
+ description: `Disconnect from a ${flatObjectMetadata.nameSingular} record`,
+ },
+ };
+ },
});
}
diff --git a/packages/twenty-server/src/engine/metadata-modules/utils/__tests__/compute-metadata-name-from-label.util.spec.ts b/packages/twenty-server/src/engine/metadata-modules/utils/__tests__/compute-metadata-name-from-label.util.spec.ts
index 142ee9991e8..ab539893055 100644
--- a/packages/twenty-server/src/engine/metadata-modules/utils/__tests__/compute-metadata-name-from-label.util.spec.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/utils/__tests__/compute-metadata-name-from-label.util.spec.ts
@@ -86,6 +86,27 @@ describe('computeMetadataNameFromLabel', () => {
expected: 'userCustom',
},
},
+ {
+ title: 'should add "Custom" suffix to nested relation keywords',
+ context: {
+ input: 'Connect',
+ expected: 'connectCustom',
+ },
+ },
+ {
+ title: 'should reserve the nested relation create keyword',
+ context: {
+ input: 'Create',
+ expected: 'createCustom',
+ },
+ },
+ {
+ title: 'should reserve the nested relation disconnect keyword',
+ context: {
+ input: 'Disconnect',
+ expected: 'disconnectCustom',
+ },
+ },
{
title: 'should not modify non-reserved keywords',
context: {
diff --git a/packages/twenty-server/src/engine/twenty-orm/datasource/workspace-data-source.ts b/packages/twenty-server/src/engine/twenty-orm/datasource/workspace-data-source.ts
index b10a4cacfce..6ab36b5762f 100644
--- a/packages/twenty-server/src/engine/twenty-orm/datasource/workspace-data-source.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/datasource/workspace-data-source.ts
@@ -1,3 +1,5 @@
+import { Logger } from '@nestjs/common';
+
import { type Pool } from 'pg';
import { isDefined } from 'twenty-shared/utils';
@@ -32,6 +34,7 @@ const tableShapeCacheByFlatObjectMetadataMaps = new WeakMap<
>();
export class WorkspaceDataSource {
+ private readonly logger = new Logger(WorkspaceDataSource.name);
private readonly pool: Pool;
private readonly internalContext: WorkspaceInternalContext;
private readonly authContext: WorkspaceAuthContext;
@@ -71,7 +74,21 @@ export class WorkspaceDataSource {
async transaction<T>(
work: (transactionScope: WorkspaceTransactionScope) => Promise<T>,
): Promise<T> {
- return this.runInClientTransaction((executor) =>
+ const afterCommitCallbacks: Array<() => void | Promise<void>> = [];
+ const afterCommit: WorkspaceTransactionScope['afterCommit'] = (callback) =>
+ afterCommitCallbacks.push(callback);
+ const transactionalInternalContext: WorkspaceInternalContext = {
+ ...this.internalContext,
+ eventEmitterService: {
+ emitDatabaseBatchEvent: (event) =>
+ afterCommit(() =>
+ this.internalContext.eventEmitterService.emitDatabaseBatchEvent(
+ event,
+ ),
+ ),
+ },
+ };
+ const result = await this.runInClientTransaction((executor) =>
work({
getRepository: <T extends ObjectLiteral = ObjectRecord>(
nameSingular: string,
@@ -85,11 +102,26 @@ export class WorkspaceDataSource {
isTransactional: true,
shouldSkipEventEmission:
repositoryOptions?.shouldSkipEventEmission ?? false,
+ internalContext: transactionalInternalContext,
}),
executeRawQuery: (sql, parameters = []) =>
executor.execute({ text: sql, values: parameters }),
+ afterCommit,
}),
);
+
+ for (const callback of afterCommitCallbacks) {
+ try {
+ await callback();
+ } catch (error) {
+ this.logger.error(
+ `After-commit callback failed for workspace ${this.internalContext.workspaceId}`,
+ error,
+ );
+ }
+ }
+
+ return result;
}
private async runInClientTransaction<T>(
@@ -107,15 +139,17 @@ export class WorkspaceDataSource {
executor,
isTransactional = false,
shouldSkipEventEmission = false,
+ internalContext = this.internalContext,
}: {
nameSingular: string;
rolePermissionConfig?: RolePermissionConfig;
executor: QueryExecutor;
isTransactional?: boolean;
shouldSkipEventEmission?: boolean;
+ internalContext?: WorkspaceInternalContext;
}): WorkspaceRepository<T> {
const objectMetadataId =
- this.internalContext.objectIdByNameSingular[nameSingular];
+ internalContext.objectIdByNameSingular[nameSingular];
if (!isDefined(objectMetadataId)) {
throw new TwentyOrmException(
@@ -130,6 +164,7 @@ export class WorkspaceDataSource {
executor,
isTransactional,
shouldSkipEventEmission,
+ internalContext,
});
}
@@ -141,12 +176,14 @@ export class WorkspaceDataSource {
executor,
isTransactional = false,
shouldSkipEventEmission = false,
+ internalContext = this.internalContext,
}: {
objectMetadataId: string;
rolePermissionConfig?: RolePermissionConfig;
executor: QueryExecutor;
isTransactional?: boolean;
shouldSkipEventEmission?: boolean;
+ internalContext?: WorkspaceInternalContext;
}): WorkspaceRepository<T> {
const flatObjectMetadata =
this.getFlatObjectMetadataOrThrow(objectMetadataId);
@@ -160,7 +197,7 @@ export class WorkspaceDataSource {
return new WorkspaceRepository<T>({
tableShape: this.getTableShape(objectMetadataId),
flatObjectMetadata,
- internalContext: this.internalContext,
+ internalContext,
authContext: this.authContext,
executor,
objectRecordsPermissions,
@@ -170,25 +207,28 @@ export class WorkspaceDataSource {
this.getTableShape(targetObjectMetadataId),
flatObjectMetadataByObjectMetadataId: (targetObjectMetadataId) =>
this.getFlatObjectMetadataOrThrow(targetObjectMetadataId),
- getRepositoryForObjectMetadataId: (targetObjectMetadataId) =>
- this.buildRepositoryForObjectMetadataId({
+ getRepositoryForObjectMetadataId: <
+ Entity extends ObjectLiteral = ObjectRecord,
+ >(
+ targetObjectMetadataId: string,
+ ) =>
+ this.buildRepositoryForObjectMetadataId<Entity>({
objectMetadataId: targetObjectMetadataId,
rolePermissionConfig,
executor,
isTransactional,
shouldSkipEventEmission,
+ internalContext,
}),
isTransactional,
runInNewTransaction: (work) =>
- this.runInClientTransaction((transactionExecutor) =>
+ this.transaction((transactionScope) =>
work(
- this.buildRepositoryForObjectMetadataId({
- objectMetadataId,
+ transactionScope.getRepository<T>(
+ flatObjectMetadata.nameSingular,
rolePermissionConfig,
- executor: transactionExecutor,
- isTransactional: true,
- shouldSkipEventEmission,
- }),
+ { shouldSkipEventEmission },
+ ),
),
),
});
diff --git a/packages/twenty-server/src/engine/twenty-orm/entity-manager/types/query-deep-partial-entity-with-nested-relation-fields.type.ts b/packages/twenty-server/src/engine/twenty-orm/entity-manager/types/query-deep-partial-entity-with-nested-relation-fields.type.ts
index ddabc713ac4..9297da068c8 100644
--- a/packages/twenty-server/src/engine/twenty-orm/entity-manager/types/query-deep-partial-entity-with-nested-relation-fields.type.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/entity-manager/types/query-deep-partial-entity-with-nested-relation-fields.type.ts
@@ -13,6 +13,10 @@ export type ConnectObject = {
};
};
+export type CreateObject = {
+ [RELATION_NESTED_QUERY_KEYWORDS.CREATE]: Record<string, unknown>;
+};
+
export type DisconnectObject = {
[RELATION_NESTED_QUERY_KEYWORDS.DISCONNECT]: true;
};
@@ -30,6 +34,6 @@ export type QueryDeepPartialEntityWithNestedRelationFields<T> = Omit<
EntityRelationFields<T>
> & {
[K in keyof T]?: T[K] extends BaseWorkspaceEntity | null
- ? T[K] | ConnectObject | DisconnectObject
+ ? T[K] | ConnectObject | CreateObject | DisconnectObject
: T[K];
};
diff --git a/packages/twenty-server/src/engine/twenty-orm/entity-manager/types/relation-nested-query-fields-by-entity-index.type.ts b/packages/twenty-server/src/engine/twenty-orm/entity-manager/types/relation-nested-query-fields-by-entity-index.type.ts
index 7892b7322bb..ebc6e83bbc8 100644
--- a/packages/twenty-server/src/engine/twenty-orm/entity-manager/types/relation-nested-query-fields-by-entity-index.type.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/entity-manager/types/relation-nested-query-fields-by-entity-index.type.ts
@@ -1,5 +1,6 @@
import {
type ConnectObject,
+ type CreateObject,
type DisconnectObject,
} from 'src/engine/twenty-orm/entity-manager/types/query-deep-partial-entity-with-nested-relation-fields.type';
@@ -12,3 +13,7 @@ export type RelationDisconnectQueryFieldsByEntityIndex = {
[key: string]: DisconnectObject;
};
};
+
+export type RelationCreateQueryFieldsByEntityIndex = {
+ [entityIndex: string]: { [key: string]: CreateObject };
+};
diff --git a/packages/twenty-server/src/engine/twenty-orm/field-operations/relation-nested-queries/relation-nested-queries.ts b/packages/twenty-server/src/engine/twenty-orm/field-operations/relation-nested-queries/relation-nested-queries.ts
index 3e240e3c63d..3faa0f7ff85 100644
--- a/packages/twenty-server/src/engine/twenty-orm/field-operations/relation-nested-queries/relation-nested-queries.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/field-operations/relation-nested-queries/relation-nested-queries.ts
@@ -1,17 +1,24 @@
-import { isDefined } from 'class-validator';
import { RELATION_NESTED_QUERY_KEYWORDS } from 'twenty-shared/constants';
+import { FieldMetadataType, type ObjectRecord } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
import { type EntityTarget, type ObjectLiteral } from 'typeorm';
import { type QueryDeepPartialEntity } from 'typeorm/query-builder/QueryPartialEntity';
+import { v4 } from 'uuid';
import { type WorkspaceInternalContext } from 'src/engine/twenty-orm/interfaces/workspace-internal-context.interface';
-import { type RolePermissionConfig } from 'src/engine/twenty-orm/types/role-permission-config';
-import { type WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
+import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
+import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';
+import { buildFieldMapsFromFlatObjectMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/build-field-maps-from-flat-object-metadata.util';
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+import { type WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace-repository';
+import { isFieldMetadataEntityOfType } from 'src/engine/utils/is-field-metadata-of-type.util';
import { type QueryDeepPartialEntityWithNestedRelationFields } from 'src/engine/twenty-orm/entity-manager/types/query-deep-partial-entity-with-nested-relation-fields.type';
import { type RelationConnectQueryConfig } from 'src/engine/twenty-orm/entity-manager/types/relation-connect-query-config.type';
import {
type RelationConnectQueryFieldsByEntityIndex,
+ type RelationCreateQueryFieldsByEntityIndex,
type RelationDisconnectQueryFieldsByEntityIndex,
} from 'src/engine/twenty-orm/entity-manager/types/relation-nested-query-fields-by-entity-index.type';
import {
@@ -24,20 +31,15 @@ import { createSqlWhereTupleInClause } from 'src/engine/twenty-orm/utils/create-
import { extractNestedRelationFieldsByEntityIndex } from 'src/engine/twenty-orm/utils/extract-nested-relation-fields-by-entity-index.util';
import { getAssociatedRelationFieldName } from 'src/engine/twenty-orm/utils/get-associated-relation-field-name.util';
import { getObjectMetadataFromEntityTarget } from 'src/engine/twenty-orm/utils/get-object-metadata-from-entity-target.util';
+import { getNestedRelationFieldNames } from 'src/engine/twenty-orm/utils/get-nested-relation-field-names.util';
export class RelationNestedQueries {
private readonly internalContext: WorkspaceInternalContext;
- private readonly workspaceOrmManager: WorkspaceOrmManager;
- private readonly rolePermissionConfig?: RolePermissionConfig;
+ private readonly repository: WorkspaceRepository;
- constructor(
- internalContext: WorkspaceInternalContext,
- workspaceOrmManager: WorkspaceOrmManager,
- rolePermissionConfig?: RolePermissionConfig,
- ) {
- this.internalContext = internalContext;
- this.workspaceOrmManager = workspaceOrmManager;
- this.rolePermissionConfig = rolePermissionConfig;
+ constructor(repository: WorkspaceRepository) {
+ this.repository = repository;
+ this.internalContext = repository.getInternalContext();
}
prepareNestedRelationQueries<Entity extends ObjectLiteral>(
@@ -46,14 +48,29 @@ export class RelationNestedQueries {
| QueryDeepPartialEntityWithNestedRelationFields<Entity>,
target: EntityTarget<Entity>,
):
- | [RelationConnectQueryConfig[], RelationDisconnectQueryFieldsByEntityIndex]
+ | [
+ RelationConnectQueryConfig[],
+ RelationDisconnectQueryFieldsByEntityIndex,
+ RelationCreateQueryFieldsByEntityIndex,
+ ]
| null {
const entitiesArray = Array.isArray(entities) ? entities : [entities];
+ const objectMetadata = getObjectMetadataFromEntityTarget(
+ target,
+ this.internalContext,
+ );
const {
relationConnectQueryFieldsByEntityIndex,
+ relationCreateQueryFieldsByEntityIndex,
relationDisconnectQueryFieldsByEntityIndex,
- } = extractNestedRelationFieldsByEntityIndex(entitiesArray);
+ } = extractNestedRelationFieldsByEntityIndex(
+ entitiesArray,
+ getNestedRelationFieldNames({
+ flatObjectMetadata: objectMetadata,
+ flatFieldMetadataMaps: this.internalContext.flatFieldMetadataMaps,
+ }),
+ );
const connectConfig = this.prepareRelationConnect(
entitiesArray,
@@ -62,8 +79,13 @@ export class RelationNestedQueries {
);
return connectConfig.length > 0 ||
+ Object.keys(relationCreateQueryFieldsByEntityIndex).length > 0 ||
Object.keys(relationDisconnectQueryFieldsByEntityIndex).length > 0
- ? [connectConfig, relationDisconnectQueryFieldsByEntityIndex]
+ ? [
+ connectConfig,
+ relationDisconnectQueryFieldsByEntityIndex,
+ relationCreateQueryFieldsByEntityIndex,
+ ]
: null;
}
@@ -92,6 +114,8 @@ export class RelationNestedQueries {
async processRelationNestedQueries<Entity extends ObjectLiteral>({
entities,
relationNestedConfig,
+ createRecords,
+ target,
}: {
entities:
| QueryDeepPartialEntityWithNestedRelationFields<Entity>[]
@@ -99,13 +123,20 @@ export class RelationNestedQueries {
relationNestedConfig: [
RelationConnectQueryConfig[],
RelationDisconnectQueryFieldsByEntityIndex,
+ RelationCreateQueryFieldsByEntityIndex,
];
+ createRecords?: (options: {
+ targetObjectMetadata: FlatObjectMetadata;
+ records: Partial<ObjectRecord>[];
+ }) => Promise<ObjectRecord[]>;
+ target: EntityTarget<Entity>;
}): Promise<QueryDeepPartialEntity<Entity>[]> {
const entitiesArray = Array.isArray(entities) ? entities : [entities];
const [
relationConnectQueryConfigs,
relationDisconnectQueryFieldsByEntityIndex,
+ relationCreateQueryFieldsByEntityIndex,
] = relationNestedConfig;
const updatedEntitiesWithDisconnect = this.processRelationDisconnect({
@@ -113,14 +144,174 @@ export class RelationNestedQueries {
relationDisconnectQueryFieldsByEntityIndex,
});
- const updatedEntitiesWithConnect = await this.processRelationConnect({
+ const updatedEntitiesWithCreate = await this.processRelationCreate({
entities: updatedEntitiesWithDisconnect,
+ target,
+ relationCreateQueryFieldsByEntityIndex,
+ createRecords,
+ });
+
+ const updatedEntitiesWithConnect = await this.processRelationConnect({
+ entities: updatedEntitiesWithCreate,
relationConnectQueryConfigs,
});
return updatedEntitiesWithConnect;
}
+ private async processRelationCreate<Entity extends ObjectLiteral>({
+ entities,
+ target,
+ relationCreateQueryFieldsByEntityIndex,
+ createRecords,
+ }: {
+ entities: QueryDeepPartialEntityWithNestedRelationFields<Entity>[];
+ target: EntityTarget<Entity>;
+ relationCreateQueryFieldsByEntityIndex: RelationCreateQueryFieldsByEntityIndex;
+ createRecords?: (options: {
+ targetObjectMetadata: FlatObjectMetadata;
+ records: Partial<ObjectRecord>[];
+ }) => Promise<ObjectRecord[]>;
+ }): Promise<QueryDeepPartialEntityWithNestedRelationFields<Entity>[]> {
+ if (Object.keys(relationCreateQueryFieldsByEntityIndex).length === 0) {
+ return entities;
+ }
+ if (!isDefined(createRecords)) {
+ throw new TwentyOrmException(
+ 'Nested relation create is not supported in this operation',
+ TwentyOrmExceptionCode.INVALID_PARAMETER,
+ );
+ }
+
+ const objectMetadata = getObjectMetadataFromEntityTarget(
+ target,
+ this.internalContext,
+ );
+ const { fieldIdByName } = buildFieldMapsFromFlatObjectMetadata(
+ this.internalContext.flatFieldMetadataMaps,
+ objectMetadata,
+ );
+ const groups = new Map<
+ string,
+ {
+ targetObjectMetadata: FlatObjectMetadata;
+ entries: {
+ entityIndex: number;
+ fieldName: string;
+ record: Partial<ObjectRecord>;
+ }[];
+ }
+ >();
+
+ for (const [entityIndex, fields] of Object.entries(
+ relationCreateQueryFieldsByEntityIndex,
+ )) {
+ for (const [fieldName, createObject] of Object.entries(fields)) {
+ const fieldMetadata = findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: fieldIdByName[fieldName],
+ flatEntityMaps: this.internalContext.flatFieldMetadataMaps,
+ });
+
+ if (
+ !isDefined(fieldMetadata) ||
+ (!isFieldMetadataEntityOfType(
+ fieldMetadata,
+ FieldMetadataType.RELATION,
+ ) &&
+ !isFieldMetadataEntityOfType(
+ fieldMetadata,
+ FieldMetadataType.MORPH_RELATION,
+ )) ||
+ fieldMetadata.settings?.relationType !== RelationType.MANY_TO_ONE ||
+ !isDefined(fieldMetadata.relationTargetObjectMetadataId)
+ ) {
+ throw new TwentyOrmException(
+ `Create is not allowed for ${fieldName} on ${objectMetadata.nameSingular}`,
+ TwentyOrmExceptionCode.INVALID_PARAMETER,
+ );
+ }
+
+ const joinColumnName = getAssociatedRelationFieldName(fieldName);
+ const entity = entities[Number(entityIndex)];
+ const entityRecord = entity as Record<string, unknown>;
+
+ if (isDefined(entityRecord[joinColumnName])) {
+ throw new TwentyOrmException(
+ `Cannot provide both ${fieldName}.create and ${joinColumnName}`,
+ TwentyOrmExceptionCode.INVALID_PARAMETER,
+ );
+ }
+
+ const targetObjectMetadata = findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: fieldMetadata.relationTargetObjectMetadataId,
+ flatEntityMaps: this.internalContext.flatObjectMetadataMaps,
+ });
+
+ if (!isDefined(targetObjectMetadata)) {
+ throw new TwentyOrmException(
+ `Target object metadata not found for ${fieldName}`,
+ TwentyOrmExceptionCode.MALFORMED_METADATA,
+ );
+ }
+
+ const group = groups.get(targetObjectMetadata.id) ?? {
+ targetObjectMetadata,
+ entries: [],
+ };
+
+ group.entries.push({
+ entityIndex: Number(entityIndex),
+ fieldName,
+ record: createObject[RELATION_NESTED_QUERY_KEYWORDS.CREATE],
+ });
+ groups.set(targetObjectMetadata.id, group);
+ }
+ }
+
+ const updatedEntities = entities.map((entity) => ({ ...entity }));
+
+ for (const { targetObjectMetadata, entries } of groups.values()) {
+ const recordsWithIds = entries.map(({ record }) => ({
+ ...record,
+ id: record.id ?? v4(),
+ }));
+ const createdRecords = await createRecords({
+ targetObjectMetadata,
+ records: recordsWithIds,
+ });
+
+ if (createdRecords.length !== entries.length) {
+ throw new TwentyOrmException(
+ `Expected ${entries.length} created ${targetObjectMetadata.namePlural} records, received ${createdRecords.length}`,
+ TwentyOrmExceptionCode.INVALID_PARAMETER,
+ );
+ }
+
+ const createdRecordIds = new Set(
+ createdRecords.map(({ id }) => id).filter(isDefined),
+ );
+
+ entries.forEach(({ entityIndex, fieldName }, index) => {
+ const createdRecordId = recordsWithIds[index].id;
+
+ if (!createdRecordIds.has(createdRecordId)) {
+ throw new TwentyOrmException(
+ `Created ${targetObjectMetadata.nameSingular} record ${createdRecordId} was not returned`,
+ TwentyOrmExceptionCode.INVALID_PARAMETER,
+ );
+ }
+
+ updatedEntities[entityIndex] = {
+ ...updatedEntities[entityIndex],
+ [getAssociatedRelationFieldName(fieldName)]: createdRecordId,
+ [fieldName]: null,
+ };
+ });
+ }
+
+ return updatedEntities;
+ }
+
private async processRelationConnect<Entity extends ObjectLiteral>({
entities,
relationConnectQueryConfigs,
@@ -181,8 +372,18 @@ export class RelationNestedQueries {
parameters: Record<string, unknown>;
}): Promise<Record<string, unknown>[]> {
const targetObjectName = connectQueryConfig.targetObjectName;
- const targetQueryBuilder = this.workspaceOrmManager
- .getRepository(targetObjectName, this.rolePermissionConfig)
+ const targetObjectMetadataId =
+ this.internalContext.objectIdByNameSingular[targetObjectName];
+
+ if (!isDefined(targetObjectMetadataId)) {
+ throw new TwentyOrmException(
+ `Target object metadata not found for ${targetObjectName}`,
+ TwentyOrmExceptionCode.MALFORMED_METADATA,
+ );
+ }
+
+ const targetQueryBuilder = this.repository
+ .getRepositoryForObjectMetadataId(targetObjectMetadataId)
.createQueryBuilder(targetObjectName);
targetQueryBuilder.select([]);
diff --git a/packages/twenty-server/src/engine/twenty-orm/interfaces/workspace-internal-context.interface.ts b/packages/twenty-server/src/engine/twenty-orm/interfaces/workspace-internal-context.interface.ts
index d774b371acc..43c4ac4c203 100644
--- a/packages/twenty-server/src/engine/twenty-orm/interfaces/workspace-internal-context.interface.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/interfaces/workspace-internal-context.interface.ts
@@ -21,6 +21,6 @@ export interface WorkspaceInternalContext {
featureFlagsMap: Record<FeatureFlagKey, boolean>;
userWorkspaceRoleMap: UserWorkspaceRoleMap;
apiKeyRoleMap: Record<string, string>;
- eventEmitterService: WorkspaceEventEmitter;
+ eventEmitterService: Pick<WorkspaceEventEmitter, 'emitDatabaseBatchEvent'>;
coreDataSource: DataSource;
}
diff --git a/packages/twenty-server/src/engine/twenty-orm/repository/workspace-repository.ts b/packages/twenty-server/src/engine/twenty-orm/repository/workspace-repository.ts
index 1b50d643e9a..9b893b77932 100644
--- a/packages/twenty-server/src/engine/twenty-orm/repository/workspace-repository.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/repository/workspace-repository.ts
@@ -89,7 +89,7 @@ const MUTATION_EVENT_ACTIONS_BY_KIND: Record<
update: [DatabaseEventAction.UPDATED, DatabaseEventAction.UPSERTED],
};
-type WorkspaceRepositoryOptions = {
+type WorkspaceRepositoryOptions<TEntity extends ObjectLiteral> = {
tableShape: WorkspaceTableShape;
flatObjectMetadata: FlatObjectMetadata;
internalContext: WorkspaceInternalContext;
@@ -109,25 +109,25 @@ type WorkspaceRepositoryOptions = {
flatObjectMetadataByObjectMetadataId: (
objectMetadataId: string,
) => FlatObjectMetadata;
- getRepositoryForObjectMetadataId: (
+ getRepositoryForObjectMetadataId: <
+ Entity extends ObjectLiteral = ObjectRecord,
+ >(
objectMetadataId: string,
- ) => WorkspaceRepository;
+ ) => WorkspaceRepository<Entity>;
isTransactional: boolean;
runInNewTransaction: <T>(
- work: (
- transactionalRepository: WorkspaceRepository<ObjectLiteral>,
- ) => Promise<T>,
+ work: (transactionalRepository: WorkspaceRepository<TEntity>) => Promise<T>,
) => Promise<T>;
};
export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
readonly objectRecordsPermissions: ObjectsPermissions;
- private readonly options: WorkspaceRepositoryOptions;
+ private readonly options: WorkspaceRepositoryOptions<TEntity>;
private _filesFieldSync?: FilesFieldSync;
- constructor(options: WorkspaceRepositoryOptions) {
+ constructor(options: WorkspaceRepositoryOptions<TEntity>) {
this.options = options;
this.objectRecordsPermissions = options.objectRecordsPermissions;
}
@@ -206,6 +206,14 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
return this.options.internalContext;
}
+ getRepositoryForObjectMetadataId<Entity extends ObjectLiteral = ObjectRecord>(
+ objectMetadataId: string,
+ ): WorkspaceRepository<Entity> {
+ return this.options.getRepositoryForObjectMetadataId<Entity>(
+ objectMetadataId,
+ );
+ }
+
async find(options?: WorkspaceFindOptions): Promise<TEntity[]> {
const records = await applyFindOptionsToQueryBuilder(
this.createQueryBuilder(),
@@ -677,7 +685,7 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {
}
private runAtomically<T>(
- work: (repository: WorkspaceRepository<ObjectLiteral>) => Promise<T>,
+ work: (repository: WorkspaceRepository<TEntity>) => Promise<T>,
): Promise<T> {
return this.options.isTransactional
? work(this)
diff --git a/packages/twenty-server/src/engine/twenty-orm/types/workspace-transaction-scope.type.ts b/packages/twenty-server/src/engine/twenty-orm/types/workspace-transaction-scope.type.ts
index cf45e3d20ad..b91a09e5543 100644
--- a/packages/twenty-server/src/engine/twenty-orm/types/workspace-transaction-scope.type.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/types/workspace-transaction-scope.type.ts
@@ -15,4 +15,5 @@ export type WorkspaceTransactionScope = {
sql: string,
parameters?: unknown[],
) => Promise<Record<string, unknown>[]>;
+ afterCommit: (callback: () => void | Promise<void>) => void;
};
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/extract-nested-relation-fields-by-entity-index.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/extract-nested-relation-fields-by-entity-index.util.spec.ts
new file mode 100644
index 00000000000..768503fb2b9
--- /dev/null
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/extract-nested-relation-fields-by-entity-index.util.spec.ts
@@ -0,0 +1,53 @@
+import { extractNestedRelationFieldsByEntityIndex } from 'src/engine/twenty-orm/utils/extract-nested-relation-fields-by-entity-index.util';
+
+describe('extractNestedRelationFieldsByEntityIndex', () => {
+ it('extracts nested create fields by record index', () => {
+ expect(
+ extractNestedRelationFieldsByEntityIndex(
+ [
+ {
+ name: 'Pivot',
+ targetPerson: { create: { id: 'target-id', name: 'Target' } },
+ },
+ ],
+ new Set(['targetPerson']),
+ ).relationCreateQueryFieldsByEntityIndex,
+ ).toEqual({
+ 0: {
+ targetPerson: { create: { id: 'target-id', name: 'Target' } },
+ },
+ });
+ });
+
+ it('rejects multiple operations on the same relation field', () => {
+ expect(() =>
+ extractNestedRelationFieldsByEntityIndex(
+ [
+ {
+ targetPerson: {
+ create: { id: 'target-id' },
+ connect: { where: { id: 'existing-id' } },
+ },
+ },
+ ],
+ new Set(['targetPerson']),
+ ),
+ ).toThrow('Cannot combine create, connect, and disconnect');
+ });
+
+ it('leaves create-shaped values on non-relation fields untouched', () => {
+ expect(
+ extractNestedRelationFieldsByEntityIndex(
+ [
+ {
+ extraData: { create: { arbitrary: 'json' } },
+ targetPerson: { create: { id: 'target-id' } },
+ },
+ ],
+ new Set(['targetPerson']),
+ ).relationCreateQueryFieldsByEntityIndex,
+ ).toEqual({
+ 0: { targetPerson: { create: { id: 'target-id' } } },
+ });
+ });
+});
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/contains-nested-relation-create.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/contains-nested-relation-create.util.ts
new file mode 100644
index 00000000000..bb8765faf45
--- /dev/null
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/contains-nested-relation-create.util.ts
@@ -0,0 +1,20 @@
+import { RELATION_NESTED_QUERY_KEYWORDS } from 'twenty-shared/constants';
+import { isDefined } from 'twenty-shared/utils';
+
+export const containsNestedRelationCreate = (
+ records: Record<string, unknown>[],
+ relationFieldNames: ReadonlySet<string>,
+): boolean =>
+ records.some((record) =>
+ Object.entries(record).some(
+ ([fieldName, value]) =>
+ relationFieldNames.has(fieldName) &&
+ isDefined(value) &&
+ typeof value === 'object' &&
+ isDefined(
+ (value as Record<string, unknown>)[
+ RELATION_NESTED_QUERY_KEYWORDS.CREATE
+ ],
+ ),
+ ),
+ );
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/extract-nested-relation-fields-by-entity-index.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/extract-nested-relation-fields-by-entity-index.util.ts
index 4af15ced2af..1d6e4314089 100644
--- a/packages/twenty-server/src/engine/twenty-orm/utils/extract-nested-relation-fields-by-entity-index.util.ts
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/extract-nested-relation-fields-by-entity-index.util.ts
@@ -3,10 +3,12 @@ import { RELATION_NESTED_QUERY_KEYWORDS } from 'twenty-shared/constants';
import {
type ConnectObject,
+ type CreateObject,
type DisconnectObject,
} from 'src/engine/twenty-orm/entity-manager/types/query-deep-partial-entity-with-nested-relation-fields.type';
import {
type RelationConnectQueryFieldsByEntityIndex,
+ type RelationCreateQueryFieldsByEntityIndex,
type RelationDisconnectQueryFieldsByEntityIndex,
} from 'src/engine/twenty-orm/entity-manager/types/relation-nested-query-fields-by-entity-index.type';
import {
@@ -70,38 +72,69 @@ const hasRelationConnect = (value: unknown): value is ConnectObject => {
};
const hasRelationDisconnect = (value: unknown): value is DisconnectObject => {
- if (!isDefined(value) || typeof value !== 'object') return false;
+ if (!isDefined(value) || typeof value !== 'object') {
+ return false;
+ }
const obj = value as Record<string, unknown>;
if (
!isDefined(obj[RELATION_NESTED_QUERY_KEYWORDS.DISCONNECT]) ||
typeof obj[RELATION_NESTED_QUERY_KEYWORDS.DISCONNECT] !== 'boolean'
- )
+ ) {
return false;
+ }
return true;
};
+const hasRelationCreate = (value: unknown): value is CreateObject => {
+ if (!isDefined(value) || typeof value !== 'object') {
+ return false;
+ }
+
+ const create = (value as Record<string, unknown>)[
+ RELATION_NESTED_QUERY_KEYWORDS.CREATE
+ ];
+
+ return isDefined(create) && typeof create === 'object';
+};
+
export const extractNestedRelationFieldsByEntityIndex = (
entities: Record<string, unknown>[],
+ relationFieldNames: ReadonlySet<string>,
): {
relationConnectQueryFieldsByEntityIndex: RelationConnectQueryFieldsByEntityIndex;
+ relationCreateQueryFieldsByEntityIndex: RelationCreateQueryFieldsByEntityIndex;
relationDisconnectQueryFieldsByEntityIndex: RelationDisconnectQueryFieldsByEntityIndex;
} => {
const relationConnectQueryFieldsByEntityIndex: RelationConnectQueryFieldsByEntityIndex =
{};
const relationDisconnectQueryFieldsByEntityIndex: RelationDisconnectQueryFieldsByEntityIndex =
{};
+ const relationCreateQueryFieldsByEntityIndex: RelationCreateQueryFieldsByEntityIndex =
+ {};
for (const [entityIndex, entity] of Object.entries(entities)) {
for (const [key, value] of Object.entries(entity)) {
+ if (!relationFieldNames.has(key)) {
+ continue;
+ }
+
const hasConnect = hasRelationConnect(value);
+ const hasCreate = hasRelationCreate(value);
const hasDisconnect = hasRelationDisconnect(value);
if (hasConnect && hasDisconnect) {
throw new TwentyOrmException(
- `Cannot have both connect and disconnect for the same field on ${entity.key}.`,
+ `Cannot have both connect and disconnect for the same relation field ${key}.`,
+ TwentyOrmExceptionCode.CONNECT_NOT_ALLOWED,
+ );
+ }
+
+ if (hasCreate && (hasConnect || hasDisconnect)) {
+ throw new TwentyOrmException(
+ `Cannot combine create, connect, and disconnect for the same relation field ${key}.`,
TwentyOrmExceptionCode.CONNECT_NOT_ALLOWED,
);
}
@@ -125,11 +158,22 @@ export const extractNestedRelationFieldsByEntityIndex = (
[key]: value,
};
}
+
+ const relationCreateQueryFields =
+ relationCreateQueryFieldsByEntityIndex?.[entityIndex] || {};
+
+ if (hasCreate) {
+ relationCreateQueryFieldsByEntityIndex[entityIndex] = {
+ ...relationCreateQueryFields,
+ [key]: value,
+ };
+ }
}
}
return {
relationConnectQueryFieldsByEntityIndex,
+ relationCreateQueryFieldsByEntityIndex,
relationDisconnectQueryFieldsByEntityIndex,
};
};
diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/get-nested-relation-field-names.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/get-nested-relation-field-names.util.ts
new file mode 100644
index 00000000000..d6d23f513df
--- /dev/null
+++ b/packages/twenty-server/src/engine/twenty-orm/utils/get-nested-relation-field-names.util.ts
@@ -0,0 +1,31 @@
+import { FieldMetadataType, RelationType } from 'twenty-shared/types';
+
+import { getFlatFieldsFromFlatObjectMetadata } from 'src/engine/api/graphql/workspace-schema-builder/utils/get-flat-fields-for-flat-object-metadata.util';
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+import { type OrmFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/orm-flat-field-metadata.type';
+import { isFlatFieldMetadataOfType } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-flat-field-metadata-of-type.util';
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+
+export const getNestedRelationFieldNames = ({
+ flatObjectMetadata,
+ flatFieldMetadataMaps,
+}: {
+ flatObjectMetadata: FlatObjectMetadata;
+ flatFieldMetadataMaps: FlatEntityMaps<OrmFlatFieldMetadata>;
+}): ReadonlySet<string> =>
+ new Set(
+ getFlatFieldsFromFlatObjectMetadata(
+ flatObjectMetadata,
+ flatFieldMetadataMaps,
+ )
+ .filter(
+ (field) =>
+ (isFlatFieldMetadataOfType(field, FieldMetadataType.RELATION) ||
+ isFlatFieldMetadataOfType(
+ field,
+ FieldMetadataType.MORPH_RELATION,
+ )) &&
+ field.settings.relationType === RelationType.MANY_TO_ONE,
+ )
+ .map(({ name }) => name),
+ );
diff --git a/packages/twenty-server/test/integration/graphql/suites/object-generated/nested-relation-queries.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/object-generated/nested-relation-queries.integration-spec.ts
index 2de9ae6731c..332633b5cdd 100644
--- a/packages/twenty-server/test/integration/graphql/suites/object-generated/nested-relation-queries.integration-spec.ts
+++ b/packages/twenty-server/test/integration/graphql/suites/object-generated/nested-relation-queries.integration-spec.ts
@@ -17,10 +17,12 @@ import { createManyOperationFactory } from 'test/integration/graphql/utils/creat
import { createManyOperation } from 'test/integration/graphql/utils/create-many-operation.util';
import { createOneOperationFactory } from 'test/integration/graphql/utils/create-one-operation-factory.util';
import { destroyManyOperationFactory } from 'test/integration/graphql/utils/destroy-many-operation-factory.util';
+import { findOneOperationFactory } from 'test/integration/graphql/utils/find-one-operation-factory.util';
import { makeGraphqlAPIRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
import { updateManyOperationFactory } from 'test/integration/graphql/utils/update-many-operation-factory.util';
import { updateOneOperationFactory } from 'test/integration/graphql/utils/update-one-operation-factory.util';
import { type ObjectRecord } from 'twenty-shared/types';
+import { v4 } from 'uuid';
import { ErrorCode } from 'src/engine/core-modules/graphql/utils/graphql-errors.util';
@@ -47,7 +49,24 @@ const PET_GQL_FIELDS_WITH_OWNER = `
}
`;
+const findRecordById = (
+ objectMetadataSingularName: string,
+ id: string,
+ gqlFields = 'id',
+) =>
+ makeGraphqlAPIRequest(
+ findOneOperationFactory({
+ objectMetadataSingularName,
+ gqlFields,
+ filter: { id: { eq: id } },
+ }),
+ );
+
describe('relation connect in workspace createOne/createMany resolvers (e2e)', () => {
+ let generatedPersonIds: string[] = [];
+ let generatedCompanyIds: string[] = [];
+ let generatedPetIds: string[] = [];
+ let generatedTaskTargetIds: string[] = [];
const [company1, company2] = [
{ id: TEST_COMPANY_1_ID, domainName: { primaryLinkUrl: 'company1.com' } },
{ id: TEST_COMPANY_2_ID, domainName: { primaryLinkUrl: 'company2.com' } },
@@ -90,6 +109,35 @@ describe('relation connect in workspace createOne/createMany resolvers (e2e)',
);
});
+ afterEach(async () => {
+ const cleanupOperations = [
+ ['taskTarget', 'taskTargets', generatedTaskTargetIds],
+ ['pet', 'pets', generatedPetIds],
+ ['person', 'people', generatedPersonIds],
+ ['company', 'companies', generatedCompanyIds],
+ ] as const;
+
+ for (const [nameSingular, namePlural, ids] of cleanupOperations) {
+ if (ids.length === 0) {
+ continue;
+ }
+
+ await makeGraphqlAPIRequest(
+ destroyManyOperationFactory({
+ objectMetadataSingularName: nameSingular,
+ objectMetadataPluralName: namePlural,
+ gqlFields: 'id',
+ filter: { id: { in: ids } },
+ }),
+ );
+ }
+
+ generatedPersonIds = [];
+ generatedCompanyIds = [];
+ generatedPetIds = [];
+ generatedTaskTargetIds = [];
+ });
+
afterAll(async () => {
await makeGraphqlAPIRequest(
destroyManyOperationFactory({
@@ -117,6 +165,367 @@ describe('relation connect in workspace createOne/createMany resolvers (e2e)',
);
});
+ it('should create and connect a related record through a MANY-TO-ONE relation', async () => {
+ const personId = v4();
+ const companyId = v4();
+ generatedPersonIds.push(personId);
+ generatedCompanyIds.push(companyId);
+ const response = await makeGraphqlAPIRequest(
+ createOneOperationFactory({
+ objectMetadataSingularName: 'person',
+ gqlFields: PERSON_GQL_FIELDS_WITH_COMPANY,
+ data: {
+ id: personId,
+ company: {
+ create: {
+ id: companyId,
+ name: 'Nested create company',
+ },
+ },
+ },
+ }),
+ );
+
+ expect(response.body.errors).toBeUndefined();
+ expect(response.body.data.createPerson.company.id).toBe(companyId);
+ });
+
+ it('should create and connect a related record with a generated target id', async () => {
+ const personId = v4();
+
+ generatedPersonIds.push(personId);
+
+ const response = await makeGraphqlAPIRequest(
+ createOneOperationFactory({
+ objectMetadataSingularName: 'person',
+ gqlFields: 'id jobTitle company { id name }',
+ data: {
+ id: personId,
+ company: {
+ create: {
+ name: 'Nested create company with generated id',
+ },
+ },
+ },
+ }),
+ );
+
+ expect(response.body.errors).toBeUndefined();
+
+ const companyId = response.body.data.createPerson.company.id;
+
+ if (typeof companyId === 'string') {
+ generatedCompanyIds.push(companyId);
+ }
+
+ const persistedPersonResponse = await findRecordById(
+ 'person',
+ personId,
+ PERSON_GQL_FIELDS_WITH_COMPANY,
+ );
+
+ expect(companyId).toEqual(expect.any(String));
+ expect(persistedPersonResponse.body.data.person.company.id).toBe(companyId);
+ });
+
+ it('should preserve target mapping when creating multiple related records', async () => {
+ const personIds = [v4(), v4()];
+ const companyIds = [v4(), v4()];
+
+ generatedPersonIds.push(...personIds);
+ generatedCompanyIds.push(...companyIds);
+
+ const response = await makeGraphqlAPIRequest(
+ createManyOperationFactory({
+ objectMetadataSingularName: 'person',
+ objectMetadataPluralName: 'people',
+ gqlFields: 'id jobTitle company { id name }',
+ data: personIds.map((personId, index) => ({
+ id: personId,
+ company: {
+ create: {
+ id: companyIds[index],
+ name: `Nested batch company ${index + 1}`,
+ },
+ },
+ })),
+ }),
+ );
+
+ expect(response.body.errors).toBeUndefined();
+ expect(response.body.data.createPeople).toHaveLength(2);
+
+ for (const [index, personId] of personIds.entries()) {
+ const createdPerson = response.body.data.createPeople.find(
+ (person: ObjectRecord) => person.id === personId,
+ );
+
+ expect(createdPerson.company).toMatchObject({
+ id: companyIds[index],
+ name: `Nested batch company ${index + 1}`,
+ });
+ }
+ });
+
+ it('should create and connect related records across both upsert branches', async () => {
+ const existingPersonId = v4();
+ const insertedPersonId = v4();
+ const existingPersonCompanyId = v4();
+ const insertedPersonCompanyId = v4();
+
+ generatedPersonIds.push(existingPersonId, insertedPersonId);
+ generatedCompanyIds.push(existingPersonCompanyId, insertedPersonCompanyId);
+
+ await makeGraphqlAPIRequest(
+ createOneOperationFactory({
+ objectMetadataSingularName: 'person',
+ gqlFields: 'id',
+ data: {
+ id: existingPersonId,
+ jobTitle: 'Preserved by nested upsert',
+ },
+ }),
+ );
+
+ const response = await makeGraphqlAPIRequest(
+ createManyOperationFactory({
+ objectMetadataSingularName: 'person',
+ objectMetadataPluralName: 'people',
+ gqlFields: PERSON_GQL_FIELDS_WITH_COMPANY,
+ data: [
+ {
+ id: existingPersonId,
+ company: {
+ create: {
+ id: existingPersonCompanyId,
+ name: 'Nested company for existing person',
+ },
+ },
+ },
+ {
+ id: insertedPersonId,
+ jobTitle: 'Inserted by nested upsert',
+ company: {
+ create: {
+ id: insertedPersonCompanyId,
+ name: 'Nested company for inserted person',
+ },
+ },
+ },
+ ],
+ upsert: true,
+ }),
+ );
+
+ expect(response.body.errors).toBeUndefined();
+
+ const upsertedPeopleById = new Map(
+ response.body.data.createPeople.map((person: ObjectRecord) => [
+ person.id,
+ person,
+ ]),
+ );
+
+ expect(upsertedPeopleById.get(existingPersonId)).toMatchObject({
+ id: existingPersonId,
+ jobTitle: 'Preserved by nested upsert',
+ company: { id: existingPersonCompanyId },
+ });
+ expect(upsertedPeopleById.get(insertedPersonId)).toMatchObject({
+ id: insertedPersonId,
+ jobTitle: 'Inserted by nested upsert',
+ company: { id: insertedPersonCompanyId },
+ });
+ });
+
+ it('should create and connect a concrete target through a MANY-TO-ONE morph relation', async () => {
+ const taskTargetId = v4();
+ const personId = v4();
+ generatedTaskTargetIds.push(taskTargetId);
+ generatedPersonIds.push(personId);
+ const response = await makeGraphqlAPIRequest(
+ createOneOperationFactory({
+ objectMetadataSingularName: 'taskTarget',
+ gqlFields: 'id targetPerson { id }',
+ data: {
+ id: taskTargetId,
+ targetPerson: {
+ create: { id: personId },
+ },
+ },
+ }),
+ );
+
+ expect(response.body.errors).toBeUndefined();
+ expect(response.body.data.createTaskTarget.targetPerson.id).toBe(personId);
+ });
+
+ it('should preserve create-shaped values in RAW_JSON fields', async () => {
+ const petId = v4();
+ const extraData = { create: { arbitrary: 'json' } };
+
+ generatedPetIds.push(petId);
+
+ const response = await makeGraphqlAPIRequest(
+ createOneOperationFactory({
+ objectMetadataSingularName: 'pet',
+ gqlFields: 'id extraData',
+ data: { id: petId, name: 'JSON nested-create regression', extraData },
+ }),
+ );
+
+ expect(response.body.errors).toBeUndefined();
+ expect(response.body.data.createPet.extraData).toEqual(extraData);
+ });
+
+ it('should roll back a nested create when the parent record cannot be created', async () => {
+ const personId = v4();
+ const companyId = v4();
+ generatedPersonIds.push(personId);
+ generatedCompanyIds.push(companyId);
+
+ await makeGraphqlAPIRequest(
+ createOneOperationFactory({
+ objectMetadataSingularName: 'person',
+ gqlFields: 'id',
+ data: { id: personId },
+ }),
+ );
+
+ const response = await makeGraphqlAPIRequest(
+ createOneOperationFactory({
+ objectMetadataSingularName: 'person',
+ gqlFields: PERSON_GQL_FIELDS_WITH_COMPANY,
+ data: {
+ id: personId,
+ company: {
+ create: {
+ id: companyId,
+ name: 'Must be rolled back',
+ },
+ },
+ },
+ }),
+ );
+
+ expect(response.body.errors).toBeDefined();
+
+ const companyResponse = await findRecordById('company', companyId);
+
+ expect(companyResponse.body.data.company).toBeNull();
+ });
+
+ it('should roll back every nested target when a create-many parent batch fails', async () => {
+ const newPersonId = v4();
+ const duplicatePersonId = v4();
+ const companyIds = [v4(), v4()];
+
+ generatedPersonIds.push(newPersonId, duplicatePersonId);
+ generatedCompanyIds.push(...companyIds);
+
+ await makeGraphqlAPIRequest(
+ createOneOperationFactory({
+ objectMetadataSingularName: 'person',
+ gqlFields: 'id',
+ data: { id: duplicatePersonId },
+ }),
+ );
+
+ const response = await makeGraphqlAPIRequest(
+ createManyOperationFactory({
+ objectMetadataSingularName: 'person',
+ objectMetadataPluralName: 'people',
+ gqlFields: PERSON_GQL_FIELDS_WITH_COMPANY,
+ data: [
+ {
+ id: newPersonId,
+ company: {
+ create: { id: companyIds[0], name: 'Rolled back company 1' },
+ },
+ },
+ {
+ id: duplicatePersonId,
+ company: {
+ create: { id: companyIds[1], name: 'Rolled back company 2' },
+ },
+ },
+ ],
+ }),
+ );
+
+ expect(response.body.errors).toBeDefined();
+
+ const [newPersonResponse, firstCompanyResponse, secondCompanyResponse] =
+ await Promise.all([
+ findRecordById('person', newPersonId),
+ findRecordById('company', companyIds[0]),
+ findRecordById('company', companyIds[1]),
+ ]);
+
+ expect(newPersonResponse.body.data.person).toBeNull();
+ expect(firstCompanyResponse.body.data.company).toBeNull();
+ expect(secondCompanyResponse.body.data.company).toBeNull();
+ });
+
+ it('should reject nested create in update operations', async () => {
+ const companyId = v4();
+
+ generatedCompanyIds.push(companyId);
+
+ const response = await makeGraphqlAPIRequest(
+ updateOneOperationFactory({
+ objectMetadataSingularName: 'person',
+ gqlFields: 'id',
+ recordId: TEST_PERSON_1_ID,
+ data: {
+ company: {
+ create: { id: companyId },
+ },
+ },
+ }),
+ );
+
+ expect(response.body.errors).toBeDefined();
+
+ const companyResponse = await findRecordById('company', companyId);
+
+ expect(companyResponse.body.data.company).toBeNull();
+ });
+
+ it('should reject conflicting nested operations without creating an orphan target', async () => {
+ const personId = v4();
+ const companyId = v4();
+
+ generatedPersonIds.push(personId);
+ generatedCompanyIds.push(companyId);
+
+ const response = await makeGraphqlAPIRequest(
+ createOneOperationFactory({
+ objectMetadataSingularName: 'person',
+ gqlFields: PERSON_GQL_FIELDS_WITH_COMPANY,
+ data: {
+ id: personId,
+ company: {
+ create: { id: companyId, name: 'Must not be created' },
+ connect: { where: { id: TEST_COMPANY_1_ID } },
+ },
+ },
+ }),
+ );
+
+ expect(response.body.errors?.[0].message).toBe(
+ 'Cannot combine create, connect, and disconnect for the same relation field company.',
+ );
+
+ const [personResponse, companyResponse] = await Promise.all([
+ findRecordById('person', personId),
+ findRecordById('company', companyId),
+ ]);
+
+ expect(personResponse.body.data.person).toBeNull();
+ expect(companyResponse.body.data.company).toBeNull();
+ });
+
it('should connect to other records through a MANY-TO-ONE relation - create One', async () => {
const graphqlOperation = createOneOperationFactory({
objectMetadataSingularName: 'person',
@@ -202,9 +611,9 @@ describe('relation connect in workspace createOne/createMany resolvers (e2e)',
},
},
{
- id: TEST_PERSON_2_ID,
- jobTitle: 'new-record',
- company: {
+ id: TEST_PERSON_2_ID,
+ jobTitle: 'new-record',
+ company: {
connect: {
where: { domainName: { primaryLinkUrl: 'company1.com' } },
},
@@ -446,7 +855,7 @@ describe('relation connect in workspace createOne/createMany resolvers (e2e)',
expect(response.body.errors).toBeDefined();
expect(response.body.errors[0].message).toBe(
- 'Cannot have both connect and disconnect for the same field on undefined.',
+ 'Cannot have both connect and disconnect for the same relation field company.',
);
});
diff --git a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/permissions-on-relations.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/permissions-on-relations.integration-spec.ts
index 50c0cbd134a..28510e17c7e 100644
--- a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/permissions-on-relations.integration-spec.ts
+++ b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/permissions-on-relations.integration-spec.ts
@@ -10,6 +10,7 @@ import { findOneOperationFactory } from 'test/integration/graphql/utils/find-one
import { makeGraphqlAPIRequestWithMemberRole as makeGraphqlAPIRequestWithJony } from 'test/integration/graphql/utils/make-graphql-api-request-with-member-role.util';
import { makeGraphqlAPIRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
import { updateWorkspaceMemberRole } from 'test/integration/graphql/utils/update-workspace-member-role.util';
+import { deleteRecordsByIds } from 'test/integration/utils/delete-records-by-ids';
import { ErrorCode } from 'src/engine/core-modules/graphql/utils/graphql-errors.util';
import { PermissionsExceptionMessage } from 'src/engine/metadata-modules/permissions/permissions.exception';
@@ -20,6 +21,8 @@ const client = request(`http://localhost:${APP_PORT}`);
describe('permissionsOnRelations', () => {
let originalMemberRoleId: string;
let customRoleId: string;
+ let generatedPersonIds: string[] = [];
+ let generatedCompanyIds: string[] = [];
const personId = randomUUID();
beforeAll(async () => {
@@ -94,6 +97,10 @@ describe('permissionsOnRelations', () => {
});
afterEach(async () => {
+ await deleteRecordsByIds('person', generatedPersonIds);
+ await deleteRecordsByIds('company', generatedCompanyIds);
+ generatedPersonIds = [];
+ generatedCompanyIds = [];
await deleteRole(client, customRoleId);
});
@@ -171,6 +178,73 @@ describe('permissionsOnRelations', () => {
expect(response.body.error).toBeUndefined();
});
+ it('should reject a nested create when the target object is not writable', async () => {
+ const { roleId } = await createCustomRoleWithObjectPermissions({
+ label: 'WritablePersonReadOnlyCompanyRole',
+ canReadPerson: true,
+ canUpdatePerson: true,
+ canReadCompany: true,
+ canUpdateCompany: false,
+ hasAllObjectRecordsReadPermission: false,
+ });
+
+ customRoleId = roleId;
+
+ await updateWorkspaceMemberRole({
+ client,
+ roleId: customRoleId,
+ workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
+ });
+
+ const nestedPersonId = randomUUID();
+ const nestedCompanyId = randomUUID();
+
+ generatedPersonIds.push(nestedPersonId);
+ generatedCompanyIds.push(nestedCompanyId);
+
+ const response = await makeGraphqlAPIRequestWithJony(
+ createOneOperationFactory({
+ objectMetadataSingularName: 'person',
+ gqlFields: 'id company { id }',
+ data: {
+ id: nestedPersonId,
+ company: {
+ create: {
+ id: nestedCompanyId,
+ name: 'Forbidden nested company',
+ },
+ },
+ },
+ }),
+ );
+
+ expect(response.body.data).toStrictEqual({ createPerson: null });
+ expect(response.body.errors?.[0]).toMatchObject({
+ message: PermissionsExceptionMessage.PERMISSION_DENIED,
+ extensions: { code: ErrorCode.FORBIDDEN },
+ });
+
+ const [personResponse, companyResponse] = await Promise.all([
+ makeGraphqlAPIRequest(
+ findOneOperationFactory({
+ objectMetadataSingularName: 'person',
+ gqlFields: 'id',
+ filter: { id: { eq: nestedPersonId } },
+ }),
+ ),
+ makeGraphqlAPIRequest(
+ findOneOperationFactory({
+ objectMetadataSingularName: 'company',
+ gqlFields: 'id',
+ filter: { id: { eq: nestedCompanyId } },
+ }),
+ ),
+ ]);
+
+ expect(personResponse.body.data.person).toBeNull();
+ expect(companyResponse.body.data.company).toBeNull();
+ });
+
it('nested relations - should throw permission error when querying nested opportunity relation without opportunity read permission', async () => {
const { roleId } = await createCustomRoleWithObjectPermissions({
label: 'PersonCompanyOnlyRole',
diff --git a/packages/twenty-shared/src/constants/RelationNestedQueriesKeyword.ts b/packages/twenty-shared/src/constants/RelationNestedQueriesKeyword.ts
index cc8097cb862..6d6a59d6173 100644
--- a/packages/twenty-shared/src/constants/RelationNestedQueriesKeyword.ts
+++ b/packages/twenty-shared/src/constants/RelationNestedQueriesKeyword.ts
@@ -1,5 +1,6 @@
export const RELATION_NESTED_QUERY_KEYWORDS = {
CONNECT: 'connect',
CONNECT_WHERE: 'where',
+ CREATE: 'create',
DISCONNECT: 'disconnect',
} as const;
diff --git a/packages/twenty-shared/src/metadata/__tests__/computeMetadataNameFromLabel.test.ts b/packages/twenty-shared/src/metadata/__tests__/computeMetadataNameFromLabel.test.ts
index 16b42bcb2c6..15e369760d9 100644
--- a/packages/twenty-shared/src/metadata/__tests__/computeMetadataNameFromLabel.test.ts
+++ b/packages/twenty-shared/src/metadata/__tests__/computeMetadataNameFromLabel.test.ts
@@ -30,6 +30,18 @@ describe('computeMetadataNameFromLabel', () => {
expect(result.length).toBeGreaterThan(0);
});
+ it('should reserve nested relation keywords', () => {
+ expect(computeMetadataNameFromLabel({ label: 'Connect' })).toBe(
+ 'connectCustom',
+ );
+ expect(computeMetadataNameFromLabel({ label: 'Create' })).toBe(
+ 'createCustom',
+ );
+ expect(computeMetadataNameFromLabel({ label: 'Disconnect' })).toBe(
+ 'disconnectCustom',
+ );
+ });
+
it('should skip custom suffix when applyCustomSuffix is false', () => {
const result = computeMetadataNameFromLabel({
label: 'My Field',
diff --git a/packages/twenty-shared/src/metadata/constants/reserved-metadata-name-keywords.constant.ts b/packages/twenty-shared/src/metadata/constants/reserved-metadata-name-keywords.constant.ts
index f4f0265837d..809d3f2b2cf 100644
--- a/packages/twenty-shared/src/metadata/constants/reserved-metadata-name-keywords.constant.ts
+++ b/packages/twenty-shared/src/metadata/constants/reserved-metadata-name-keywords.constant.ts
@@ -60,6 +60,9 @@ export const RESERVED_METADATA_NAME_KEYWORDS = [
'relation',
'relations',
'aggregate',
+ 'connect',
+ 'create',
+ 'disconnect',
'search',
'searches',
];