mukeshs/twenty_crm
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Deprecate old relations completely (#12482)

Browse Source 
# What

Fully deprecate old relations because we have one bug tied to it and it
make the codebase complex

# How I've made this PR:
1. remove metadata datasource (we only keep 'core') => this was causing
extra complexity in the refactor + flaky reset
2. merge dev and demo datasets => as I needed to update the tests which
is very painful, I don't want to do it twice
3. remove all code tied to RELATION_METADATA /
relation-metadata.resolver, or anything tied to the old relation system
4. Remove ONE_TO_ONE and MANY_TO_MANY that are not supported
5. fix impacts on the different areas : see functional testing below 

# Functional testing

## Functional testing from the front-end:
1. Database Reset ✅
2. Sign In ✅
3. Workspace sign-up ✅
5. Browsing table / kanban / show ✅
6. Assigning a record in a one to many / in a many to one ✅
7. Deleting a record involved in a relation ✅ => broken but not tied to
this PR
8. "Add new" from relation picker ✅ => broken but not tied to this PR
9. Creating a Task / Note, Updating a Task / Note relations, Deleting a
Task / Note (from table, show page, right drawer) ✅ => broken but not
tied to this PR
10. creating a relation from settings (custom / standard x oneToMany /
manyToOne) ✅
11. updating a relation from settings should not be possible ✅
12. deleting a relation from settings (custom / standard x oneToMany /
manyToOne) ✅
13. Make sure timeline activity still work (relation were involved
there), espacially with Task / Note => to be double checked ✅ => Cannot
convert undefined or null to object
14. Workspace deletion / User deletion ✅ 
15. CSV Import should keep working ✅ 
16. Permissions: I have tested without permissions V2 as it's still hard
to test v2 work and it's not in prod yet ✅
17. Workflows global test ✅ 

## From the API:
1. Review open-api documentation (REST) ✅ 
2. Make sure REST Api are still able to fetch relations ==> won't do, we
have a coupling Get/Update/Create there, this requires refactoring
3. Make sure REST Api is still able to update / remove relation => won't
do same

## Automated tests
1. lint + typescript ✅
2. front unit tests: ✅
3. server unit tests 2 ✅
4. front stories: ✅
5. server integration: ✅
6. chromatic check : expected 0
7. e2e check : expected no more that current failures

## Remove // Todos
1. All are captured by functional tests above, nothing additional to do

## (Un)related regressions
1. Table loading state is not working anymore, we see the empty state
before table content
2. Filtering by Creator Tim Ap return empty results
3. Not possible to add Tasks / Notes / Files from show page

# Result

## New seeds that can be easily extended
<img width="1920" alt="image"
src="https://github.com/user-attachments/assets/d290d130-2a5f-44e6-b419-7e42a89eec4b"
/>

## -5k lines of code
## No more 'metadata' dataSource (we only have 'core)
## No more relationMetadata (I haven't drop the table yet it's not
referenced in the code anymore)
## We are ready to fix the 6 months lag between current API results and
our mocked tests
## No more bug on relation creation / deletion

---------

Co-authored-by: Weiko <corentin@twenty.com>
Co-authored-by: Félix Malfait <felix@twenty.com>
This commit is contained in:
Charles Bochet
2025-06-10 16:45:27 +02:00
committed by GitHub
parent 264861e020
commit a68895189c
426 changed files with 48870 additions and 54125 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
packages/twenty-server/src/engine/api/__mocks__/object-metadata-item.mock.ts
View File

