admin/twenty
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

feat: new relation sync-metadata, twenty-orm, create/update (#10217)

Browse Source 
Fix
https://github.com/twentyhq/core-team-issues/issues/330#issue-2827026606
and
https://github.com/twentyhq/core-team-issues/issues/327#issue-2827001814

What this PR does when `isNewRelationEnabled` is set to `true`:
- [x] Drop the creation of the  foreign key as a `FieldMetadata`
- [x] Stop creating `RelationMetadata`
- [x] Properly fill `FieldMetadata` of type `RELATION` during the sync
command
- [x] Use new relation settings in TwentyORM
- [x] Properly create `FieldMetadata` relations when we create a new
object
- [x] Handle `database:reset` with new relations

---------

Co-authored-by: Charles Bochet <charles@twenty.com>
Co-authored-by: Charles Bochet <charlesBochet@users.noreply.github.com>
This commit is contained in:
Jérémy M
2025-04-22 19:01:39 +02:00
committed by GitHub
parent de1489aabb
commit cc29c25176
160 changed files with 3247 additions and 711 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
packages/twenty-front/src/modules/object-metadata/utils/__tests__/mapFieldMetadataToGraphQLQuery.test.ts
View File

@ -14,7 +14,8 @@ describe('mapFieldMetadataToGraphQLQuery', () => {
it('should return fieldName if simpleValue', async () => {
const res = mapFieldMetadataToGraphQLQuery({
objectMetadataItems: generatedMockObjectMetadataItems,
field: personObjectMetadataItem.fields.find(
gqlField: 'id',
fieldMetadata: personObjectMetadataItem.fields.find(
(field) => field.name === 'id',
)!,
});
@ -23,7 +24,8 @@ describe('mapFieldMetadataToGraphQLQuery', () => {
it('should return fieldName if composite', async () => {
const res = mapFieldMetadataToGraphQLQuery({
objectMetadataItems: generatedMockObjectMetadataItems,
field: personObjectMetadataItem.fields.find(
gqlField: 'name',
fieldMetadata: personObjectMetadataItem.fields.find(
(field) => field.name === 'name',
)!,
});
@ -39,7 +41,8 @@ describe('mapFieldMetadataToGraphQLQuery', () => {
it('should return non relation subFields if relation', async () => {
const res = mapFieldMetadataToGraphQLQuery({
objectMetadataItems: generatedMockObjectMetadataItems,
field: personObjectMetadataItem.fields.find(
gqlField: 'company',
fieldMetadata: personObjectMetadataItem.fields.find(
(field) => field.name === 'company',
)!,
});
@ -115,7 +118,8 @@ idealCustomerProfile
id: true,
idealCustomerProfile: true,
},
field: personObjectMetadataItem.fields.find(
gqlField: 'company',
fieldMetadata: personObjectMetadataItem.fields.find(
(field) => field.name === 'company',
)!,
});

18
packages/twenty-front/src/modules/object-metadata/utils/__tests__/shouldFieldBeQueried.test.ts
View File

@ -5,14 +5,16 @@ describe('shouldFieldBeQueried', () => {
describe('if recordGqlFields is absent, we query all except relations', () => {
it('should be queried if the field is not a relation', () => {
const res = shouldFieldBeQueried({
field: { name: 'fieldName', type: FieldMetadataType.BOOLEAN },
gqlField: 'fieldName',
fieldMetadata: { name: 'fieldName', type: FieldMetadataType.BOOLEAN },
});
expect(res).toBe(true);
});
it('should not be queried if the field is a relation', () => {
const res = shouldFieldBeQueried({
field: { name: 'fieldName', type: FieldMetadataType.RELATION },
gqlField: 'fieldName',
fieldMetadata: { name: 'fieldName', type: FieldMetadataType.RELATION },
});
expect(res).toBe(false);
});
@ -21,8 +23,9 @@ describe('shouldFieldBeQueried', () => {
describe('if recordGqlFields is present, we respect it', () => {
it('should be queried if true', () => {
const res = shouldFieldBeQueried({
gqlField: 'fieldName',
fieldMetadata: { name: 'fieldName', type: FieldMetadataType.RELATION },
recordGqlFields: { fieldName: true },
field: { name: 'fieldName', type: FieldMetadataType.RELATION },
});
expect(res).toBe(true);
});
@ -30,23 +33,26 @@ describe('shouldFieldBeQueried', () => {
it('should be queried if object', () => {
const res = shouldFieldBeQueried({
recordGqlFields: { fieldName: { subFieldName: false } },
field: { name: 'fieldName', type: FieldMetadataType.RELATION },
fieldMetadata: { name: 'fieldName', type: FieldMetadataType.RELATION },
gqlField: 'fieldName',
});
expect(res).toBe(true);
});
it('should not be queried if false', () => {
const res = shouldFieldBeQueried({
gqlField: 'fieldName',
fieldMetadata: { name: 'fieldName', type: FieldMetadataType.RELATION },
recordGqlFields: { fieldName: false },
field: { name: 'fieldName', type: FieldMetadataType.RELATION },
});
expect(res).toBe(false);
});
it('should not be queried if absent', () => {
const res = shouldFieldBeQueried({
gqlField: 'fieldName',
fieldMetadata: { name: 'fieldName', type: FieldMetadataType.RELATION },
recordGqlFields: { otherFieldName: false },
field: { name: 'fieldName', type: FieldMetadataType.RELATION },
});
expect(res).toBe(false);
});

47
packages/twenty-front/src/modules/object-metadata/utils/mapFieldMetadataToGraphQLQuery.ts
View File

@ -12,40 +12,50 @@ import { FieldMetadataItem } from '../types/FieldMetadataItem';
type MapFieldMetadataToGraphQLQueryArgs = {
objectMetadataItems: ObjectMetadataItem[];
field: Pick<FieldMetadataItem, 'name' | 'type' | 'relationDefinition'>;
gqlField: string;
fieldMetadata: Pick<
FieldMetadataItem,
'name' | 'type' | 'relationDefinition' | 'settings'
>;
relationRecordGqlFields?: RecordGqlFields;
computeReferences?: boolean;
};
// TODO: change ObjectMetadataItems mock before refactoring with relationDefinition computed field
export const mapFieldMetadataToGraphQLQuery = ({
objectMetadataItems,
field,
gqlField,
fieldMetadata,
relationRecordGqlFields,
computeReferences = false,
}: MapFieldMetadataToGraphQLQueryArgs): string => {
const fieldType = field.type;
const fieldType = fieldMetadata.type;
const fieldIsNonCompositeField = isNonCompositeField(fieldType);
if (fieldIsNonCompositeField) {
return field.name;
return gqlField;
}
if (
fieldType === FieldMetadataType.RELATION &&
field.relationDefinition?.direction === RelationDefinitionType.MANY_TO_ONE
fieldMetadata.relationDefinition?.direction ===
RelationDefinitionType.MANY_TO_ONE
) {
const relationMetadataItem = objectMetadataItems.find(
(objectMetadataItem) =>
objectMetadataItem.id ===
field.relationDefinition?.targetObjectMetadata.id,
fieldMetadata.relationDefinition?.targetObjectMetadata.id,
);
if (isUndefined(relationMetadataItem)) {
return '';
}
return `${field.name}
if (gqlField === fieldMetadata.settings?.joinColumnName) {
return `${gqlField}`;
}
return `${gqlField}
${mapObjectMetadataToGraphQLQuery({
objectMetadataItems,
objectMetadataItem: relationMetadataItem,
@ -57,19 +67,20 @@ ${mapObjectMetadataToGraphQLQuery({
if (
fieldType === FieldMetadataType.RELATION &&
field.relationDefinition?.direction === RelationDefinitionType.ONE_TO_MANY
fieldMetadata.relationDefinition?.direction ===
RelationDefinitionType.ONE_TO_MANY
) {
const relationMetadataItem = objectMetadataItems.find(
(objectMetadataItem) =>
objectMetadataItem.id ===
field.relationDefinition?.targetObjectMetadata.id,
fieldMetadata.relationDefinition?.targetObjectMetadata.id,
);
if (isUndefined(relationMetadataItem)) {
return '';
}
return `${field.name}
return `${gqlField}
{
edges {
node ${mapObjectMetadataToGraphQLQuery({
@ -84,7 +95,7 @@ ${mapObjectMetadataToGraphQLQuery({
}
if (fieldType === FieldMetadataType.LINKS) {
return `${field.name}
return `${gqlField}
{
primaryLinkUrl
primaryLinkLabel
@ -93,7 +104,7 @@ ${mapObjectMetadataToGraphQLQuery({
}
if (fieldType === FieldMetadataType.CURRENCY) {
return `${field.name}
return `${gqlField}
{
amountMicros
currencyCode
@ -102,7 +113,7 @@ ${mapObjectMetadataToGraphQLQuery({
}
if (fieldType === FieldMetadataType.FULL_NAME) {
return `${field.name}
return `${gqlField}
{
firstName
lastName
@ -110,7 +121,7 @@ ${mapObjectMetadataToGraphQLQuery({
}
if (fieldType === FieldMetadataType.ADDRESS) {
return `${field.name}
return `${gqlField}
{
addressStreet1
addressStreet2
@ -124,7 +135,7 @@ ${mapObjectMetadataToGraphQLQuery({
}
if (fieldType === FieldMetadataType.ACTOR) {
return `${field.name}
return `${gqlField}
{
source
workspaceMemberId
@ -134,7 +145,7 @@ ${mapObjectMetadataToGraphQLQuery({
}
if (fieldType === FieldMetadataType.EMAILS) {
return `${field.name}
return `${gqlField}
{
primaryEmail
additionalEmails
@ -142,7 +153,7 @@ ${mapObjectMetadataToGraphQLQuery({
}
if (fieldType === FieldMetadataType.PHONES) {
return `${field.name}
return `${gqlField}
{
primaryPhoneNumber
primaryPhoneCountryCode
@ -152,7 +163,7 @@ ${mapObjectMetadataToGraphQLQuery({
}
if (fieldType === FieldMetadataType.RICH_TEXT_V2) {
return `${field.name}
return `${gqlField}
{
blocknote
markdown

50
packages/twenty-front/src/modules/object-metadata/utils/mapObjectMetadataToGraphQLQuery.ts
View File

@ -3,6 +3,8 @@ import { mapFieldMetadataToGraphQLQuery } from '@/object-metadata/utils/mapField
import { shouldFieldBeQueried } from '@/object-metadata/utils/shouldFieldBeQueried';
import { RecordGqlFields } from '@/object-record/graphql/types/RecordGqlFields';
import { isRecordGqlFieldsNode } from '@/object-record/graphql/utils/isRecordGraphlFieldsNode';
import { FieldMetadataType } from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
type MapObjectMetadataToGraphQLQueryArgs = {
objectMetadataItems: ObjectMetadataItem[];
@ -18,16 +20,40 @@ export const mapObjectMetadataToGraphQLQuery = ({
computeReferences = false,
isRootLevel = true,
}: MapObjectMetadataToGraphQLQueryArgs): string => {
const fieldsThatShouldBeQueried =
objectMetadataItem?.fields
.filter((field) => field.isActive)
.sort((fieldA, fieldB) => fieldA.name.localeCompare(fieldB.name))
.filter((field) =>
const manyToOneRelationFields = objectMetadataItem?.fields
.filter((field) => field.isActive)
.filter((field) => field.type === FieldMetadataType.RELATION)
.filter((field) => isDefined(field.settings?.joinColumnName));
const manyToOneRelationGqlFieldWithFieldMetadata =
manyToOneRelationFields.map((field) => ({
gqlField: field.settings?.joinColumnName,
fieldMetadata: field,
}));
const gqlFieldWithFieldMetadataThatCouldBeQueried = [
...objectMetadataItem.fields
.filter((fieldMetadata) => fieldMetadata.isActive)
.map((fieldMetadata) => ({
gqlField: fieldMetadata.name,
fieldMetadata,
})),
...manyToOneRelationGqlFieldWithFieldMetadata,
].sort((gqlFieldWithFieldMetadataA, gqlFieldWithFieldMetadataB) =>
gqlFieldWithFieldMetadataA.gqlField.localeCompare(
gqlFieldWithFieldMetadataB.gqlField,
),
);
const gqlFieldWithFieldMetadataThatSouldBeQueried =
gqlFieldWithFieldMetadataThatCouldBeQueried.filter(
(gqlFieldWithFieldMetadata) =>
shouldFieldBeQueried({
field,
gqlField: gqlFieldWithFieldMetadata.gqlField,
fieldMetadata: gqlFieldWithFieldMetadata.fieldMetadata,
recordGqlFields,
}),
) ?? [];
);
if (!isRootLevel && computeReferences) {
return `{
@ -37,9 +63,10 @@ export const mapObjectMetadataToGraphQLQuery = ({
return `{
__typename
${fieldsThatShouldBeQueried
.map((field) => {
const currentRecordGqlFields = recordGqlFields?.[field.name];
${gqlFieldWithFieldMetadataThatSouldBeQueried
.map((gqlFieldWithFieldMetadata) => {
const currentRecordGqlFields =
recordGqlFields?.[gqlFieldWithFieldMetadata.gqlField];
const relationRecordGqlFields = isRecordGqlFieldsNode(
currentRecordGqlFields,
)
@ -47,7 +74,8 @@ ${fieldsThatShouldBeQueried
: undefined;
return mapFieldMetadataToGraphQLQuery({
objectMetadataItems,
field,
gqlField: gqlFieldWithFieldMetadata.gqlField,
fieldMetadata: gqlFieldWithFieldMetadata.fieldMetadata,
relationRecordGqlFields,
computeReferences,
});

15
packages/twenty-front/src/modules/object-metadata/utils/shouldFieldBeQueried.ts
View File

@ -3,27 +3,30 @@ import { ObjectRecord } from '@/object-record/types/ObjectRecord';
import { FieldMetadataType } from '~/generated-metadata/graphql';
import { isUndefinedOrNull } from '~/utils/isUndefinedOrNull';
import { FieldMetadataItem } from '../types/FieldMetadataItem';
import { isDefined } from 'twenty-shared/utils';
import { FieldMetadataItem } from '../types/FieldMetadataItem';
export const shouldFieldBeQueried = ({
field,
gqlField,
fieldMetadata,
recordGqlFields,
}: {
field: Pick<FieldMetadataItem, 'name' | 'type'>;
gqlField: string;
fieldMetadata: Pick<FieldMetadataItem, 'name' | 'type'>;
objectRecord?: ObjectRecord;
recordGqlFields?: RecordGqlOperationGqlRecordFields;
}): any => {
if (
isUndefinedOrNull(recordGqlFields) &&
field.type !== FieldMetadataType.RELATION
fieldMetadata.type !== FieldMetadataType.RELATION
) {
return true;
}
if (
isDefined(recordGqlFields) &&
isDefined(recordGqlFields[field.name]) &&
recordGqlFields[field.name] !== false
isDefined(recordGqlFields[gqlField]) &&
recordGqlFields[gqlField] !== false
) {
return true;
}

16
packages/twenty-front/src/modules/object-record/cache/utils/getRecordNodeFromRecord.ts vendored
View File

@ -7,12 +7,12 @@ import { getRecordConnectionFromRecords } from '@/object-record/cache/utils/getR
import { getRefName } from '@/object-record/cache/utils/getRefName';
import { RecordGqlNode } from '@/object-record/graphql/types/RecordGqlNode';
import { ObjectRecord } from '@/object-record/types/ObjectRecord';
import { isDefined } from 'twenty-shared/utils';
import {
FieldMetadataType,
RelationDefinitionType,
} from '~/generated-metadata/graphql';
import { pascalCase } from '~/utils/string/pascalCase';
import { isDefined } from 'twenty-shared/utils';
export const getRecordNodeFromRecord = <T extends ObjectRecord>({
objectMetadataItems,
@ -51,9 +51,11 @@ export const getRecordNodeFromRecord = <T extends ObjectRecord>({
return undefined;
}
const field = objectMetadataItem.fields.find(
(field) => field.name === fieldName,
);
const field =
objectMetadataItem.fields.find((field) => field.name === fieldName) ??
objectMetadataItem.fields.find(
(field) => field.settings?.joinColumnName === fieldName,
);
if (isUndefined(field)) {
return undefined;
@ -94,6 +96,12 @@ export const getRecordNodeFromRecord = <T extends ObjectRecord>({
switch (field.type) {
case FieldMetadataType.RELATION: {
const isJoinColumn = field.settings?.joinColumnName === fieldName;
if (isJoinColumn) {
return [fieldName, value];
}
if (
isUndefined(
field.relationDefinition?.targetObjectMetadata.nameSingular,

2
packages/twenty-front/src/modules/object-record/cache/utils/updateRecordFromCache.ts vendored
View File

@ -6,8 +6,8 @@ import { mapObjectMetadataToGraphQLQuery } from '@/object-metadata/utils/mapObje
import { getRecordNodeFromRecord } from '@/object-record/cache/utils/getRecordNodeFromRecord';
import { RecordGqlNode } from '@/object-record/graphql/types/RecordGqlNode';
import { ObjectRecord } from '@/object-record/types/ObjectRecord';
import { isUndefinedOrNull } from '~/utils/isUndefinedOrNull';
import { capitalize } from 'twenty-shared/utils';
import { isUndefinedOrNull } from '~/utils/isUndefinedOrNull';
export const updateRecordFromCache = <T extends ObjectRecord>({
objectMetadataItems,

6
packages/twenty-front/src/modules/object-record/graphql/utils/generateDepthOneRecordGqlFields.ts
View File

@ -1,4 +1,5 @@
import { ObjectMetadataItem } from '@/object-metadata/types/ObjectMetadataItem';
import { isDefined } from 'twenty-shared/utils';
export type GenerateDepthOneRecordGqlFields = {
objectMetadataItem: ObjectMetadataItem;
@ -10,6 +11,11 @@ export const generateDepthOneRecordGqlFields = ({
objectMetadataItem.fields.reduce<Record<string, true>>((acc, field) => {
return {
...acc,
...(isDefined(field.settings?.joinColumnName)
? {
[field.settings.joinColumnName]: true,
}
: {}),
[field.name]: true,
};
}, {});

4
packages/twenty-front/src/modules/object-record/hooks/useUpdateOneRecord.ts
View File

@ -18,8 +18,8 @@ import { getUpdateOneRecordMutationResponseField } from '@/object-record/utils/g
import { sanitizeRecordInput } from '@/object-record/utils/sanitizeRecordInput';
import { isNull } from '@sniptt/guards';
import { useRecoilValue } from 'recoil';
import { buildRecordFromKeysWithSameValue } from '~/utils/array/buildRecordFromKeysWithSameValue';
import { isDefined } from 'twenty-shared/utils';
import { buildRecordFromKeysWithSameValue } from '~/utils/array/buildRecordFromKeysWithSameValue';
type useUpdateOneRecordProps = {
objectNameSingular: string;
@ -91,6 +91,7 @@ export const useUpdateOneRecord = <
id: idToUpdate,
__typename: getObjectTypename(objectMetadataItem.nameSingular),
};
const optimisticRecordWithConnection =
getRecordNodeFromRecord<ObjectRecord>({
record: computedOptimisticRecord,
@ -110,6 +111,7 @@ export const useUpdateOneRecord = <
objectMetadataItem,
record: optimisticRecordInput,
});
updateRecordFromCache({
objectMetadataItems,
objectMetadataItem,

22
packages/twenty-front/src/modules/object-record/record-filter/utils/isRecordMatchingFilter.ts
View File

@ -38,9 +38,9 @@ import { isMatchingRichTextV2Filter } from '@/object-record/record-filter/utils/
import { isMatchingSelectFilter } from '@/object-record/record-filter/utils/isMatchingSelectFilter';
import { isMatchingStringFilter } from '@/object-record/record-filter/utils/isMatchingStringFilter';
import { isMatchingUUIDFilter } from '@/object-record/record-filter/utils/isMatchingUUIDFilter';
import { isDefined } from 'twenty-shared/utils';
import { FieldMetadataType } from '~/generated-metadata/graphql';
import { isEmptyObject } from '~/utils/isEmptyObject';
import { isDefined } from 'twenty-shared/utils';
const isLeafFilter = (
filter: RecordGqlOperationFilter,
@ -167,9 +167,13 @@ export const isRecordMatchingFilter = ({
if (isEmptyObject(filterValue)) return true;
const objectMetadataField = objectMetadataItem.fields.find(
(field) => field.name === filterKey,
);
const objectMetadataField =
objectMetadataItem.fields.find((field) => field.name === filterKey) ??
objectMetadataItem.fields.find(
(field) =>
field.type === FieldMetadataType.RELATION &&
field.settings?.joinColumnName === filterKey,
);
if (!isDefined(objectMetadataField)) {
throw new Error(
@ -359,6 +363,16 @@ export const isRecordMatchingFilter = ({
});
}
case FieldMetadataType.RELATION: {
const isJoinColumn =
objectMetadataField.settings?.joinColumnName === filterKey;
if (isJoinColumn) {
return isMatchingUUIDFilter({
uuidFilter: filterValue as UUIDFilter,
value: record[filterKey],
});
}
throw new Error(
`Not implemented yet, use UUID filter instead on the corredponding "${filterKey}Id" field`,
);

29
packages/twenty-front/src/modules/object-record/utils/computeOptimisticRecordFromInput.ts
View File

@ -14,9 +14,9 @@ import { isFieldUuid } from '@/object-record/record-field/types/guards/isFieldUu
import { ObjectRecord } from '@/object-record/types/ObjectRecord';
import { buildOptimisticActorFieldValueFromCurrentWorkspaceMember } from '@/object-record/utils/buildOptimisticActorFieldValueFromCurrentWorkspaceMember';
import { getForeignKeyNameFromRelationFieldName } from '@/object-record/utils/getForeignKeyNameFromRelationFieldName';
import { isDefined } from 'twenty-shared/utils';
import { RelationDefinitionType } from '~/generated-metadata/graphql';
import { FieldMetadataType } from '~/generated/graphql';
import { isDefined } from 'twenty-shared/utils';
type ComputeOptimisticCacheRecordInputArgs = {
objectMetadataItem: ObjectMetadataItem;
@ -32,11 +32,23 @@ export const computeOptimisticRecordFromInput = ({
}: ComputeOptimisticCacheRecordInputArgs) => {
const unknownRecordInputFields = Object.keys(recordInput).filter(
(recordKey) => {
const isUnknownMetadataItemField =
objectMetadataItem.fields.find((field) => field.name === recordKey) ===
undefined;
const correspondingFieldMetadataItem = objectMetadataItem.fields.find(
(field) => field.name === recordKey,
);
const potentialJoinColumnNameFieldMetadataItem =
objectMetadataItem.fields.find(
(field) =>
field.type === FieldMetadataType.RELATION &&
field.settings?.joinColumnName === recordKey,
);
const isUnknownField =
!isDefined(correspondingFieldMetadataItem) &&
!isDefined(potentialJoinColumnNameFieldMetadataItem);
const isTypenameField = recordKey === GRAPHQL_TYPENAME_KEY;
return isUnknownMetadataItemField && !isTypenameField;
return isUnknownField && !isTypenameField;
},
);
if (unknownRecordInputFields.length > 0) {
@ -122,6 +134,7 @@ export const computeOptimisticRecordFromInput = ({
const relationFieldIdName = getForeignKeyNameFromRelationFieldName(
fieldMetadataItem.name,
);
const recordInputFieldIdValue: string | null | undefined =
recordInput[relationFieldIdName];
@ -132,7 +145,11 @@ export const computeOptimisticRecordFromInput = ({
const relationIdFieldMetadataItem = objectMetadataItem.fields.find(
(field) => field.name === relationFieldIdName,
);
if (!isDefined(relationIdFieldMetadataItem)) {
if (
!isDefined(relationIdFieldMetadataItem) &&
!isDefined(fieldMetadataItem.settings?.joinColumnName)
) {
throw new Error(
'Should never occur, encountered unknown relationId within relations definitions',
);

19
packages/twenty-front/src/modules/object-record/utils/sanitizeRecordInput.ts
View File

@ -1,8 +1,8 @@
import { ObjectMetadataItem } from '@/object-metadata/types/ObjectMetadataItem';
import { ObjectRecord } from '@/object-record/types/ObjectRecord';
import { isDefined } from 'twenty-shared/utils';
import { RelationDefinitionType } from '~/generated-metadata/graphql';
import { FieldMetadataType } from '~/generated/graphql';
import { isDefined } from 'twenty-shared/utils';
export const sanitizeRecordInput = ({
objectMetadataItem,
@ -17,14 +17,26 @@ export const sanitizeRecordInput = ({
const fieldMetadataItem = objectMetadataItem.fields.find(
(field) => field.name === fieldName,
);
const potentialJoinColumnNameFieldMetadataItem =
objectMetadataItem.fields.find(
(field) =>
field.type === FieldMetadataType.RELATION &&
field.settings?.joinColumnName === fieldName,
);
if (!fieldMetadataItem) return undefined;
if (
!isDefined(fieldMetadataItem) &&
!isDefined(potentialJoinColumnNameFieldMetadataItem)
) {
return undefined;
}
if (!fieldMetadataItem.isNullable && fieldValue == null) {
if (fieldMetadataItem?.isNullable === false && fieldValue == null) {
return undefined;
}
if (
isDefined(fieldMetadataItem) &&
fieldMetadataItem.type === FieldMetadataType.RELATION &&
fieldMetadataItem.relationDefinition?.direction ===
RelationDefinitionType.MANY_TO_ONE
@ -42,6 +54,7 @@ export const sanitizeRecordInput = ({
}
if (
isDefined(fieldMetadataItem) &&
fieldMetadataItem.type === FieldMetadataType.RELATION &&
fieldMetadataItem.relationDefinition?.direction ===
RelationDefinitionType.ONE_TO_MANY