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

Refactor triggerUpdateRelationsOptimisticEffect to compute relationship from Metadatas (#9815)

Browse Source 
# Introduction
At the moment the relationships are inferred from the record data
structure instead of its metadatas
We should refactor the code that computes or not the necessity to detach
a relation on a mutation

We've refactored the `isObjectRecordConnection` method to be consuming a
`relationDefintion` instead of "typeChecking" at the runtime the data
structure using zod validation schema

Related to #9580
This commit is contained in:
Paul Rastoin
2025-01-24 17:24:23 +01:00
committed by GitHub
parent a8552a6a67
commit 95c772664e
3 changed files with 104 additions and 115 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
packages/twenty-front/src/modules/object-record/cache/utils/__tests__/isObjectRecordConnection.test.ts vendored
View File

@ -1,27 +1,38 @@
import { peopleQueryResult } from '~/testing/mock-data/people';
import { FieldMetadataItem } from '@/object-metadata/types/FieldMetadataItem';
import { isObjectRecordConnection } from '@/object-record/cache/utils/isObjectRecordConnection';
import { RelationDefinitionType } from '~/generated-metadata/graphql';
describe('isObjectRecordConnection', () => {
it('should work with query result', () => {
const validQueryResult = peopleQueryResult.people;
const relationDefinitionMap: { [K in RelationDefinitionType]: boolean } = {
[RelationDefinitionType.MANY_TO_MANY]: true,
[RelationDefinitionType.ONE_TO_MANY]: true,
[RelationDefinitionType.MANY_TO_ONE]: false,
[RelationDefinitionType.ONE_TO_ONE]: false,
};
const isValidQueryResult = isObjectRecordConnection(
'person',
validQueryResult,
);
it.each(Object.entries(relationDefinitionMap))(
'.$relation',
(relation, expected) => {
const emptyRecord = {};
const result = isObjectRecordConnection(
{
direction: relation,
} as NonNullable<FieldMetadataItem['relationDefinition']>,
emptyRecord,
);
expect(isValidQueryResult).toEqual(true);
});
expect(result).toEqual(expected);
},
);
it('should fail with invalid result', () => {
const invalidResult = { test: 123 };
const isValidQueryResult = isObjectRecordConnection(
'person',
invalidResult,
);
expect(isValidQueryResult).toEqual(false);
it('should throw on unknown relation direction', () => {
const emptyRecord = {};
expect(() =>
isObjectRecordConnection(
{
direction: 'UNKNOWN_TYPE',
} as any,
emptyRecord,
),
).toThrowError();
});
});

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

@ -1,30 +1,23 @@
import { z } from 'zod';
import { FieldMetadataItem } from '@/object-metadata/types/FieldMetadataItem';
import { RecordGqlConnection } from '@/object-record/graphql/types/RecordGqlConnection';
import { capitalize } from 'twenty-shared';
import { assertUnreachable } from '@/workflow/utils/assertUnreachable';
import { RelationDefinitionType } from '~/generated-metadata/graphql';
export const isObjectRecordConnection = (
objectNameSingular: string,
relationDefinition: NonNullable<FieldMetadataItem['relationDefinition']>,
value: unknown,
): value is RecordGqlConnection => {
const objectConnectionTypeName = `${capitalize(
objectNameSingular,
)}Connection`;
const objectEdgeTypeName = `${capitalize(objectNameSingular)}Edge`;
const objectConnectionSchema = z.object({
__typename: z.literal(objectConnectionTypeName).optional(),
edges: z.array(
z.object({
__typename: z.literal(objectEdgeTypeName).optional(),
node: z.object({
id: z.string().uuid(),
}),
}),
),
});
const connectionValidation = objectConnectionSchema.safeParse(value);
return connectionValidation.success;
switch (relationDefinition.direction) {
case RelationDefinitionType.MANY_TO_MANY:
case RelationDefinitionType.ONE_TO_MANY: {
return true;
}
case RelationDefinitionType.MANY_TO_ONE:
case RelationDefinitionType.ONE_TO_ONE: {
return false;
}
default: {
return assertUnreachable(relationDefinition.direction);
}
}
};