@ -1,5 +1,7 @@
import { FieldMetadataType } from 'twenty-shared/types';
import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
import { FieldActorSource } from 'src/engine/metadata-modules/field-metadata/composite-types/actor.composite-type';
import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
import { ObjectMetadataItemWithFieldMaps } from 'src/engine/metadata-modules/types/object-metadata-item-with-field-maps';
@ -87,10 +89,19 @@ export const fieldRelationMock = {
id: 'fieldRelationId',
name: 'fieldRelation',
type: FieldMetadataType.RELATION,
fromRelationMetadata: {
toObjectMetadata: {
nameSingular: 'toObjectMetadataName',
},
settings: {
relationType: RelationType.MANY_TO_ONE,
joinColumnName: 'fieldRelationId',
onDelete: 'CASCADE',
},
relationTargetObjectMetadata: {
id: 'relationTargetObjectId',
nameSingular: 'relationTargetObject',
namePlural: 'relationTargetObjects',
},
relationTargetFieldMetadata: {
id: 'relationTargetFieldId',
name: 'relationTargetField',
},
isNullable: true,
defaultValue: null,

2
packages/twenty-server/src/engine/api/graphql/graphql-query-runner/__mocks__/mockPersonObjectMetadata.ts
View File

@ -21,8 +21,6 @@ export const mockPersonObjectMetadata = (
isAuditLogged: true,
isSearchable: true,
duplicateCriteria: duplicateCriteria,
fromRelations: [],
toRelations: [],
labelIdentifierFieldMetadataId: '',
imageIdentifierFieldMetadataId: '',
workspaceId: '',

2
packages/twenty-server/src/engine/api/graphql/graphql-query-runner/graphql-query-runner.module.ts
View File

@ -45,7 +45,7 @@ const graphqlQueryResolvers = [
WorkspaceQueryHookModule,
WorkspaceQueryRunnerModule,
PermissionsModule,
TypeOrmModule.forFeature([UserWorkspaceRoleEntity], 'metadata'),
TypeOrmModule.forFeature([UserWorkspaceRoleEntity], 'core'),
UserRoleModule,
],
providers: [

170
packages/twenty-server/src/engine/api/graphql/workspace-schema-builder/factories/extend-object-type-definition.factory.ts
View File

@ -1,170 +0,0 @@
import { Injectable, Logger } from '@nestjs/common';
import {
GraphQLFieldConfigArgumentMap,
GraphQLFieldConfigMap,
GraphQLObjectType,
} from 'graphql';
import { WorkspaceBuildSchemaOptions } from 'src/engine/api/graphql/workspace-schema-builder/interfaces/workspace-build-schema-optionts.interface';
import { ObjectMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/object-metadata.interface';
import { TypeDefinitionsStorage } from 'src/engine/api/graphql/workspace-schema-builder/storages/type-definitions.storage';
import { getResolverArgs } from 'src/engine/api/graphql/workspace-schema-builder/utils/get-resolver-args.util';
import { objectContainsRelationField } from 'src/engine/api/graphql/workspace-schema-builder/utils/object-contains-relation-field';
import { RelationMetadataType } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
import {
RelationDirection,
deduceRelationDirection,
} from 'src/engine/utils/deduce-relation-direction.util';
import { isRelationFieldMetadataType } from 'src/engine/utils/is-relation-field-metadata-type.util';
import { ArgsFactory } from './args.factory';
import { RelationTypeFactory } from './relation-type.factory';
export enum ObjectTypeDefinitionKind {
Connection = 'Connection',
Edge = 'Edge',
Plain = '',
}
export interface ObjectTypeDefinition {
target: string;
kind: ObjectTypeDefinitionKind;
type: GraphQLObjectType;
}
@Injectable()
export class ExtendObjectTypeDefinitionFactory {
private readonly logger = new Logger(ExtendObjectTypeDefinitionFactory.name);
constructor(
private readonly relationTypeFactory: RelationTypeFactory,
private readonly argsFactory: ArgsFactory,
private readonly typeDefinitionsStorage: TypeDefinitionsStorage,
) {}
public create(
objectMetadata: ObjectMetadataInterface,
options: WorkspaceBuildSchemaOptions,
): ObjectTypeDefinition {
const kind = ObjectTypeDefinitionKind.Plain;
const gqlType = this.typeDefinitionsStorage.getObjectTypeByKey(
objectMetadata.id,
kind,
);
const containsRelationField = objectContainsRelationField(objectMetadata);
if (!gqlType) {
this.logger.error(
`Could not find a GraphQL type for ${objectMetadata.id.toString()}`,
{
objectMetadata,
options,
},
);
throw new Error(
`Could not find a GraphQL type for ${objectMetadata.id.toString()}`,
);
}
// Security check to avoid extending an object that does not need to be extended
if (!containsRelationField) {
this.logger.error(
`This object does not need to be extended: ${objectMetadata.id.toString()}`,
{
objectMetadata,
options,
},
);
throw new Error(
`This object does not need to be extended: ${objectMetadata.id.toString()}`,
);
}
// Extract current object config to extend it
const config = gqlType.toConfig();
// Recreate the same object type with the new fields
return {
target: objectMetadata.id,
kind,
type: new GraphQLObjectType({
...config,
fields: () => ({
...config.fields,
...this.generateFields(objectMetadata, options),
}),
}),
};
}
private generateFields(
objectMetadata: ObjectMetadataInterface,
options: WorkspaceBuildSchemaOptions,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
// eslint-disable-next-line @typescript-eslint/no-explicit-any
): GraphQLFieldConfigMap<any, any> {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const fields: GraphQLFieldConfigMap<any, any> = {};
for (const fieldMetadata of objectMetadata.fields) {
// Ignore relation fields as they are already defined
if (!isRelationFieldMetadataType(fieldMetadata.type)) {
continue;
}
const relationMetadata =
fieldMetadata.fromRelationMetadata ?? fieldMetadata.toRelationMetadata;
if (!relationMetadata) {
this.logger.error(
`Could not find a relation metadata for ${fieldMetadata.id}`,
{ fieldMetadata },
);
throw new Error(
`Could not find a relation metadata for ${fieldMetadata.id}`,
);
}
const relationDirection = deduceRelationDirection(
fieldMetadata,
relationMetadata,
);
const relationType = this.relationTypeFactory.create(
fieldMetadata,
relationMetadata,
relationDirection,
);
let argsType: GraphQLFieldConfigArgumentMap | undefined = undefined;
// Args are only needed when relation is of kind `oneToMany` and the relation direction is `from`
if (
relationMetadata.relationType === RelationMetadataType.ONE_TO_MANY &&
relationDirection === RelationDirection.FROM
) {
const args = getResolverArgs('findMany');
argsType = this.argsFactory.create(
{
args,
objectMetadataId: relationMetadata.toObjectMetadataId,
},
options,
);
}
fields[fieldMetadata.name] = {
type: relationType,
args: argsType,
description: fieldMetadata.description,
};
}
return fields;
}
}

4
packages/twenty-server/src/engine/api/graphql/workspace-schema-builder/factories/factories.ts
View File

@ -11,7 +11,6 @@ import { ConnectionTypeDefinitionFactory } from './connection-type-definition.fa
import { ConnectionTypeFactory } from './connection-type.factory';
import { EdgeTypeDefinitionFactory } from './edge-type-definition.factory';
import { EdgeTypeFactory } from './edge-type.factory';
import { ExtendObjectTypeDefinitionFactory } from './extend-object-type-definition.factory';
import { InputTypeDefinitionFactory } from './input-type-definition.factory';
import { InputTypeFactory } from './input-type.factory';
import { MutationTypeFactory } from './mutation-type.factory';
@ -19,7 +18,6 @@ import { ObjectTypeDefinitionFactory } from './object-type-definition.factory';
import { OrphanedTypesFactory } from './orphaned-types.factory';
import { OutputTypeFactory } from './output-type.factory';
import { QueryTypeFactory } from './query-type.factory';
import { RelationTypeFactory } from './relation-type.factory';
import { RootTypeFactory } from './root-type.factory';
export const workspaceSchemaBuilderFactories = [
@ -32,9 +30,7 @@ export const workspaceSchemaBuilderFactories = [
CompositeObjectTypeDefinitionFactory,
EnumTypeDefinitionFactory,
CompositeEnumTypeDefinitionFactory,
RelationTypeFactory,
RelationTypeV2Factory,
ExtendObjectTypeDefinitionFactory,
ExtendObjectTypeDefinitionV2Factory,
ConnectionTypeFactory,
ConnectionTypeDefinitionFactory,

62
packages/twenty-server/src/engine/api/graphql/workspace-schema-builder/factories/relation-type.factory.ts
View File

@ -1,62 +0,0 @@
import { Injectable, Logger } from '@nestjs/common';
import { GraphQLOutputType } from 'graphql';
import { FieldMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata.interface';
import { RelationMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-metadata.interface';
import { TypeDefinitionsStorage } from 'src/engine/api/graphql/workspace-schema-builder/storages/type-definitions.storage';
import { RelationMetadataType } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
import { RelationDirection } from 'src/engine/utils/deduce-relation-direction.util';
import { ObjectTypeDefinitionKind } from './object-type-definition.factory';
@Injectable()
export class RelationTypeFactory {
private readonly logger = new Logger(RelationTypeFactory.name);
constructor(
private readonly typeDefinitionsStorage: TypeDefinitionsStorage,
) {}
public create(
fieldMetadata: FieldMetadataInterface,
relationMetadata: RelationMetadataInterface,
relationDirection: RelationDirection,
): GraphQLOutputType {
let relationGqlType: GraphQLOutputType | undefined = undefined;
if (
relationDirection === RelationDirection.FROM &&
relationMetadata.relationType === RelationMetadataType.ONE_TO_MANY
) {
relationGqlType = this.typeDefinitionsStorage.getObjectTypeByKey(
relationMetadata.toObjectMetadataId,
ObjectTypeDefinitionKind.Connection,
);
} else {
const relationObjectId =
relationDirection === RelationDirection.FROM
? relationMetadata.toObjectMetadataId
: relationMetadata.fromObjectMetadataId;
relationGqlType = this.typeDefinitionsStorage.getObjectTypeByKey(
relationObjectId,
ObjectTypeDefinitionKind.Plain,
);
}
if (!relationGqlType) {
this.logger.error(
`Could not find a relation type for ${fieldMetadata.id}`,
{
fieldMetadata,
},
);
throw new Error(`Could not find a relation type for ${fieldMetadata.id}`);
}
return relationGqlType;
}
}

26
packages/twenty-server/src/engine/api/rest/core/interfaces/rest-api-base.handler.ts
View File

@ -1,6 +1,7 @@
import { BadRequestException, Inject } from '@nestjs/common';
import { Request } from 'express';
import chunk from 'lodash.chunk';
import { FieldMetadataType } from 'twenty-shared/types';
import { capitalize, isDefined } from 'twenty-shared/utils';
import { In, ObjectLiteral } from 'typeorm';
@ -212,14 +213,31 @@ export abstract class RestApiBaseHandler {
depth: depth,
});
const unorderedRecords = await repository.find({
const relationsChunk = chunk(relations, 50);
const recordsWithoutRelations = await repository.find({
where: { id: In(recordIds) },
relations,
});
const recordMap = new Map(unorderedRecords.map((r) => [r.id, r]));
const recordsMap = new Map(
recordsWithoutRelations.map((record) => [record.id, record]),
);
const orderedRecords = recordIds.map((id) => recordMap.get(id));
for (const relationChunk of relationsChunk) {
const records = await repository.find({
where: { id: In(recordIds) },
relations: relationChunk,
});
records.map((record) => {
recordsMap.set(record.id, {
...recordsMap.get(record.id),
...record,
});
});
}
const orderedRecords = recordIds.map((id) => recordsMap.get(id));
return orderedRecords;
}

13
packages/twenty-server/src/engine/api/rest/core/query-builder/utils/__tests__/map-field-metadata-to-graphql-query.utils.spec.ts
View File

@ -1,6 +1,8 @@
import { FieldMetadataType } from 'twenty-shared/types';
import { FieldMetadataDefaultSettings } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata-settings.interface';
import { FieldMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata.interface';
import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
import {
fieldCurrencyMock,
@ -9,7 +11,6 @@ import {
objectMetadataItemMock,
} from 'src/engine/api/__mocks__/object-metadata-item.mock';
import { mapFieldMetadataToGraphqlQuery } from 'src/engine/api/rest/core/query-builder/utils/map-field-metadata-to-graphql-query.utils';
import { RelationMetadataType } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
import { FieldMetadataMap } from 'src/engine/metadata-modules/types/field-metadata-map';
import { ObjectMetadataItemWithFieldMaps } from 'src/engine/metadata-modules/types/object-metadata-item-with-field-maps';
import { ObjectMetadataMaps } from 'src/engine/metadata-modules/types/object-metadata-maps';
@ -109,12 +110,14 @@ describe('mapFieldMetadataToGraphqlQuery', () => {
name: 'toObjectMetadataName',
label: 'Test Field',
objectMetadataId: 'object-metadata-id',
fromRelationMetadata: {
relationType: RelationMetadataType.ONE_TO_MANY,
toObjectMetadataId: objectMetadataItemMock.id,
} as any,
};
if (fieldMetadataType === FieldMetadataType.RELATION) {
field.settings = {
relationType: RelationType.MANY_TO_ONE,
} as FieldMetadataDefaultSettings;
}
expect(
mapFieldMetadataToGraphqlQuery(objectMetadataMapsMock, field),
).toBeDefined();

31
packages/twenty-server/src/engine/api/rest/core/query-builder/utils/map-field-metadata-to-graphql-query.utils.ts
View File

@ -1,9 +1,10 @@
import { FieldMetadataType } from 'twenty-shared/types';
import { FieldMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata.interface';
import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
import { RelationMetadataType } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
import { ObjectMetadataMaps } from 'src/engine/metadata-modules/types/object-metadata-maps';
import { isFieldMetadataInterfaceOfType } from 'src/engine/utils/is-field-metadata-of-type.util';
const DEFAULT_DEPTH_VALUE = 1;
@ -41,20 +42,17 @@ export const mapFieldMetadataToGraphqlQuery = (
return field.name;
} else if (
maxDepthForRelations > 0 &&
fieldType === FieldMetadataType.RELATION &&
field.toRelationMetadata?.relationType === RelationMetadataType.ONE_TO_MANY
isFieldMetadataInterfaceOfType(field, FieldMetadataType.RELATION) &&
field.settings?.relationType === RelationType.MANY_TO_ONE
) {
const fromObjectMetadataId = field.toRelationMetadata?.fromObjectMetadataId;
const targetObjectMetadataId = field.relationTargetObjectMetadataId;
if (!fromObjectMetadataId) {
if (!targetObjectMetadataId) {
return '';
}
const relationMetadataItem = objectMetadataMaps.byId[fromObjectMetadataId];
if (!relationMetadataItem) {
return '';
}
const relationMetadataItem =
objectMetadataMaps.byId[targetObjectMetadataId];
return `${field.name}
{
@ -71,17 +69,16 @@ export const mapFieldMetadataToGraphqlQuery = (
}`;
} else if (
maxDepthForRelations > 0 &&
fieldType === FieldMetadataType.RELATION &&
field.fromRelationMetadata?.relationType ===
RelationMetadataType.ONE_TO_MANY
isFieldMetadataInterfaceOfType(field, FieldMetadataType.RELATION) &&
field.settings?.relationType === RelationType.ONE_TO_MANY
) {
const toObjectMetadataId = field.fromRelationMetadata?.toObjectMetadataId;
const targetObjectMetadataId = field.relationTargetObjectMetadataId;
if (!toObjectMetadataId) {
if (!targetObjectMetadataId) {
return '';
}
const relationMetadataItem = objectMetadataMaps.byId[toObjectMetadataId];
const relationMetadataItem =
objectMetadataMaps.byId[targetObjectMetadataId];
if (!relationMetadataItem) {
return '';

2
packages/twenty-server/src/engine/api/rest/metadata/query-builder/utils/__tests__/parse-metadata-path.utils.spec.ts
View File

@ -25,7 +25,7 @@ describe('parseMetadataPath', () => {
const request: any = { path: '/rest/metadata/INVALID' };
expect(() => parseMetadataPath(request)).toThrow(
'Query path \'/rest/metadata/INVALID\' invalid. Metadata path "INVALID" does not exist. Valid examples: /rest/metadata/fields or /rest/metadata/objects or /rest/metadata/relations',
'Query path \'/rest/metadata/INVALID\' invalid. Metadata path "INVALID" does not exist. Valid examples: /rest/metadata/fields or /rest/metadata/objects',
);
});

62
packages/twenty-server/src/engine/api/rest/metadata/query-builder/utils/fetch-metadata-fields.utils.ts
View File

@ -1,28 +1,4 @@
export const fetchMetadataFields = (objectNamePlural: string) => {
const fromRelations = `
toObjectMetadata {
id
dataSourceId
nameSingular
namePlural
isSystem
isRemote
}
toFieldMetadataId
`;
const toRelations = `
fromObjectMetadata {
id
dataSourceId
nameSingular
namePlural
isSystem
isRemote
}
fromFieldMetadataId
`;
const fields = `
type
name
@ -35,18 +11,29 @@ export const fetchMetadataFields = (objectNamePlural: string) => {
isNullable
createdAt
updatedAt
fromRelationMetadata {
id
relationType
${fromRelations}
}
toRelationMetadata {
id
relationType
${toRelations}
}
defaultValue
options
relation {
type
targetObjectMetadata {
id
nameSingular
namePlural
}
targetFieldMetadata {
id
name
}
sourceObjectMetadata {
id
nameSingular
namePlural
}
sourceFieldMetadata {
id
name
}
}
`;
switch (objectNamePlural) {
@ -77,12 +64,5 @@ export const fetchMetadataFields = (objectNamePlural: string) => {
`;
case 'fields':
return fields;
case 'relationMetadata':
return `
id
relationType
${fromRelations}
${toRelations}
`;
}
};

15
packages/twenty-server/src/engine/api/rest/metadata/query-builder/utils/parse-metadata-path.utils.ts
View File

@ -13,9 +13,9 @@ export const parseMetadataPath = (
);
}
if (!['fields', 'objects', 'relations'].includes(queryAction[0])) {
if (!['fields', 'objects'].includes(queryAction[0])) {
throw new BadRequestException(
`Query path '${request.path}' invalid. Metadata path "${queryAction[0]}" does not exist. Valid examples: /rest/metadata/fields or /rest/metadata/objects or /rest/metadata/relations`,
`Query path '${request.path}' invalid. Metadata path "${queryAction[0]}" does not exist. Valid examples: /rest/metadata/fields or /rest/metadata/objects`,
);
}
@ -35,12 +35,6 @@ export const parseMetadataPath = (
objectNamePlural: 'objects',
id: queryAction[1],
};
case 'relations':
return {
objectNameSingular: 'relationMetadata',
objectNamePlural: 'relationMetadata',
id: queryAction[1],
};
default:
return { objectNameSingular: '', objectNamePlural: '', id: '' };
}
@ -50,11 +44,6 @@ export const parseMetadataPath = (
return { objectNameSingular: 'field', objectNamePlural: 'fields' };
case 'objects':
return { objectNameSingular: 'object', objectNamePlural: 'objects' };
case 'relations':
return {
objectNameSingular: 'relationMetadata',
objectNamePlural: 'relationMetadata',
};
default:
return { objectNameSingular: '', objectNamePlural: '' };
}