admin/twenty
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: '' };
}

8
packages/twenty-server/src/engine/core-modules/__mocks__/mockObjectMetadataItemsWithFieldMaps.ts
View File

@ -20,8 +20,6 @@ export const mockObjectMetadataItemsWithFieldMaps: ObjectMetadataItemWithFieldMa
isSystem: false,
isAuditLogged: true,
isSearchable: true,
fromRelations: [],
toRelations: [],
labelIdentifierFieldMetadataId: 'nameFieldMetadataId',
imageIdentifierFieldMetadataId: '',
workspaceId: '',
@ -101,8 +99,6 @@ export const mockObjectMetadataItemsWithFieldMaps: ObjectMetadataItemWithFieldMa
isSystem: false,
isAuditLogged: true,
isSearchable: true,
fromRelations: [],
toRelations: [],
labelIdentifierFieldMetadataId: 'nameFieldMetadataId',
imageIdentifierFieldMetadataId: '',
workspaceId: '',
@ -212,8 +208,6 @@ export const mockObjectMetadataItemsWithFieldMaps: ObjectMetadataItemWithFieldMa
isSystem: false,
isAuditLogged: true,
isSearchable: true,
fromRelations: [],
toRelations: [],
labelIdentifierFieldMetadataId: 'nameFieldMetadataId',
imageIdentifierFieldMetadataId: 'imageIdentifierFieldMetadataId',
workspaceId: '',
@ -323,8 +317,6 @@ export const mockObjectMetadataItemsWithFieldMaps: ObjectMetadataItemWithFieldMa
isSystem: true,
isAuditLogged: true,
isSearchable: false,
fromRelations: [],
toRelations: [],
labelIdentifierFieldMetadataId: '',
imageIdentifierFieldMetadataId: '',
workspaceId: '',

2
packages/twenty-server/src/engine/core-modules/actor/actor.module.ts
View File

@ -8,7 +8,7 @@ import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/
import { CreatedByFromAuthContextService } from './services/created-by-from-auth-context.service';
@Module({
imports: [TypeOrmModule.forFeature([FieldMetadataEntity], 'metadata')],
imports: [TypeOrmModule.forFeature([FieldMetadataEntity], 'core')],
providers: [
CreatedByCreateManyPreQueryHook,
CreatedByCreateOnePreQueryHook,

4
packages/twenty-server/src/engine/core-modules/actor/services/__tests__/created-by-from-auth-context.service.spec.ts
View File

@ -10,10 +10,10 @@ import {
FieldActorSource,
} from 'src/engine/metadata-modules/field-metadata/composite-types/actor.composite-type';
import { FullNameMetadata } from 'src/engine/metadata-modules/field-metadata/composite-types/full-name.composite-type';
import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
import { ApiKeyWorkspaceEntity } from 'src/modules/api-key/standard-objects/api-key.workspace-entity';
import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
type TestingAuthContext = Omit<AuthContext, 'workspace' | 'apiKey' | 'user'> & {
workspace: Partial<Workspace>;
@ -51,7 +51,7 @@ describe('CreatedByFromAuthContextService', () => {
useValue: twentyORMGlobalManager,
},
{
provide: getRepositoryToken(FieldMetadataEntity, 'metadata'),
provide: getRepositoryToken(FieldMetadataEntity, 'core'),
useValue: {
findOne: jest.fn().mockResolvedValue(true),
},

4
packages/twenty-server/src/engine/core-modules/actor/services/created-by-from-auth-context.service.ts
View File

@ -8,9 +8,9 @@ import { buildCreatedByFromApiKey } from 'src/engine/core-modules/actor/utils/bu
import { buildCreatedByFromFullNameMetadata } from 'src/engine/core-modules/actor/utils/build-created-by-from-full-name-metadata.util';
import { AuthContext } from 'src/engine/core-modules/auth/types/auth-context.type';
import { ActorMetadata } from 'src/engine/metadata-modules/field-metadata/composite-types/actor.composite-type';
import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
// eslint-disable-next-line @typescript-eslint/no-explicit-any
export type CreateInput = Record<string, any>;
@ -20,7 +20,7 @@ export class CreatedByFromAuthContextService {
private readonly logger = new Logger(CreatedByFromAuthContextService.name);
constructor(
@InjectRepository(FieldMetadataEntity, 'metadata')
@InjectRepository(FieldMetadataEntity, 'core')
private readonly fieldMetadataRepository: Repository<FieldMetadataEntity>,
private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
) {}

2
packages/twenty-server/src/engine/core-modules/auth/auth.module.ts
View File

@ -86,7 +86,7 @@ import { JwtAuthStrategy } from './strategies/jwt.auth.strategy';
],
'core',
),
TypeOrmModule.forFeature([ObjectMetadataEntity], 'metadata'),
TypeOrmModule.forFeature([ObjectMetadataEntity], 'core'),
HttpModule,
UserWorkspaceModule,
WorkspaceModule,

2
packages/twenty-server/src/engine/core-modules/auth/services/create-calendar-channel.service.ts
View File

@ -27,7 +27,7 @@ export class CreateCalendarChannelService {
constructor(
private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
private readonly workspaceEventEmitter: WorkspaceEventEmitter,
@InjectRepository(ObjectMetadataEntity, 'metadata')
@InjectRepository(ObjectMetadataEntity, 'core')
private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
) {}

2
packages/twenty-server/src/engine/core-modules/auth/services/create-connected-account.service.ts
View File

@ -28,7 +28,7 @@ export class CreateConnectedAccountService {
constructor(
private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
private readonly workspaceEventEmitter: WorkspaceEventEmitter,
@InjectRepository(ObjectMetadataEntity, 'metadata')
@InjectRepository(ObjectMetadataEntity, 'core')
private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
) {}

2
packages/twenty-server/src/engine/core-modules/auth/services/create-message-channel.service.ts
View File

@ -29,7 +29,7 @@ export class CreateMessageChannelService {
constructor(
private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
private readonly workspaceEventEmitter: WorkspaceEventEmitter,
@InjectRepository(ObjectMetadataEntity, 'metadata')
@InjectRepository(ObjectMetadataEntity, 'core')
private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
) {}

2
packages/twenty-server/src/engine/core-modules/auth/services/google-apis.service.spec.ts
View File

@ -100,7 +100,7 @@ describe('GoogleAPIsService', () => {
},
},
{
provide: getRepositoryToken(ObjectMetadataEntity, 'metadata'),
provide: getRepositoryToken(ObjectMetadataEntity, 'core'),
useValue: {
findOneOrFail: jest.fn(),
},

7
packages/twenty-server/src/engine/core-modules/auth/services/google-apis.service.ts
View File

@ -1,8 +1,6 @@
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { ConnectedAccountProvider } from 'twenty-shared/types';
import { Repository } from 'typeorm';
import { v4 } from 'uuid';
import {
@ -20,10 +18,8 @@ import { InjectMessageQueue } from 'src/engine/core-modules/message-queue/decora
import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
import { MessageQueueService } from 'src/engine/core-modules/message-queue/services/message-queue.service';
import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
import { WorkspaceEntityManager } from 'src/engine/twenty-orm/entity-manager/workspace-entity-manager';
import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
import { WorkspaceEventEmitter } from 'src/engine/workspace-event-emitter/workspace-event-emitter';
import {
CalendarEventListFetchJob,
CalendarEventListFetchJobData,
@ -60,9 +56,6 @@ export class GoogleAPIsService {
private readonly createCalendarChannelService: CreateCalendarChannelService,
private readonly createConnectedAccountService: CreateConnectedAccountService,
private readonly updateConnectedAccountOnReconnectService: UpdateConnectedAccountOnReconnectService,
private readonly workspaceEventEmitter: WorkspaceEventEmitter,
@InjectRepository(ObjectMetadataEntity, 'metadata')
private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
private readonly googleAPIScopesService: GoogleAPIScopesService,
) {}

2
packages/twenty-server/src/engine/core-modules/auth/services/microsoft-apis.service.spec.ts
View File

@ -101,7 +101,7 @@ describe('MicrosoftAPIsService', () => {
},
},
{
provide: getRepositoryToken(ObjectMetadataEntity, 'metadata'),
provide: getRepositoryToken(ObjectMetadataEntity, 'core'),
useValue: {
findOneOrFail: jest.fn(),
},

7
packages/twenty-server/src/engine/core-modules/auth/services/microsoft-apis.service.ts
View File

@ -1,8 +1,6 @@
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { ConnectedAccountProvider } from 'twenty-shared/types';
import { Repository } from 'typeorm';
import { v4 } from 'uuid';
import { CreateCalendarChannelService } from 'src/engine/core-modules/auth/services/create-calendar-channel.service';
@ -18,10 +16,8 @@ import { InjectMessageQueue } from 'src/engine/core-modules/message-queue/decora
import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
import { MessageQueueService } from 'src/engine/core-modules/message-queue/services/message-queue.service';
import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
import { WorkspaceEntityManager } from 'src/engine/twenty-orm/entity-manager/workspace-entity-manager';
import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
import { WorkspaceEventEmitter } from 'src/engine/workspace-event-emitter/workspace-event-emitter';
import {
CalendarEventListFetchJob,
CalendarEventListFetchJobData,
@ -59,9 +55,6 @@ export class MicrosoftAPIsService {
private readonly createMessageFolderService: CreateMessageFolderService,
private readonly createConnectedAccountService: CreateConnectedAccountService,
private readonly updateConnectedAccountOnReconnectService: UpdateConnectedAccountOnReconnectService,
private readonly workspaceEventEmitter: WorkspaceEventEmitter,
@InjectRepository(ObjectMetadataEntity, 'metadata')
private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
private readonly twentyConfigService: TwentyConfigService,
) {}

2
packages/twenty-server/src/engine/core-modules/auth/services/reset-calendar-channel.service.ts
View File

@ -24,7 +24,7 @@ export class ResetCalendarChannelService {
constructor(
private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
private readonly workspaceEventEmitter: WorkspaceEventEmitter,
@InjectRepository(ObjectMetadataEntity, 'metadata')
@InjectRepository(ObjectMetadataEntity, 'core')
private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
) {}

2
packages/twenty-server/src/engine/core-modules/auth/services/reset-message-channel.service.ts
View File

@ -25,7 +25,7 @@ export class ResetMessageChannelService {
constructor(
private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
private readonly workspaceEventEmitter: WorkspaceEventEmitter,
@InjectRepository(ObjectMetadataEntity, 'metadata')
@InjectRepository(ObjectMetadataEntity, 'core')
private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
) {}

2
packages/twenty-server/src/engine/core-modules/auth/services/update-connected-account-on-reconnect.service.ts
View File

@ -25,7 +25,7 @@ export class UpdateConnectedAccountOnReconnectService {
constructor(
private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
private readonly workspaceEventEmitter: WorkspaceEventEmitter,
@InjectRepository(ObjectMetadataEntity, 'metadata')
@InjectRepository(ObjectMetadataEntity, 'core')
private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
) {}

8
packages/twenty-server/src/engine/core-modules/domain-manager/services/domain-manager.service.ts
View File

@ -4,7 +4,6 @@ import { InjectRepository } from '@nestjs/typeorm';
import { isDefined } from 'twenty-shared/utils';
import { Repository } from 'typeorm';
import { SEED_APPLE_WORKSPACE_ID } from 'src/database/typeorm-seeds/core/workspaces';
import { WorkspaceSubdomainCustomDomainAndIsCustomDomainEnabledType } from 'src/engine/core-modules/domain-manager/domain-manager.type';
import { CustomDomainValidRecords } from 'src/engine/core-modules/domain-manager/dtos/custom-domain-valid-records';
import { generateRandomSubdomain } from 'src/engine/core-modules/domain-manager/utils/generate-random-subdomain';
@ -159,12 +158,7 @@ export class DomainManagerService {
);
}
const foundWorkspace =
workspaces.length === 1
? workspaces[0]
: workspaces.filter(
(workspace) => workspace.id === SEED_APPLE_WORKSPACE_ID,
)?.[0];
const foundWorkspace = workspaces[0];
workspaceValidator.assertIsDefinedOrThrow(foundWorkspace);

2
packages/twenty-server/src/engine/core-modules/event-emitter/utils/__tests__/object-record-changed-values.spec.ts
View File

@ -11,8 +11,6 @@ const mockObjectMetadata: ObjectMetadataInterface = {
description: 'Test object metadata',
targetTableName: 'test_table',
workspaceId: '1',
fromRelations: [],
toRelations: [],
fields: [],
indexMetadatas: [],
isSystem: false,

2
packages/twenty-server/src/engine/core-modules/message-queue/jobs.module.ts
View File

@ -2,7 +2,6 @@ import { Module } from '@nestjs/common';
import { ModuleRef } from '@nestjs/core';
import { TypeOrmModule } from '@nestjs/typeorm';
import { DataSeedDemoWorkspaceModule } from 'src/database/commands/data-seed-demo-workspace/data-seed-demo-workspace.module';
import { TypeORMModule } from 'src/database/typeorm/typeorm.module';
import { AuditJobModule } from 'src/engine/core-modules/audit/jobs/audit-job.module';
import { AuthModule } from 'src/engine/core-modules/auth/auth.module';
@ -44,7 +43,6 @@ import { WorkflowModule } from 'src/modules/workflow/workflow.module';
UserModule,
UserVarsModule,
EmailModule,
DataSeedDemoWorkspaceModule,
BillingModule,
UserWorkspaceModule,
WorkspaceModule,

46
packages/twenty-server/src/engine/core-modules/open-api/open-api.service.ts
View File

@ -145,10 +145,6 @@ export class OpenApiService {
nameSingular: 'field',
namePlural: 'fields',
},
{
nameSingular: 'relation',
namePlural: 'relations',
},
];
schema.paths = metadata.reduce((path, item) => {
@ -191,30 +187,28 @@ export class OpenApiService {
'401': { $ref: '#/components/responses/401' },
},
},
...(item.nameSingular !== 'relation' && {
get: {
tags: [item.namePlural],
summary: `Find One ${item.nameSingular}`,
parameters: [{ $ref: '#/components/parameters/idPath' }],
responses: {
'200': getFindOneResponse200(item),
'400': { $ref: '#/components/responses/400' },
'401': { $ref: '#/components/responses/401' },
},
get: {
tags: [item.namePlural],
summary: `Find One ${item.nameSingular}`,
parameters: [{ $ref: '#/components/parameters/idPath' }],
responses: {
'200': getFindOneResponse200(item),
'400': { $ref: '#/components/responses/400' },
'401': { $ref: '#/components/responses/401' },
},
patch: {
tags: [item.namePlural],
summary: `Update One ${item.nameSingular}`,
operationId: `updateOne${capitalize(item.nameSingular)}`,
parameters: [{ $ref: '#/components/parameters/idPath' }],
requestBody: getUpdateRequestBody(capitalize(item.nameSingular)),
responses: {
'200': getUpdateOneResponse200(item, true),
'400': { $ref: '#/components/responses/400' },
'401': { $ref: '#/components/responses/401' },
},
},
patch: {
tags: [item.namePlural],
summary: `Update One ${item.nameSingular}`,
operationId: `updateOne${capitalize(item.nameSingular)}`,
parameters: [{ $ref: '#/components/parameters/idPath' }],
requestBody: getUpdateRequestBody(capitalize(item.nameSingular)),
responses: {
'200': getUpdateOneResponse200(item, true),
'400': { $ref: '#/components/responses/400' },
'401': { $ref: '#/components/responses/401' },
},
}),
},
} as OpenAPIV3_1.PathItemObject;
return path;

24
packages/twenty-server/src/engine/core-modules/open-api/utils/__tests__/components.utils.spec.ts
View File

@ -1,5 +1,5 @@
import { FieldMetadataType } from 'twenty-shared/types';
import { EachTestingContext } from 'twenty-shared/testing';
import { FieldMetadataType } from 'twenty-shared/types';
import { NumberDataType } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata-settings.interface';
@ -196,6 +196,10 @@ describe('computeSchemaComponents', () => {
"fieldRawJson": {
"type": "object",
},
"fieldRelationId": {
"format": "uuid",
"type": "string",
},
"fieldRichText": {
"type": "string",
},
@ -407,10 +411,16 @@ describe('computeSchemaComponents', () => {
"type": "object",
},
"fieldRelation": {
"items": {
"$ref": "#/components/schemas/ToObjectMetadataName for Response",
},
"type": "array",
"oneOf": [
{
"$ref": "#/components/schemas/RelationTargetObject for Response",
},
],
"type": "object",
},
"fieldRelationId": {
"format": "uuid",
"type": "string",
},
"fieldRichText": {
"type": "string",
@ -612,6 +622,10 @@ describe('computeSchemaComponents', () => {
"fieldRawJson": {
"type": "object",
},
"fieldRelationId": {
"format": "uuid",
"type": "string",
},
"fieldRichText": {
"type": "string",
},

164
packages/twenty-server/src/engine/core-modules/open-api/utils/components.utils.ts
View File

@ -6,6 +6,7 @@ import {
FieldMetadataSettings,
NumberDataType,
} from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata-settings.interface';
import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
import {
computeDepthParameters,
@ -18,7 +19,7 @@ import {
} from 'src/engine/core-modules/open-api/utils/parameters.utils';
import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
import { RelationMetadataType } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
import { isFieldMetadataEntityOfType } from 'src/engine/utils/is-field-metadata-of-type.util';
type Property = OpenAPIV3_1.SchemaObject;
@ -95,12 +96,30 @@ const getSchemaComponentsProperties = ({
return item.fields.reduce((node, field) => {
if (
!isFieldAvailable(field, forResponse) ||
field.type === FieldMetadataType.RELATION ||
field.type === FieldMetadataType.TS_VECTOR
) {
return node;
}
if (
isFieldMetadataEntityOfType(field, FieldMetadataType.RELATION) &&
field.settings?.relationType === RelationType.MANY_TO_ONE
) {
node[`${field.name}Id`] = {
type: 'string',
format: 'uuid',
};
return node;
}
if (
isFieldMetadataEntityOfType(field, FieldMetadataType.RELATION) &&
field.settings?.relationType === RelationType.ONE_TO_MANY
) {
return node;
}
let itemProperty = {} as Property;
switch (field.type) {
@ -331,15 +350,28 @@ const getSchemaComponentsRelationProperties = (
let itemProperty = {} as Property;
if (field.fromRelationMetadata?.toObjectMetadata.nameSingular) {
itemProperty = {
type: 'array',
items: {
$ref: `#/components/schemas/${capitalize(
field.fromRelationMetadata?.toObjectMetadata.nameSingular,
)} for Response`,
},
};
if (isFieldMetadataEntityOfType(field, FieldMetadataType.RELATION)) {
if (field.settings?.relationType === RelationType.MANY_TO_ONE) {
itemProperty = {
type: 'object',
oneOf: [
{
$ref: `#/components/schemas/${capitalize(
field.relationTargetObjectMetadata.nameSingular,
)} for Response`,
},
],
};
} else if (field.settings?.relationType === RelationType.ONE_TO_MANY) {
itemProperty = {
type: 'array',
items: {
$ref: `#/components/schemas/${capitalize(
field.relationTargetObjectMetadata.nameSingular,
)} for Response`,
},
};
}
}
if (field.description) {
@ -608,50 +640,6 @@ export const computeMetadataSchemaComponents = (
isSystem: { type: 'boolean' },
createdAt: { type: 'string', format: 'date-time' },
updatedAt: { type: 'string', format: 'date-time' },
fromRelationMetadata: {
type: 'object',
properties: {
id: { type: 'string', format: 'uuid' },
relationType: {
type: 'string',
enum: Object.keys(RelationMetadataType),
},
toObjectMetadata: {
type: 'object',
properties: {
id: { type: 'string', format: 'uuid' },
dataSourceId: { type: 'string', format: 'uuid' },
nameSingular: { type: 'string' },
namePlural: { type: 'string' },
isSystem: { type: 'boolean' },
isRemote: { type: 'boolean' },
},
},
toFieldMetadataId: { type: 'string', format: 'uuid' },
},
},
toRelationMetadata: {
type: 'object',
properties: {
id: { type: 'string', format: 'uuid' },
relationType: {
type: 'string',
enum: Object.keys(RelationMetadataType),
},
fromObjectMetadata: {
type: 'object',
properties: {
id: { type: 'string', format: 'uuid' },
dataSourceId: { type: 'string', format: 'uuid' },
nameSingular: { type: 'string' },
namePlural: { type: 'string' },
isSystem: { type: 'boolean' },
isRemote: { type: 'boolean' },
},
},
fromFieldMetadataId: { type: 'string', format: 'uuid' },
},
},
},
};
schemas[`${capitalize(item.namePlural)} for Response`] = {
@ -664,72 +652,6 @@ export const computeMetadataSchemaComponents = (
return schemas;
}
case 'relation': {
schemas[`${capitalize(item.nameSingular)}`] = {
type: 'object',
description: 'A relation',
properties: {
relationType: {
type: 'string',
enum: Object.keys(RelationMetadataType),
},
fromObjectMetadataId: { type: 'string', format: 'uuid' },
toObjectMetadataId: { type: 'string', format: 'uuid' },
fromName: { type: 'string' },
fromLabel: { type: 'string' },
toName: { type: 'string' },
toLabel: { type: 'string' },
},
};
schemas[`${capitalize(item.namePlural)}`] = {
type: 'array',
description: `A list of ${item.namePlural}`,
items: {
$ref: `#/components/schemas/${capitalize(item.nameSingular)}`,
},
};
schemas[`${capitalize(item.nameSingular)} for Response`] = {
...schemas[`${capitalize(item.nameSingular)}`],
properties: {
relationType: {
type: 'string',
enum: Object.keys(RelationMetadataType),
},
id: { type: 'string', format: 'uuid' },
fromFieldMetadataId: { type: 'string', format: 'uuid' },
toFieldMetadataId: { type: 'string', format: 'uuid' },
fromObjectMetadata: {
type: 'object',
properties: {
id: { type: 'string', format: 'uuid' },
dataSourceId: { type: 'string', format: 'uuid' },
nameSingular: { type: 'string' },
namePlural: { type: 'string' },
isSystem: { type: 'boolean' },
isRemote: { type: 'boolean' },
},
},
toObjectMetadata: {
type: 'object',
properties: {
id: { type: 'string', format: 'uuid' },
dataSourceId: { type: 'string', format: 'uuid' },
nameSingular: { type: 'string' },
namePlural: { type: 'string' },
isSystem: { type: 'boolean' },
isRemote: { type: 'boolean' },
},
},
},
};
schemas[`${capitalize(item.namePlural)} for Response`] = {
type: 'array',
description: `A list of ${item.namePlural}`,
items: {
$ref: `#/components/schemas/${capitalize(item.nameSingular)} for Response`,
},
};
}
}
return schemas;

14
packages/twenty-server/src/engine/core-modules/open-api/utils/responses.utils.ts
View File

@ -10,9 +10,6 @@ export const getFindManyResponse200 = (
item.nameSingular,
)} for Response`;
const namePlural =
item.namePlural === 'relations' ? 'relationMetadata' : item.namePlural;
return {
description: 'Successful operation',
content: {
@ -23,7 +20,7 @@ export const getFindManyResponse200 = (
data: {
type: 'object',
properties: {
[namePlural]: {
[item.namePlural]: {
type: 'array',
items: {
$ref: schemaRef,
@ -90,10 +87,9 @@ export const getCreateOneResponse201 = (
) => {
const one = fromMetadata ? 'One' : '';
const nameSingular =
item.nameSingular === 'relation' ? 'relationMetadata' : item.nameSingular;
const schemaRef = `#/components/schemas/${capitalize(nameSingular)} for Response`;
const schemaRef = `#/components/schemas/${capitalize(
item.nameSingular,
)} for Response`;
return {
description: 'Successful operation',
@ -105,7 +101,7 @@ export const getCreateOneResponse201 = (
data: {
type: 'object',
properties: {
[`create${one}${capitalize(nameSingular)}`]: {
[`create${one}${capitalize(item.nameSingular)}`]: {
$ref: schemaRef,
},
},

2
packages/twenty-server/src/engine/core-modules/user-workspace/user-workspace.module.ts
View File

@ -28,7 +28,7 @@ import { WorkspaceDataSourceModule } from 'src/engine/workspace-datasource/works
[User, UserWorkspace, Workspace, TwoFactorMethod],
'core',
),
NestjsQueryTypeOrmModule.forFeature([ObjectMetadataEntity], 'metadata'),
NestjsQueryTypeOrmModule.forFeature([ObjectMetadataEntity], 'core'),
TypeORMModule,
DataSourceModule,
WorkspaceDataSourceModule,

4
packages/twenty-server/src/engine/core-modules/user-workspace/user-workspace.service.spec.ts
View File

@ -66,7 +66,7 @@ describe('UserWorkspaceService', () => {
},
},
{
provide: getRepositoryToken(ObjectMetadataEntity, 'metadata'),
provide: getRepositoryToken(ObjectMetadataEntity, 'core'),
useValue: {
findOneOrFail: jest.fn(),
},
@ -142,7 +142,7 @@ describe('UserWorkspaceService', () => {
);
userRepository = module.get(getRepositoryToken(User, 'core'));
objectMetadataRepository = module.get(
getRepositoryToken(ObjectMetadataEntity, 'metadata'),
getRepositoryToken(ObjectMetadataEntity, 'core'),
);
typeORMService = module.get<TypeORMService>(TypeORMService);
workspaceInvitationService = module.get<WorkspaceInvitationService>(

2
packages/twenty-server/src/engine/core-modules/user-workspace/user-workspace.service.ts
View File

@ -42,7 +42,7 @@ export class UserWorkspaceService extends TypeOrmQueryService<UserWorkspace> {
private readonly userWorkspaceRepository: Repository<UserWorkspace>,
@InjectRepository(User, 'core')
private readonly userRepository: Repository<User>,
@InjectRepository(ObjectMetadataEntity, 'metadata')
@InjectRepository(ObjectMetadataEntity, 'core')
private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
private readonly workspaceInvitationService: WorkspaceInvitationService,

4
packages/twenty-server/src/engine/core-modules/user/services/user.service.ts
View File

@ -16,7 +16,6 @@ import { User } from 'src/engine/core-modules/user/user.entity';
import { userValidator } from 'src/engine/core-modules/user/user.validate';
import { WorkspaceService } from 'src/engine/core-modules/workspace/services/workspace.service';
import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
import { DataSourceService } from 'src/engine/metadata-modules/data-source/data-source.service';
import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
import {
PermissionsException,
@ -33,9 +32,8 @@ export class UserService extends TypeOrmQueryService<User> {
constructor(
@InjectRepository(User, 'core')
private readonly userRepository: Repository<User>,
@InjectRepository(ObjectMetadataEntity, 'metadata')
@InjectRepository(ObjectMetadataEntity, 'core')
private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
private readonly dataSourceService: DataSourceService,
private readonly workspaceEventEmitter: WorkspaceEventEmitter,
private readonly workspaceService: WorkspaceService,
private readonly twentyORMGlobalManager: TwentyORMGlobalManager,

4
packages/twenty-server/src/engine/core-modules/user/user.module.ts
View File

@ -16,6 +16,7 @@ import { KeyValuePair } from 'src/engine/core-modules/key-value-pair/key-value-p
import { OnboardingModule } from 'src/engine/core-modules/onboarding/onboarding.module';
import { UserWorkspace } from 'src/engine/core-modules/user-workspace/user-workspace.entity';
import { UserWorkspaceModule } from 'src/engine/core-modules/user-workspace/user-workspace.module';
import { DeletedWorkspaceMemberTranspiler } from 'src/engine/core-modules/user/services/deleted-workspace-member-transpiler.service';
import { UserVarsModule } from 'src/engine/core-modules/user/user-vars/user-vars.module';
import { User } from 'src/engine/core-modules/user/user.entity';
import { UserResolver } from 'src/engine/core-modules/user/user.resolver';
@ -24,7 +25,6 @@ import { DataSourceModule } from 'src/engine/metadata-modules/data-source/data-s
import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
import { PermissionsModule } from 'src/engine/metadata-modules/permissions/permissions.module';
import { UserRoleModule } from 'src/engine/metadata-modules/user-role/user-role.module';
import { DeletedWorkspaceMemberTranspiler } from 'src/engine/core-modules/user/services/deleted-workspace-member-transpiler.service';
import { userAutoResolverOpts } from './user.auto-resolver-opts';
@ -40,7 +40,7 @@ import { UserService } from './services/user.service';
],
resolvers: userAutoResolverOpts,
}),
NestjsQueryTypeOrmModule.forFeature([ObjectMetadataEntity], 'metadata'),
NestjsQueryTypeOrmModule.forFeature([ObjectMetadataEntity], 'core'),
DataSourceModule,
FileUploadModule,
WorkspaceModule,

7
packages/twenty-server/src/engine/dataloaders/dataloader.interface.ts
View File

@ -3,18 +3,11 @@ import DataLoader from 'dataloader';
import {
FieldMetadataLoaderPayload,
RelationLoaderPayload,
RelationMetadataLoaderPayload,
} from 'src/engine/dataloaders/dataloader.service';
import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
import { RelationMetadataEntity } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
export interface IDataloaders {
relationMetadataLoader: DataLoader<
RelationMetadataLoaderPayload,
RelationMetadataEntity
>;
relationLoader: DataLoader<
RelationLoaderPayload,
{

3
packages/twenty-server/src/engine/dataloaders/dataloader.module.ts
View File

@ -2,10 +2,9 @@ import { Module } from '@nestjs/common';
import { DataloaderService } from 'src/engine/dataloaders/dataloader.service';
import { FieldMetadataModule } from 'src/engine/metadata-modules/field-metadata/field-metadata.module';
import { RelationMetadataModule } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.module';
@Module({
imports: [RelationMetadataModule, FieldMetadataModule],
imports: [FieldMetadataModule],
providers: [DataloaderService],
exports: [DataloaderService],
})

25
packages/twenty-server/src/engine/dataloaders/dataloader.service.ts
View File

@ -10,8 +10,6 @@ import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/
import { FieldMetadataService } from 'src/engine/metadata-modules/field-metadata/field-metadata.service';
import { FieldMetadataRelationService } from 'src/engine/metadata-modules/field-metadata/relation/field-metadata-relation.service';
import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
import { RelationMetadataEntity } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
import { RelationMetadataService } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.service';
export type RelationMetadataLoaderPayload = {
workspaceId: string;
@ -41,43 +39,20 @@ export type FieldMetadataLoaderPayload = {
@Injectable()
export class DataloaderService {
constructor(
private readonly relationMetadataService: RelationMetadataService,
private readonly fieldMetadataRelationService: FieldMetadataRelationService,
private readonly fieldMetadataService: FieldMetadataService,
) {}
createLoaders(): IDataloaders {
const relationMetadataLoader = this.createRelationMetadataLoader();
const relationLoader = this.createRelationLoader();
const fieldMetadataLoader = this.createFieldMetadataLoader();
return {
relationMetadataLoader,
relationLoader,
fieldMetadataLoader,
};
}
private createRelationMetadataLoader() {
return new DataLoader<
RelationMetadataLoaderPayload,
RelationMetadataEntity
>(async (dataLoaderParams: RelationMetadataLoaderPayload[]) => {
const workspaceId = dataLoaderParams[0].workspaceId;
const fieldMetadataItems = dataLoaderParams.map(
(dataLoaderParam) => dataLoaderParam.fieldMetadata,
);
const relationsMetadataCollection =
await this.relationMetadataService.findManyRelationMetadataByFieldMetadataIds(
fieldMetadataItems,
workspaceId,
);
return relationsMetadataCollection;
});
}
private createRelationLoader() {
return new DataLoader<
RelationLoaderPayload,

4
packages/twenty-server/src/engine/metadata-modules/data-source/data-source.module.ts
View File

@ -1,11 +1,11 @@
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { DataSourceService } from './data-source.service';
import { DataSourceEntity } from './data-source.entity';
import { DataSourceService } from './data-source.service';
@Module({
imports: [TypeOrmModule.forFeature([DataSourceEntity], 'metadata')],
imports: [TypeOrmModule.forFeature([DataSourceEntity], 'core')],
providers: [DataSourceService],
exports: [DataSourceService],
})

2
packages/twenty-server/src/engine/metadata-modules/data-source/data-source.service.ts
View File

@ -13,7 +13,7 @@ import { DataSourceEntity } from './data-source.entity';
@Injectable()
export class DataSourceService {
constructor(
@InjectRepository(DataSourceEntity, 'metadata')
@InjectRepository(DataSourceEntity, 'core')
private readonly dataSourceMetadataRepository: Repository<DataSourceEntity>,
) {}

12
packages/twenty-server/src/engine/metadata-modules/field-metadata/dtos/create-field.input.ts
View File

@ -2,6 +2,9 @@ import { Field, InputType, OmitType } from '@nestjs/graphql';
import { Type } from 'class-transformer';
import { IsOptional, IsUUID, ValidateNested } from 'class-validator';
import GraphQLJSON from 'graphql-type-json';
import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
import { FieldMetadataDTO } from 'src/engine/metadata-modules/field-metadata/dtos/field-metadata.dto';
@ -18,6 +21,15 @@ export class CreateFieldInput extends OmitType(
@Field(() => Boolean, { nullable: true })
@IsOptional()
isRemoteCreation?: boolean;
@IsOptional()
@Field(() => GraphQLJSON, { nullable: true })
relationCreationPayload?: {
targetObjectMetadataId: string;
targetFieldLabel: string;
targetFieldIcon: string;
type: RelationType;
};
}
@InputType()

7
packages/twenty-server/src/engine/metadata-modules/field-metadata/dtos/field-metadata.dto.ts
View File

@ -37,7 +37,6 @@ import { FieldMetadataDefaultOption } from 'src/engine/metadata-modules/field-me
import { IsFieldMetadataDefaultValue } from 'src/engine/metadata-modules/field-metadata/validators/is-field-metadata-default-value.validator';
import { IsFieldMetadataOptions } from 'src/engine/metadata-modules/field-metadata/validators/is-field-metadata-options.validator';
import { ObjectMetadataDTO } from 'src/engine/metadata-modules/object-metadata/dtos/object-metadata.dto';
import { RelationMetadataDTO } from 'src/engine/metadata-modules/relation-metadata/dtos/relation-metadata.dto';
import { transformEnumValue } from 'src/engine/utils/transform-enum-value';
registerEnumType(FieldMetadataType, {
@ -57,12 +56,6 @@ registerEnumType(FieldMetadataType, {
disableSort: true,
maxResultsSize: 1000,
})
@Relation('toRelationMetadata', () => RelationMetadataDTO, {
nullable: true,
})
@Relation('fromRelationMetadata', () => RelationMetadataDTO, {
nullable: true,
})
@Relation('object', () => ObjectMetadataDTO, {
nullable: true,
})

50
packages/twenty-server/src/engine/metadata-modules/field-metadata/dtos/relation-definition.dto.ts
View File

@ -1,50 +0,0 @@
import { Field, ObjectType, registerEnumType } from '@nestjs/graphql';
import { IsEnum, IsNotEmpty } from 'class-validator';
import { Relation } from 'typeorm';
import { IDField } from '@ptc-org/nestjs-query-graphql';
import { FieldMetadataDTO } from 'src/engine/metadata-modules/field-metadata/dtos/field-metadata.dto';
import { ObjectMetadataDTO } from 'src/engine/metadata-modules/object-metadata/dtos/object-metadata.dto';
import { RelationMetadataType } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
export enum RelationDefinitionType {
ONE_TO_ONE = RelationMetadataType.ONE_TO_ONE,
ONE_TO_MANY = RelationMetadataType.ONE_TO_MANY,
MANY_TO_MANY = RelationMetadataType.MANY_TO_MANY,
MANY_TO_ONE = 'MANY_TO_ONE',
}
registerEnumType(RelationDefinitionType, {
name: 'RelationDefinitionType',
description: 'Relation definition type',
});
@ObjectType('RelationDefinition')
export class RelationDefinitionDTO {
@IsNotEmpty()
@IDField(() => UUIDScalarType)
relationId: string;
@IsNotEmpty()
@Field(() => ObjectMetadataDTO)
sourceObjectMetadata: Relation<ObjectMetadataDTO>;
@IsNotEmpty()
@Field(() => ObjectMetadataDTO)
targetObjectMetadata: Relation<ObjectMetadataDTO>;
@IsNotEmpty()
@Field(() => FieldMetadataDTO)
sourceFieldMetadata: Relation<FieldMetadataDTO>;
@IsNotEmpty()
@Field(() => FieldMetadataDTO)
targetFieldMetadata: Relation<FieldMetadataDTO>;
@IsEnum(RelationDefinitionType)
@IsNotEmpty()
@Field(() => RelationDefinitionType)
direction: RelationDefinitionType;
}

71
packages/twenty-server/src/engine/metadata-modules/field-metadata/field-metadata-validation.service.ts
View File

@ -1,17 +1,21 @@
import { Injectable } from '@nestjs/common';
import { plainToInstance } from 'class-transformer';
import { ClassConstructor, plainToInstance } from 'class-transformer';
import {
IsEnum,
IsInt,
IsOptional,
IsString,
IsUUID,
Max,
Min,
ValidationError,
validateOrReject,
} from 'class-validator';
import { FieldMetadataType } from 'twenty-shared/types';
import { FieldMetadataSettings } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata-settings.interface';
import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
import {
FieldMetadataException,
@ -42,12 +46,51 @@ class TextSettingsValidation {
displayedMaxRows?: number;
}
export class RelationCreationPayloadValidation {
@IsUUID()
targetObjectMetadataId?: string;
@IsString()
targetFieldLabel: string;
@IsString()
targetFieldIcon: string;
@IsEnum(RelationType)
type: RelationType;
}
@Injectable()
export class FieldMetadataValidationService<
T extends FieldMetadataType = FieldMetadataType,
> {
constructor() {}
async validateRelationCreationPayloadOrThrow(
relationCreationPayload: RelationCreationPayloadValidation,
) {
try {
const relationCreationPayloadInstance = plainToInstance(
RelationCreationPayloadValidation,
relationCreationPayload,
);
await validateOrReject(relationCreationPayloadInstance);
} catch (error) {
const errorMessages = Array.isArray(error)
? error
.map((err: ValidationError) => Object.values(err.constraints ?? {}))
.flat()
.join(', ')
: error.message;
throw new FieldMetadataException(
`Relation creation payload is invalid: ${errorMessages}`,
FieldMetadataExceptionCode.INVALID_FIELD_INPUT,
);
}
}
async validateSettingsOrThrow({
fieldType,
settings,
@ -57,19 +100,32 @@ export class FieldMetadataValidationService<
}) {
switch (fieldType) {
case FieldMetadataType.NUMBER:
await this.validateSettings(NumberSettingsValidation, settings);
await this.validateSettings<FieldMetadataType.NUMBER>(
NumberSettingsValidation,
settings,
);
break;
case FieldMetadataType.TEXT:
await this.validateSettings(TextSettingsValidation, settings);
await this.validateSettings<FieldMetadataType.TEXT>(
TextSettingsValidation,
settings,
);
break;
default:
break;
}
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
// eslint-disable-next-line @typescript-eslint/no-explicit-any
private async validateSettings(validator: any, settings: any) {
private async validateSettings<Type extends FieldMetadataType>(
validator: ClassConstructor<
Type extends FieldMetadataType.NUMBER
? NumberSettingsValidation
: Type extends FieldMetadataType.TEXT
? TextSettingsValidation
: never
>,
settings: FieldMetadataSettings<T>,
) {
try {
const settingsInstance = plainToInstance(validator, settings);
@ -77,8 +133,7 @@ export class FieldMetadataValidationService<
} catch (error) {
const errorMessages = Array.isArray(error)
? error
// eslint-disable-next-line @typescript-eslint/no-explicit-any
.map((err: any) => Object.values(err.constraints))
.map((err: ValidationError) => Object.values(err.constraints ?? {}))
.flat()
.join(', ')
: error.message;

13
packages/twenty-server/src/engine/metadata-modules/field-metadata/field-metadata.entity.ts
View File

@ -22,7 +22,6 @@ import { FieldMetadataInterface } from 'src/engine/metadata-modules/field-metada
import { FieldStandardOverridesDTO } from 'src/engine/metadata-modules/field-metadata/dtos/field-standard-overrides.dto';
import { IndexFieldMetadataEntity } from 'src/engine/metadata-modules/index-metadata/index-field-metadata.entity';
import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
import { RelationMetadataEntity } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
@Entity('fieldMetadata')
@Unique('IDX_FIELD_METADATA_NAME_OBJECT_METADATA_ID_WORKSPACE_ID_UNIQUE', [
@ -133,18 +132,6 @@ export class FieldMetadataEntity<
@JoinColumn({ name: 'relationTargetObjectMetadataId' })
relationTargetObjectMetadata: Relation<ObjectMetadataEntity>;
@OneToOne(
() => RelationMetadataEntity,
(relation: RelationMetadataEntity) => relation.fromFieldMetadata,
)
fromRelationMetadata: Relation<RelationMetadataEntity>;
@OneToOne(
() => RelationMetadataEntity,
(relation: RelationMetadataEntity) => relation.toFieldMetadata,
)
toRelationMetadata: Relation<RelationMetadataEntity>;
@OneToMany(
() => IndexFieldMetadataEntity,
(indexFieldMetadata: IndexFieldMetadataEntity) =>

5
packages/twenty-server/src/engine/metadata-modules/field-metadata/field-metadata.module.ts
View File

@ -24,7 +24,6 @@ import { IsFieldMetadataOptions } from 'src/engine/metadata-modules/field-metada
import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
import { ObjectMetadataModule } from 'src/engine/metadata-modules/object-metadata/object-metadata.module';
import { PermissionsModule } from 'src/engine/metadata-modules/permissions/permissions.module';
import { RelationMetadataEntity } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
import { WorkspaceMetadataVersionModule } from 'src/engine/metadata-modules/workspace-metadata-version/workspace-metadata-version.module';
import { WorkspaceMigrationModule } from 'src/engine/metadata-modules/workspace-migration/workspace-migration.module';
import { WorkspaceCacheStorageModule } from 'src/engine/workspace-cache-storage/workspace-cache-storage.module';
@ -42,8 +41,8 @@ import { UpdateFieldInput } from './dtos/update-field.input';
NestjsQueryGraphQLModule.forFeature({
imports: [
NestjsQueryTypeOrmModule.forFeature(
[FieldMetadataEntity, ObjectMetadataEntity, RelationMetadataEntity],
'metadata',
[FieldMetadataEntity, ObjectMetadataEntity],
'core',
),
WorkspaceMigrationModule,
WorkspaceMigrationRunnerModule,

39
packages/twenty-server/src/engine/metadata-modules/field-metadata/field-metadata.resolver.ts
View File

@ -23,10 +23,6 @@ import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.guard';
import { CreateOneFieldMetadataInput } from 'src/engine/metadata-modules/field-metadata/dtos/create-field.input';
import { DeleteOneFieldInput } from 'src/engine/metadata-modules/field-metadata/dtos/delete-field.input';
import { FieldMetadataDTO } from 'src/engine/metadata-modules/field-metadata/dtos/field-metadata.dto';
import {
RelationDefinitionDTO,
RelationDefinitionType,
} from 'src/engine/metadata-modules/field-metadata/dtos/relation-definition.dto';
import { RelationDTO } from 'src/engine/metadata-modules/field-metadata/dtos/relation.dto';
import {
UpdateFieldInput,
@ -43,7 +39,6 @@ import { fieldMetadataGraphqlApiExceptionHandler } from 'src/engine/metadata-mod
import { SettingPermissionType } from 'src/engine/metadata-modules/permissions/constants/setting-permission-type.constants';
import { PermissionsGraphqlApiExceptionFilter } from 'src/engine/metadata-modules/permissions/utils/permissions-graphql-api-exception.filter';
import { isRelationFieldMetadataType } from 'src/engine/utils/is-relation-field-metadata-type.util';
import { createDeterministicUuid } from 'src/engine/workspace-manager/workspace-sync-metadata/utils/create-deterministic-uuid.util';
@UseGuards(WorkspaceAuthGuard)
@Resolver(() => FieldMetadataDTO)
@ -165,40 +160,6 @@ export class FieldMetadataResolver {
}
}
@ResolveField(() => RelationDefinitionDTO, { nullable: true })
async relationDefinition(
@AuthWorkspace() workspace: Workspace,
@Parent() fieldMetadata: FieldMetadataDTO,
@Context() context: { loaders: IDataloaders },
): Promise<RelationDefinitionDTO | null | undefined> {
if (fieldMetadata.type !== FieldMetadataType.RELATION) {
return null;
}
const relation = await this.relation(
workspace,
fieldMetadata as FieldMetadataEntity<FieldMetadataType.RELATION>,
context,
);
if (!relation) {
return null;
}
return {
// Temporary fix as we don't have relationId in the new relation
relationId: createDeterministicUuid([
relation.sourceFieldMetadata.id,
relation.targetFieldMetadata.id,
]),
direction: relation.type as unknown as RelationDefinitionType,
sourceObjectMetadata: relation.sourceObjectMetadata,
targetObjectMetadata: relation.targetObjectMetadata,
sourceFieldMetadata: relation.sourceFieldMetadata,
targetFieldMetadata: relation.targetFieldMetadata,
};
}
@ResolveField(() => RelationDTO, { nullable: true })
async relation(
@AuthWorkspace() workspace: Workspace,

289
packages/twenty-server/src/engine/metadata-modules/field-metadata/field-metadata.service.ts
View File

@ -23,10 +23,6 @@ import {
FieldMetadataComplexOption,
FieldMetadataDefaultOption,
} from 'src/engine/metadata-modules/field-metadata/dtos/options.input';
import {
RelationDefinitionDTO,
RelationDefinitionType,
} from 'src/engine/metadata-modules/field-metadata/dtos/relation-definition.dto';
import { UpdateFieldInput } from 'src/engine/metadata-modules/field-metadata/dtos/update-field.input';
import {
FieldMetadataException,
@ -42,17 +38,18 @@ import {
} from 'src/engine/metadata-modules/field-metadata/utils/compute-column-name.util';
import { generateNullable } from 'src/engine/metadata-modules/field-metadata/utils/generate-nullable';
import { isCompositeFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/utils/is-composite-field-metadata-type.util';
import { isEnumFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/utils/is-enum-field-metadata-type.util';
import { isSelectOrMultiSelectFieldMetadata } from 'src/engine/metadata-modules/field-metadata/utils/is-select-or-multi-select-field-metadata.util';
import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
import { assertMutationNotOnRemoteObject } from 'src/engine/metadata-modules/object-metadata/utils/assert-mutation-not-on-remote-object.util';
import {
RelationMetadataEntity,
RelationMetadataType,
} from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
import { RelationOnDeleteAction } from 'src/engine/metadata-modules/relation-metadata/relation-on-delete-action.type';
import { InvalidMetadataException } from 'src/engine/metadata-modules/utils/exceptions/invalid-metadata.exception';
import { validateFieldNameAvailabilityOrThrow } from 'src/engine/metadata-modules/utils/validate-field-name-availability.utils';
import { validateMetadataNameOrThrow } from 'src/engine/metadata-modules/utils/validate-metadata-name.utils';
import { validateNameAndLabelAreSyncOrThrow } from 'src/engine/metadata-modules/utils/validate-name-and-label-are-sync-or-throw.util';
import {
computeMetadataNameFromLabel,
validateNameAndLabelAreSyncOrThrow,
} from 'src/engine/metadata-modules/utils/validate-name-and-label-are-sync-or-throw.util';
import { WorkspaceMetadataVersionService } from 'src/engine/metadata-modules/workspace-metadata-version/services/workspace-metadata-version.service';
import { generateMigrationName } from 'src/engine/metadata-modules/workspace-migration/utils/generate-migration-name.util';
import {
@ -66,9 +63,9 @@ import { WorkspaceMigrationService } from 'src/engine/metadata-modules/workspace
import { WorkspaceEntityManager } from 'src/engine/twenty-orm/entity-manager/workspace-entity-manager';
import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
import { computeObjectTargetTable } from 'src/engine/utils/compute-object-target-table.util';
import { isFieldMetadataEntityOfType } from 'src/engine/utils/is-field-metadata-of-type.util';
import { WorkspaceMigrationRunnerService } from 'src/engine/workspace-manager/workspace-migration-runner/workspace-migration-runner.service';
import { ViewService } from 'src/modules/view/services/view.service';
import { isEnumFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/utils/is-enum-field-metadata-type.util';
import { trimAndRemoveDuplicatedWhitespacesFromObjectStringProperties } from 'src/utils/trim-and-remove-duplicated-whitespaces-from-object-string-properties';
import { FieldMetadataValidationService } from './field-metadata-validation.service';
@ -88,14 +85,12 @@ type ValidateFieldMetadataArgs<T extends UpdateFieldInput | CreateFieldInput> =
@Injectable()
export class FieldMetadataService extends TypeOrmQueryService<FieldMetadataEntity> {
constructor(
@InjectDataSource('metadata')
private readonly metadataDataSource: DataSource,
@InjectRepository(FieldMetadataEntity, 'metadata')
@InjectDataSource('core')
private readonly coreDataSource: DataSource,
@InjectRepository(FieldMetadataEntity, 'core')
private readonly fieldMetadataRepository: Repository<FieldMetadataEntity>,
@InjectRepository(ObjectMetadataEntity, 'metadata')
@InjectRepository(ObjectMetadataEntity, 'core')
private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
@InjectRepository(RelationMetadataEntity, 'metadata')
private readonly relationMetadataRepository: Repository<RelationMetadataEntity>,
private readonly workspaceMigrationFactory: WorkspaceMigrationFactory,
private readonly workspaceMigrationService: WorkspaceMigrationService,
private readonly workspaceMigrationRunnerService: WorkspaceMigrationRunnerService,
@ -128,7 +123,7 @@ export class FieldMetadataService extends TypeOrmQueryService<FieldMetadataEntit
id: string,
fieldMetadataInput: UpdateFieldInput,
): Promise<FieldMetadataEntity> {
const queryRunner = this.metadataDataSource.createQueryRunner();
const queryRunner = this.coreDataSource.createQueryRunner();
await queryRunner.connect();
await queryRunner.startTransaction();
@ -314,7 +309,7 @@ export class FieldMetadataService extends TypeOrmQueryService<FieldMetadataEntit
input: DeleteOneFieldInput,
workspaceId: string,
): Promise<FieldMetadataEntity> {
const queryRunner = this.metadataDataSource.createQueryRunner();
const queryRunner = this.coreDataSource.createQueryRunner();
await queryRunner.connect();
await queryRunner.startTransaction(); // transaction not safe as a different queryRunner is used within workspaceMigrationRunnerService
@ -377,20 +372,6 @@ export class FieldMetadataService extends TypeOrmQueryService<FieldMetadataEntit
);
}
// TODO: remove this once we have deleted the relation metadata table
await this.relationMetadataRepository.delete({
fromFieldMetadataId: In([
fieldMetadata.id,
fieldMetadata.relationTargetFieldMetadata.id,
]),
});
await this.relationMetadataRepository.delete({
toFieldMetadataId: In([
fieldMetadata.id,
fieldMetadata.relationTargetFieldMetadata.id,
]),
});
await fieldMetadataRepository.delete({
id: In([
fieldMetadata.id,
@ -560,61 +541,6 @@ export class FieldMetadataService extends TypeOrmQueryService<FieldMetadataEntit
return updatableStandardFieldInput;
}
public async getRelationDefinitionFromRelationMetadata(
fieldMetadataDTO: FieldMetadataDTO,
relationMetadata: RelationMetadataEntity,
): Promise<RelationDefinitionDTO | null> {
if (fieldMetadataDTO.type !== FieldMetadataType.RELATION) {
return null;
}
const isRelationFromSource =
relationMetadata.fromFieldMetadata.id === fieldMetadataDTO.id;
// TODO: implement MANY_TO_MANY
if (
relationMetadata.relationType === RelationMetadataType.MANY_TO_MANY ||
relationMetadata.relationType === RelationMetadataType.MANY_TO_ONE
) {
throw new FieldMetadataException(
`
Relation type ${relationMetadata.relationType} not supported
`,
FieldMetadataExceptionCode.INVALID_FIELD_INPUT,
);
}
if (isRelationFromSource) {
const direction =
relationMetadata.relationType === RelationMetadataType.ONE_TO_ONE
? RelationDefinitionType.ONE_TO_ONE
: RelationDefinitionType.ONE_TO_MANY;
return {
relationId: relationMetadata.id,
sourceObjectMetadata: relationMetadata.fromObjectMetadata,
sourceFieldMetadata: relationMetadata.fromFieldMetadata,
targetObjectMetadata: relationMetadata.toObjectMetadata,
targetFieldMetadata: relationMetadata.toFieldMetadata,
direction,
};
} else {
const direction =
relationMetadata.relationType === RelationMetadataType.ONE_TO_ONE
? RelationDefinitionType.ONE_TO_ONE
: RelationDefinitionType.MANY_TO_ONE;
return {
relationId: relationMetadata.id,
sourceObjectMetadata: relationMetadata.toObjectMetadata,
sourceFieldMetadata: relationMetadata.toFieldMetadata,
targetObjectMetadata: relationMetadata.fromObjectMetadata,
targetFieldMetadata: relationMetadata.fromFieldMetadata,
direction,
};
}
}
private async validateFieldMetadata<
T extends UpdateFieldInput | CreateFieldInput,
>({
@ -680,6 +606,25 @@ export class FieldMetadataService extends TypeOrmQueryService<FieldMetadataEntit
});
}
// TODO: clean typings, we should try to validate both update and create inputs in the same function
if (
fieldMetadataType === FieldMetadataType.RELATION &&
isDefined(
(fieldMetadataInput as unknown as CreateFieldInput)
.relationCreationPayload,
)
) {
const relationCreationPayload = (
fieldMetadataInput as unknown as CreateFieldInput
).relationCreationPayload;
if (isDefined(relationCreationPayload)) {
await this.fieldMetadataValidationService.validateRelationCreationPayloadOrThrow(
relationCreationPayload,
);
}
}
return fieldMetadataInput;
}
@ -745,20 +690,49 @@ export class FieldMetadataService extends TypeOrmQueryService<FieldMetadataEntit
fieldMetadataInput.defaultValue ??
generateDefaultValue(fieldMetadataInput.type);
const relationCreationPayload = fieldMetadataInput.relationCreationPayload;
return {
id: v4(),
createdAt: new Date(),
updatedAt: new Date(),
...fieldMetadataInput,
name: fieldMetadataInput.name,
label: fieldMetadataInput.label,
icon: fieldMetadataInput.icon,
type: fieldMetadataInput.type,
isLabelSyncedWithName: fieldMetadataInput.isLabelSyncedWithName,
objectMetadataId: fieldMetadataInput.objectMetadataId,
workspaceId: fieldMetadataInput.workspaceId,
isNullable: generateNullable(
fieldMetadataInput.type,
fieldMetadataInput.isNullable,
fieldMetadataInput.isRemoteCreation,
),
relationTargetObjectMetadataId:
relationCreationPayload?.targetObjectMetadataId,
defaultValue,
...options,
isActive: true,
isCustom: true,
settings: {
...fieldMetadataInput.settings,
...(fieldMetadataInput.type === FieldMetadataType.RELATION &&
relationCreationPayload &&
relationCreationPayload.type === RelationType.ONE_TO_MANY
? {
relationType: RelationType.ONE_TO_MANY,
}
: {}),
...(fieldMetadataInput.type === FieldMetadataType.RELATION &&
relationCreationPayload &&
relationCreationPayload.type === RelationType.MANY_TO_ONE
? {
relationType: RelationType.MANY_TO_ONE,
onDelete: RelationOnDeleteAction.SET_NULL,
joinColumnName: `${fieldMetadataInput.name}Id`,
}
: {}),
},
};
}
@ -778,11 +752,11 @@ export class FieldMetadataService extends TypeOrmQueryService<FieldMetadataEntit
);
}
private async validateAndCreateFieldMetadata(
private async validateAndCreateFieldMetadataItems(
fieldMetadataInput: CreateFieldInput,
objectMetadata: ObjectMetadataEntity,
fieldMetadataRepository: Repository<FieldMetadataEntity>,
): Promise<FieldMetadataEntity> {
): Promise<FieldMetadataEntity[]> {
if (!fieldMetadataInput.isRemoteCreation) {
assertMutationNotOnRemoteObject(objectMetadata);
}
@ -796,7 +770,10 @@ export class FieldMetadataService extends TypeOrmQueryService<FieldMetadataEntit
await this.validateFieldMetadata({
fieldMetadataType: fieldMetadataForCreate.type,
fieldMetadataInput: fieldMetadataForCreate,
fieldMetadataInput: {
...fieldMetadataForCreate,
relationCreationPayload: fieldMetadataInput.relationCreationPayload,
},
objectMetadata,
});
@ -807,26 +784,99 @@ export class FieldMetadataService extends TypeOrmQueryService<FieldMetadataEntit
);
}
return await fieldMetadataRepository.save(fieldMetadataForCreate);
}
const createdFieldMetadataItem = await fieldMetadataRepository.save(
fieldMetadataForCreate,
);
private async createMigrationActions(
createdFieldMetadata: FieldMetadataEntity,
objectMetadata: ObjectMetadataEntity,
isRemoteCreation: boolean,
): Promise<WorkspaceMigrationTableAction | null> {
if (isRemoteCreation) {
return null;
if (fieldMetadataForCreate.type !== FieldMetadataType.RELATION) {
return [createdFieldMetadataItem];
}
return {
name: computeObjectTargetTable(objectMetadata),
action: WorkspaceMigrationTableActionType.ALTER,
columns: this.workspaceMigrationFactory.createColumnActions(
WorkspaceMigrationColumnActionType.CREATE,
createdFieldMetadata,
),
};
const relationCreationPayload = fieldMetadataInput.relationCreationPayload;
if (!isDefined(relationCreationPayload)) {
throw new FieldMetadataException(
'Relation creation payload is not defined',
FieldMetadataExceptionCode.FIELD_METADATA_RELATION_MALFORMED,
);
}
const targetFieldMetadataToCreate =
this.prepareCustomFieldMetadataForCreation({
objectMetadataId: relationCreationPayload.targetObjectMetadataId,
type: FieldMetadataType.RELATION,
name: computeMetadataNameFromLabel(
relationCreationPayload.targetFieldLabel,
),
label: relationCreationPayload.targetFieldLabel,
icon: relationCreationPayload.targetFieldIcon,
workspaceId: fieldMetadataForCreate.workspaceId,
relationCreationPayload: {
targetObjectMetadataId: objectMetadata.id,
targetFieldLabel: fieldMetadataInput.label,
targetFieldIcon: fieldMetadataInput.icon ?? 'Icon123',
type:
relationCreationPayload.type === RelationType.ONE_TO_MANY
? RelationType.MANY_TO_ONE
: RelationType.ONE_TO_MANY,
},
});
const targetFieldMetadata = await fieldMetadataRepository.save({
...targetFieldMetadataToCreate,
relationTargetFieldMetadataId: createdFieldMetadataItem.id,
});
const createdFieldMetadataItemUpdated = await fieldMetadataRepository.save({
...createdFieldMetadataItem,
relationTargetFieldMetadataId: targetFieldMetadata.id,
});
return [createdFieldMetadataItemUpdated, targetFieldMetadata];
}
private async createMigrationActions({
createdFieldMetadataItems,
objectMetadataMap,
isRemoteCreation,
}: {
createdFieldMetadataItems: FieldMetadataEntity[];
objectMetadataMap: Record<string, ObjectMetadataEntity>;
isRemoteCreation: boolean;
}): Promise<WorkspaceMigrationTableAction[]> {
if (isRemoteCreation) {
return [];
}
const migrationActions: WorkspaceMigrationTableAction[] = [];
for (const createdFieldMetadata of createdFieldMetadataItems) {
if (
isFieldMetadataEntityOfType(
createdFieldMetadata,
FieldMetadataType.RELATION,
)
) {
const relationType = createdFieldMetadata.settings?.relationType;
if (relationType === RelationType.ONE_TO_MANY) {
continue;
}
}
migrationActions.push({
name: computeObjectTargetTable(
objectMetadataMap[createdFieldMetadata.objectMetadataId],
),
action: WorkspaceMigrationTableActionType.ALTER,
columns: this.workspaceMigrationFactory.createColumnActions(
WorkspaceMigrationColumnActionType.CREATE,
createdFieldMetadata,
),
});
}
return migrationActions;
}
async createMany(
@ -837,7 +887,7 @@ export class FieldMetadataService extends TypeOrmQueryService<FieldMetadataEntit
}
const workspaceId = fieldMetadataInputs[0].workspaceId;
const queryRunner = this.metadataDataSource.createQueryRunner();
const queryRunner = this.coreDataSource.createQueryRunner();
await queryRunner.connect();
await queryRunner.startTransaction();
@ -854,7 +904,6 @@ export class FieldMetadataService extends TypeOrmQueryService<FieldMetadataEntit
const objectMetadatas = await this.objectMetadataRepository.find({
where: {
id: In(objectMetadataIds),
workspaceId,
},
relations: ['fields'],
@ -881,24 +930,22 @@ export class FieldMetadataService extends TypeOrmQueryService<FieldMetadataEntit
const inputs = inputsByObjectId[objectMetadataId];
for (const fieldMetadataInput of inputs) {
const createdFieldMetadata =
await this.validateAndCreateFieldMetadata(
const createdFieldMetadataItems =
await this.validateAndCreateFieldMetadataItems(
fieldMetadataInput,
objectMetadata,
fieldMetadataRepository,
);
createdFieldMetadatas.push(createdFieldMetadata);
createdFieldMetadatas.push(...createdFieldMetadataItems);
const migrationAction = await this.createMigrationActions(
createdFieldMetadata,
objectMetadata,
fieldMetadataInput.isRemoteCreation ?? false,
);
const fieldMigrationActions = await this.createMigrationActions({
createdFieldMetadataItems,
objectMetadataMap,
isRemoteCreation: fieldMetadataInput.isRemoteCreation ?? false,
});
if (isDefined(migrationAction)) {
migrationActions.push(migrationAction);
}
migrationActions.push(...fieldMigrationActions);
}
}

3
packages/twenty-server/src/engine/metadata-modules/field-metadata/interfaces/field-metadata.interface.ts
View File

@ -4,7 +4,6 @@ import { FieldMetadataDefaultValue } from 'src/engine/metadata-modules/field-met
import { FieldMetadataOptions } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata-options.interface';
import { FieldMetadataSettings } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata-settings.interface';
import { ObjectMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/object-metadata.interface';
import { RelationMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-metadata.interface';
export interface FieldMetadataInterface<
T extends FieldMetadataType = FieldMetadataType,
@ -22,8 +21,6 @@ export interface FieldMetadataInterface<
icon?: string;
isNullable?: boolean;
isUnique?: boolean;
fromRelationMetadata?: RelationMetadataInterface;
toRelationMetadata?: RelationMetadataInterface;
relationTargetFieldMetadataId?: string;
relationTargetFieldMetadata?: FieldMetadataInterface;
relationTargetObjectMetadataId?: string;

3
packages/twenty-server/src/engine/metadata-modules/field-metadata/interfaces/object-metadata.interface.ts
View File

@ -3,7 +3,6 @@ import { IndexMetadataInterface } from 'src/engine/metadata-modules/index-metada
import { WorkspaceEntityDuplicateCriteria } from 'src/engine/api/graphql/workspace-query-builder/types/workspace-entity-duplicate-criteria.type';
import { FieldMetadataInterface } from './field-metadata.interface';
import { RelationMetadataInterface } from './relation-metadata.interface';
export interface ObjectMetadataInterface {
id: string;
@ -16,8 +15,6 @@ export interface ObjectMetadataInterface {
description?: string;
icon?: string;
targetTableName: string;
fromRelations: RelationMetadataInterface[];
toRelations: RelationMetadataInterface[];
fields: FieldMetadataInterface[];
indexMetadatas: IndexMetadataInterface[];
isSystem: boolean;

22
packages/twenty-server/src/engine/metadata-modules/field-metadata/interfaces/relation-metadata.interface.ts
View File

@ -1,22 +0,0 @@
import { RelationMetadataType } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
import { ObjectMetadataInterface } from './object-metadata.interface';
import { FieldMetadataInterface } from './field-metadata.interface';
export interface RelationMetadataInterface {
id: string;
relationType: RelationMetadataType;
fromObjectMetadataId: string;
fromObjectMetadata: ObjectMetadataInterface;
toObjectMetadataId: string;
toObjectMetadata: ObjectMetadataInterface;
fromFieldMetadataId: string;
fromFieldMetadata: FieldMetadataInterface;
toFieldMetadataId: string;
toFieldMetadata: FieldMetadataInterface;
}

1
packages/twenty-server/src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface.ts
View File

@ -1,5 +1,4 @@
export enum RelationType {
ONE_TO_ONE = 'ONE_TO_ONE',
ONE_TO_MANY = 'ONE_TO_MANY',
MANY_TO_ONE = 'MANY_TO_ONE',
}

4
packages/twenty-server/src/engine/metadata-modules/field-metadata/validators/is-field-metadata-default-value.validator.ts
View File

@ -6,8 +6,8 @@ import {
ValidatorConstraint,
ValidatorConstraintInterface,
} from 'class-validator';
import { Repository } from 'typeorm';
import { FieldMetadataType } from 'twenty-shared/types';
import { Repository } from 'typeorm';
import { FieldMetadataDefaultValue } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata-default-value.interface';
@ -21,7 +21,7 @@ export class IsFieldMetadataDefaultValue
implements ValidatorConstraintInterface
{
constructor(
@InjectRepository(FieldMetadataEntity, 'metadata')
@InjectRepository(FieldMetadataEntity, 'core')
private readonly fieldMetadataRepository: Repository<FieldMetadataEntity>,
private readonly loggerService: LoggerService,
) {}

4
packages/twenty-server/src/engine/metadata-modules/field-metadata/validators/is-field-metadata-options.validator.ts
View File

@ -2,8 +2,8 @@ import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { ValidationArguments, ValidatorConstraint } from 'class-validator';
import { Repository } from 'typeorm';
import { FieldMetadataType } from 'twenty-shared/types';
import { Repository } from 'typeorm';
import { FieldMetadataOptions } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata-options.interface';
@ -16,7 +16,7 @@ export class IsFieldMetadataOptions {
private validationErrors: string[] = [];
constructor(
@InjectRepository(FieldMetadataEntity, 'metadata')
@InjectRepository(FieldMetadataEntity, 'core')
private readonly fieldMetadataRepository: Repository<FieldMetadataEntity>,
) {}

4
packages/twenty-server/src/engine/metadata-modules/index-metadata/index-metadata.module.ts
View File

@ -15,12 +15,12 @@ import { WorkspaceMigrationModule } from 'src/engine/metadata-modules/workspace-
@Module({
imports: [
TypeOrmModule.forFeature([IndexMetadataEntity], 'metadata'),
TypeOrmModule.forFeature([IndexMetadataEntity], 'core'),
NestjsQueryGraphQLModule.forFeature({
imports: [
NestjsQueryTypeOrmModule.forFeature(
[IndexMetadataEntity, IndexFieldMetadataEntity],
'metadata',
'core',
),
WorkspaceMigrationModule,
],

4
packages/twenty-server/src/engine/metadata-modules/index-metadata/index-metadata.service.ts
View File

@ -2,8 +2,8 @@ import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import isEmpty from 'lodash.isempty';
import { Repository } from 'typeorm';
import { isDefined } from 'twenty-shared/utils';
import { Repository } from 'typeorm';
import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
import {
@ -25,7 +25,7 @@ import { computeObjectTargetTable } from 'src/engine/utils/compute-object-target
@Injectable()
export class IndexMetadataService {
constructor(
@InjectRepository(IndexMetadataEntity, 'metadata')
@InjectRepository(IndexMetadataEntity, 'core')
private readonly indexMetadataRepository: Repository<IndexMetadataEntity>,
private readonly workspaceMigrationService: WorkspaceMigrationService,
) {}

3
packages/twenty-server/src/engine/metadata-modules/metadata-engine.module.ts
View File

@ -4,7 +4,6 @@ import { DataSourceModule } from 'src/engine/metadata-modules/data-source/data-s
import { FieldMetadataModule } from 'src/engine/metadata-modules/field-metadata/field-metadata.module';
import { ObjectMetadataModule } from 'src/engine/metadata-modules/object-metadata/object-metadata.module';
import { PermissionsModule } from 'src/engine/metadata-modules/permissions/permissions.module';
import { RelationMetadataModule } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.module';
import { RemoteServerModule } from 'src/engine/metadata-modules/remote-server/remote-server.module';
import { RoleModule } from 'src/engine/metadata-modules/role/role.module';
import { ServerlessFunctionModule } from 'src/engine/metadata-modules/serverless-function/serverless-function.module';
@ -16,7 +15,6 @@ import { WorkspaceMigrationModule } from 'src/engine/metadata-modules/workspace-
DataSourceModule,
FieldMetadataModule,
ObjectMetadataModule,
RelationMetadataModule,
ServerlessFunctionModule,
WorkspaceMetadataVersionModule,
WorkspaceMigrationModule,
@ -29,7 +27,6 @@ import { WorkspaceMigrationModule } from 'src/engine/metadata-modules/workspace-
DataSourceModule,
FieldMetadataModule,
ObjectMetadataModule,
RelationMetadataModule,
ServerlessFunctionModule,
RemoteServerModule,
RoleModule,

4
packages/twenty-server/src/engine/metadata-modules/object-metadata/hooks/__tests__/before-update-one-object.hook.spec.ts
View File

@ -42,7 +42,7 @@ describe('BeforeUpdateOneObject', () => {
},
},
{
provide: getRepositoryToken(FieldMetadataEntity, 'metadata'),
provide: getRepositoryToken(FieldMetadataEntity, 'core'),
useValue: {
findBy: jest.fn(),
},
@ -57,7 +57,7 @@ describe('BeforeUpdateOneObject', () => {
ObjectMetadataService,
);
fieldMetadataRepository = module.get<Repository<FieldMetadataEntity>>(
getRepositoryToken(FieldMetadataEntity, 'metadata'),
getRepositoryToken(FieldMetadataEntity, 'core'),
);
});

2
packages/twenty-server/src/engine/metadata-modules/object-metadata/hooks/before-update-one-object.hook.ts
View File

@ -32,7 +32,7 @@ export class BeforeUpdateOneObject<T extends UpdateObjectPayload>
constructor(
readonly objectMetadataService: ObjectMetadataService,
// TODO: Should not use the repository here
@InjectRepository(FieldMetadataEntity, 'metadata')
@InjectRepository(FieldMetadataEntity, 'core')
private readonly fieldMetadataRepository: Repository<FieldMetadataEntity>,
) {}

19
packages/twenty-server/src/engine/metadata-modules/object-metadata/object-metadata.entity.ts
View File

@ -18,7 +18,6 @@ import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/
import { IndexMetadataEntity } from 'src/engine/metadata-modules/index-metadata/index-metadata.entity';
import { ObjectStandardOverridesDTO } from 'src/engine/metadata-modules/object-metadata/dtos/object-standard-overrides.dto';
import { ObjectPermissionEntity } from 'src/engine/metadata-modules/object-permission/object-permission.entity';
import { RelationMetadataEntity } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
@Entity('objectMetadata')
@Unique('IDX_OBJECT_METADATA_NAME_SINGULAR_WORKSPACE_ID_UNIQUE', [
@ -109,24 +108,6 @@ export class ObjectMetadataEntity implements ObjectMetadataInterface {
})
indexMetadatas: Relation<IndexMetadataEntity[]>;
@OneToMany(
() => RelationMetadataEntity,
(relation: RelationMetadataEntity) => relation.fromObjectMetadata,
{
cascade: true,
},
)
fromRelations: Relation<RelationMetadataEntity[]>;
@OneToMany(
() => RelationMetadataEntity,
(relation: RelationMetadataEntity) => relation.toObjectMetadata,
{
cascade: true,
},
)
toRelations: Relation<RelationMetadataEntity[]>;
@OneToMany(
() => FieldMetadataEntity,
(field) => field.relationTargetObjectMetadataId,

5
packages/twenty-server/src/engine/metadata-modules/object-metadata/object-metadata.module.ts
View File

@ -24,7 +24,6 @@ import { ObjectMetadataRelatedRecordsService } from 'src/engine/metadata-modules
import { SettingPermissionType } from 'src/engine/metadata-modules/permissions/constants/setting-permission-type.constants';
import { PermissionsModule } from 'src/engine/metadata-modules/permissions/permissions.module';
import { PermissionsGraphqlApiExceptionFilter } from 'src/engine/metadata-modules/permissions/utils/permissions-graphql-api-exception.filter';
import { RelationMetadataEntity } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
import { RemoteTableRelationsModule } from 'src/engine/metadata-modules/remote-server/remote-table/remote-table-relations/remote-table-relations.module';
import { SearchVectorModule } from 'src/engine/metadata-modules/search-vector/search-vector.module';
import { WorkspaceMetadataVersionModule } from 'src/engine/metadata-modules/workspace-metadata-version/workspace-metadata-version.module';
@ -46,8 +45,8 @@ import { UpdateObjectPayload } from './dtos/update-object.input';
imports: [
TypeORMModule,
NestjsQueryTypeOrmModule.forFeature(
[ObjectMetadataEntity, FieldMetadataEntity, RelationMetadataEntity],
'metadata',
[ObjectMetadataEntity, FieldMetadataEntity],
'core',
),
TypeOrmModule.forFeature([FeatureFlag], 'core'),
DataSourceModule,

29
packages/twenty-server/src/engine/metadata-modules/object-metadata/object-metadata.service.ts
View File

@ -50,10 +50,10 @@ import { CreateObjectInput } from './dtos/create-object.input';
@Injectable()
export class ObjectMetadataService extends TypeOrmQueryService<ObjectMetadataEntity> {
constructor(
@InjectRepository(ObjectMetadataEntity, 'metadata')
@InjectRepository(ObjectMetadataEntity, 'core')
private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
@InjectRepository(FieldMetadataEntity, 'metadata')
@InjectRepository(FieldMetadataEntity, 'core')
private readonly fieldMetadataRepository: Repository<FieldMetadataEntity>,
private readonly remoteTableRelationsService: RemoteTableRelationsService,
@ -343,14 +343,6 @@ export class ObjectMetadataService extends TypeOrmQueryService<ObjectMetadataEnt
'fields.object',
'fields.relationTargetFieldMetadata',
'fields.relationTargetFieldMetadata.object',
'fromRelations.fromFieldMetadata',
'fromRelations.toFieldMetadata',
'toRelations.fromFieldMetadata',
'toRelations.toFieldMetadata',
'fromRelations.fromObjectMetadata',
'fromRelations.toObjectMetadata',
'toRelations.fromObjectMetadata',
'toRelations.toObjectMetadata',
],
where: {
id: input.id,
@ -414,11 +406,7 @@ export class ObjectMetadataService extends TypeOrmQueryService<ObjectMetadataEnt
options: FindOneOptions<ObjectMetadataEntity>,
): Promise<ObjectMetadataEntity | null> {
return this.objectMetadataRepository.findOne({
relations: [
'fields',
'fields.fromRelationMetadata',
'fields.toRelationMetadata',
],
relations: ['fields'],
...options,
where: {
...options.where,
@ -435,9 +423,7 @@ export class ObjectMetadataService extends TypeOrmQueryService<ObjectMetadataEnt
relations: [
'fields.object',
'fields',
'fields.fromRelationMetadata',
'fields.toRelationMetadata',
'fields.fromRelationMetadata.toObjectMetadata',
'fields.relationTargetObjectMetadata',
],
...options,
where: {
@ -449,12 +435,7 @@ export class ObjectMetadataService extends TypeOrmQueryService<ObjectMetadataEnt
public async findMany(options?: FindManyOptions<ObjectMetadataEntity>) {
return this.objectMetadataRepository.find({
relations: [
'fields',
'fields.fromRelationMetadata',
'fields.toRelationMetadata',
'fields.fromRelationMetadata.toObjectMetadata',
],
relations: ['fields'],
...options,
where: {
...options?.where,

6
packages/twenty-server/src/engine/metadata-modules/object-metadata/services/object-metadata-field-relation.service.ts
View File

@ -13,7 +13,7 @@ import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/
import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
import { buildDescriptionForRelationFieldMetadataOnFromField } from 'src/engine/metadata-modules/object-metadata/utils/build-description-for-relation-field-on-from-field.util';
import { buildDescriptionForRelationFieldMetadataOnToField } from 'src/engine/metadata-modules/object-metadata/utils/build-description-for-relation-field-on-to-field.util';
import { RelationOnDeleteAction } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
import { RelationOnDeleteAction } from 'src/engine/metadata-modules/relation-metadata/relation-on-delete-action.type';
import {
CUSTOM_OBJECT_STANDARD_FIELD_IDS,
STANDARD_OBJECT_FIELD_IDS,
@ -33,9 +33,9 @@ const DEFAULT_RELATIONS_OBJECTS_STANDARD_IDS = [
@Injectable()
export class ObjectMetadataFieldRelationService {
constructor(
@InjectRepository(ObjectMetadataEntity, 'metadata')
@InjectRepository(ObjectMetadataEntity, 'core')
private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
@InjectRepository(FieldMetadataEntity, 'metadata')
@InjectRepository(FieldMetadataEntity, 'core')
private readonly fieldMetadataRepository: Repository<FieldMetadataEntity>,
) {}

102
packages/twenty-server/src/engine/metadata-modules/object-metadata/services/object-metadata-migration.service.ts
View File

@ -9,8 +9,6 @@ import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfa
import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
import { buildMigrationsForCustomObjectRelations } from 'src/engine/metadata-modules/object-metadata/utils/build-migrations-for-custom-object-relations.util';
import { RelationMetadataEntity } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
import { RelationToDelete } from 'src/engine/metadata-modules/relation-metadata/types/relation-to-delete';
import { fieldMetadataTypeToColumnType } from 'src/engine/metadata-modules/workspace-migration/utils/field-metadata-type-to-column-type.util';
import { generateMigrationName } from 'src/engine/metadata-modules/workspace-migration/utils/generate-migration-name.util';
import {
@ -29,10 +27,8 @@ import { RELATION_MIGRATION_PRIORITY_PREFIX } from 'src/engine/workspace-manager
@Injectable()
export class ObjectMetadataMigrationService {
constructor(
@InjectRepository(FieldMetadataEntity, 'metadata')
@InjectRepository(FieldMetadataEntity, 'core')
private readonly fieldMetadataRepository: Repository<FieldMetadataEntity>,
@InjectRepository(RelationMetadataEntity, 'metadata')
private readonly relationMetadataRepository: Repository<RelationMetadataEntity>,
private readonly workspaceMigrationService: WorkspaceMigrationService,
private readonly workspaceMigrationFactory: WorkspaceMigrationFactory,
) {}
@ -220,99 +216,46 @@ export class ObjectMetadataMigrationService {
objectMetadata: ObjectMetadataEntity,
workspaceId: string,
) {
const relationsMetadataToDelete: RelationToDelete[] = [];
// TODO: Most of this logic should be moved to relation-metadata.service.ts
for (const relation of [
...objectMetadata.fromRelations,
...objectMetadata.toRelations,
]) {
relationsMetadataToDelete.push({
id: relation.id,
fromFieldMetadataId: relation.fromFieldMetadata.id,
toFieldMetadataId: relation.toFieldMetadata.id,
fromFieldMetadataName: relation.fromFieldMetadata.name,
toFieldMetadataName: relation.toFieldMetadata.name,
fromObjectMetadataId: relation.fromObjectMetadata.id,
toObjectMetadataId: relation.toObjectMetadata.id,
fromObjectName: relation.fromObjectMetadata.nameSingular,
toObjectName: relation.toObjectMetadata.nameSingular,
toFieldMetadataIsCustom: relation.toFieldMetadata.isCustom,
toObjectMetadataIsCustom: relation.toObjectMetadata.isCustom,
direction:
relation.fromObjectMetadata.nameSingular ===
objectMetadata.nameSingular
? 'from'
: 'to',
});
}
if (relationsMetadataToDelete.length > 0) {
await this.relationMetadataRepository.delete(
relationsMetadataToDelete.map((relation) => relation.id),
);
}
for (const relationToDelete of relationsMetadataToDelete) {
const foreignKeyFieldsToDelete = await this.fieldMetadataRepository.find({
where: {
name: `${relationToDelete.toFieldMetadataName}Id`,
objectMetadataId: relationToDelete.toObjectMetadataId,
workspaceId,
},
});
const foreignKeyFieldsToDeleteIds = foreignKeyFieldsToDelete.map(
(field) => field.id,
);
await this.fieldMetadataRepository.delete([
...foreignKeyFieldsToDeleteIds,
relationToDelete.fromFieldMetadataId,
relationToDelete.toFieldMetadataId,
]);
}
const manyToOneRelationFieldsToDelete = objectMetadata.fields.filter(
(field) =>
isFieldMetadataInterfaceOfType(field, FieldMetadataType.RELATION) &&
(field as FieldMetadataEntity<FieldMetadataType.RELATION>).settings
?.relationType === RelationType.MANY_TO_ONE,
const relationFields = objectMetadata.fields.filter((field) =>
isFieldMetadataInterfaceOfType(field, FieldMetadataType.RELATION),
) as FieldMetadataEntity<FieldMetadataType.RELATION>[];
const oneToManyRelationFieldsToDelete = objectMetadata.fields.filter(
(field) =>
isFieldMetadataInterfaceOfType(field, FieldMetadataType.RELATION) &&
(field as FieldMetadataEntity<FieldMetadataType.RELATION>).settings
?.relationType === RelationType.ONE_TO_MANY,
);
const relationFieldsToDelete = [
...manyToOneRelationFieldsToDelete,
...(oneToManyRelationFieldsToDelete.map(
(field) => field.relationTargetFieldMetadata,
...relationFields,
...(relationFields.map(
(relation) => relation.relationTargetFieldMetadata,
) as FieldMetadataEntity<FieldMetadataType.RELATION>[]),
];
for (const relationFieldToDelete of relationFieldsToDelete) {
const joinColumnName = relationFieldToDelete.settings?.joinColumnName;
await this.fieldMetadataRepository.delete(
relationFieldsToDelete.map((relation) => relation.id),
);
for (const relationToDelete of relationFieldsToDelete) {
if (
relationToDelete.settings?.relationType === RelationType.ONE_TO_MANY
) {
continue;
}
const joinColumnName = relationToDelete.settings?.joinColumnName;
if (!joinColumnName) {
throw new Error(
`Join column name is not set for relation field ${relationFieldToDelete.name}`,
`Join column name is not set for relation field ${relationToDelete.name}`,
);
}
await this.workspaceMigrationService.createCustomMigration(
generateMigrationName(
`delete-${RELATION_MIGRATION_PRIORITY_PREFIX}-${relationFieldToDelete.name}`,
`delete-${RELATION_MIGRATION_PRIORITY_PREFIX}-${relationToDelete.name}`,
),
workspaceId,
[
{
name: computeTableName(
relationFieldToDelete.object.nameSingular,
relationFieldToDelete.object.isCustom,
relationToDelete.object.nameSingular,
relationToDelete.object.isCustom,
),
action: WorkspaceMigrationTableActionType.ALTER,
columns: [
@ -326,7 +269,6 @@ export class ObjectMetadataMigrationService {
);
}
// DROP TABLE
await this.workspaceMigrationService.createCustomMigration(
generateMigrationName(`delete-${objectMetadata.nameSingular}`),
workspaceId,

2
packages/twenty-server/src/engine/metadata-modules/object-metadata/utils/build-migrations-for-custom-object-relations.util.ts
View File

@ -1,6 +1,6 @@
import { computeColumnName } from 'src/engine/metadata-modules/field-metadata/utils/compute-column-name.util';
import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
import { RelationOnDeleteAction } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
import { RelationOnDeleteAction } from 'src/engine/metadata-modules/relation-metadata/relation-on-delete-action.type';
import {
WorkspaceMigrationColumnActionType,
WorkspaceMigrationColumnCreate,

2
packages/twenty-server/src/engine/metadata-modules/object-permission/object-permission.module.ts
View File

@ -12,7 +12,7 @@ import { WorkspaceCacheStorageModule } from 'src/engine/workspace-cache-storage/
imports: [
TypeOrmModule.forFeature(
[ObjectPermissionEntity, RoleEntity, ObjectMetadataEntity],
'metadata',
'core',
),
WorkspaceCacheStorageModule,
WorkspacePermissionsCacheModule,

10
packages/twenty-server/src/engine/metadata-modules/object-permission/object-permission.service.spec.ts
View File

@ -33,20 +33,20 @@ describe('ObjectPermissionService', () => {
providers: [
ObjectPermissionService,
{
provide: getRepositoryToken(ObjectPermissionEntity, 'metadata'),
provide: getRepositoryToken(ObjectPermissionEntity, 'core'),
useValue: {
upsert: jest.fn(),
find: jest.fn(),
},
},
{
provide: getRepositoryToken(RoleEntity, 'metadata'),
provide: getRepositoryToken(RoleEntity, 'core'),
useValue: {
findOne: jest.fn(),
},
},
{
provide: getRepositoryToken(ObjectMetadataEntity, 'metadata'),
provide: getRepositoryToken(ObjectMetadataEntity, 'core'),
useValue: {
find: jest.fn(),
},
@ -68,9 +68,9 @@ describe('ObjectPermissionService', () => {
service = module.get<ObjectPermissionService>(ObjectPermissionService);
objectPermissionRepository = module.get(
getRepositoryToken(ObjectPermissionEntity, 'metadata'),
getRepositoryToken(ObjectPermissionEntity, 'core'),
);
roleRepository = module.get(getRepositoryToken(RoleEntity, 'metadata'));
roleRepository = module.get(getRepositoryToken(RoleEntity, 'core'));
workspacePermissionsCacheService = module.get(
WorkspacePermissionsCacheService,
);

6
packages/twenty-server/src/engine/metadata-modules/object-permission/object-permission.service.ts
View File

@ -17,11 +17,11 @@ import { WorkspaceCacheStorageService } from 'src/engine/workspace-cache-storage
export class ObjectPermissionService {
constructor(
@InjectRepository(ObjectPermissionEntity, 'metadata')
@InjectRepository(ObjectPermissionEntity, 'core')
private readonly objectPermissionRepository: Repository<ObjectPermissionEntity>,
@InjectRepository(RoleEntity, 'metadata')
@InjectRepository(RoleEntity, 'core')
private readonly roleRepository: Repository<RoleEntity>,
@InjectRepository(ObjectMetadataEntity, 'metadata')
@InjectRepository(ObjectMetadataEntity, 'core')
private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
private readonly workspacePermissionsCacheService: WorkspacePermissionsCacheService,
private readonly workspaceCacheStorageService: WorkspaceCacheStorageService,

2
packages/twenty-server/src/engine/metadata-modules/permissions/permissions.module.ts
View File

@ -11,7 +11,7 @@ import { WorkspacePermissionsCacheModule } from 'src/engine/metadata-modules/wor
@Module({
imports: [
TypeOrmModule.forFeature([RoleEntity, UserWorkspaceRoleEntity], 'metadata'),
TypeOrmModule.forFeature([RoleEntity, UserWorkspaceRoleEntity], 'core'),
FeatureFlagModule,
TypeOrmModule.forFeature([UserWorkspace], 'core'),
UserRoleModule,

80
packages/twenty-server/src/engine/metadata-modules/relation-metadata/dtos/create-relation.input.ts
View File

@ -1,80 +0,0 @@
import { Field, HideField, InputType } from '@nestjs/graphql';
import { BeforeCreateOne } from '@ptc-org/nestjs-query-graphql';
import {
IsEnum,
IsNotEmpty,
IsOptional,
IsString,
IsUUID,
} from 'class-validator';
import { BeforeCreateOneRelation } from 'src/engine/metadata-modules/relation-metadata/hooks/before-create-one-relation.hook';
import { RelationMetadataType } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
@InputType()
@BeforeCreateOne(BeforeCreateOneRelation)
export class CreateRelationInput {
@IsEnum(RelationMetadataType)
@IsNotEmpty()
@Field(() => RelationMetadataType)
relationType: RelationMetadataType;
@IsUUID()
@IsNotEmpty()
@Field()
fromObjectMetadataId: string;
@IsUUID()
@IsNotEmpty()
@Field()
toObjectMetadataId: string;
@IsString()
@IsNotEmpty()
@Field()
fromName: string;
@IsString()
@IsNotEmpty()
@Field()
toName: string;
@IsString()
@IsNotEmpty()
@Field()
fromLabel: string;
@IsString()
@IsNotEmpty()
@Field()
toLabel: string;
@IsString()
@IsOptional()
@Field({ nullable: true })
fromIcon?: string;
@IsString()
@IsOptional()
@Field({ nullable: true })
toIcon?: string;
@IsString()
@IsOptional()
@Field({ nullable: true, deprecationReason: 'Use fromDescription instead' })
description?: string;
@IsString()
@IsOptional()
@Field({ nullable: true })
fromDescription?: string;
@IsString()
@IsOptional()
@Field({ nullable: true })
toDescription?: string;
@HideField()
workspaceId: string;
}

13
packages/twenty-server/src/engine/metadata-modules/relation-metadata/dtos/delete-relation.input.ts
View File

@ -1,13 +0,0 @@
import { InputType } from '@nestjs/graphql';
import { IDField } from '@ptc-org/nestjs-query-graphql';
import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
@InputType()
export class DeleteOneRelationInput {
@IDField(() => UUIDScalarType, {
description: 'The id of the relation to delete.',
})
id!: string;
}

72
packages/twenty-server/src/engine/metadata-modules/relation-metadata/dtos/relation-metadata.dto.ts
View File

@ -1,72 +0,0 @@
import {
Field,
HideField,
ObjectType,
registerEnumType,
} from '@nestjs/graphql';
import {
Authorize,
BeforeDeleteOne,
IDField,
QueryOptions,
Relation,
} from '@ptc-org/nestjs-query-graphql';
import { CreateDateColumn, UpdateDateColumn } from 'typeorm';
import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
import { ObjectMetadataDTO } from 'src/engine/metadata-modules/object-metadata/dtos/object-metadata.dto';
import { BeforeDeleteOneRelation } from 'src/engine/metadata-modules/relation-metadata/hooks/before-delete-one-relation.hook';
import { RelationMetadataType } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
registerEnumType(RelationMetadataType, {
name: 'RelationMetadataType',
description: 'Type of the relation',
});
@ObjectType('RelationMetadata')
@Authorize({
// eslint-disable-next-line @typescript-eslint/no-explicit-any
authorize: (context: any) => ({
workspaceId: { eq: context?.req?.workspace?.id },
}),
})
@QueryOptions({
defaultResultSize: 10,
disableFilter: true,
disableSort: true,
maxResultsSize: 1000,
})
@BeforeDeleteOne(BeforeDeleteOneRelation)
@Relation('fromObjectMetadata', () => ObjectMetadataDTO)
@Relation('toObjectMetadata', () => ObjectMetadataDTO)
export class RelationMetadataDTO {
@IDField(() => UUIDScalarType)
id: string;
@Field(() => RelationMetadataType)
relationType: RelationMetadataType;
@Field()
fromObjectMetadataId: string;
@Field()
toObjectMetadataId: string;
@Field()
fromFieldMetadataId: string;
@Field()
toFieldMetadataId: string;
@HideField()
workspaceId: string;
@Field()
@CreateDateColumn()
createdAt: Date;
@Field()
@UpdateDateColumn()
updatedAt: Date;
}

29
packages/twenty-server/src/engine/metadata-modules/relation-metadata/hooks/before-create-one-relation.hook.ts
View File

@ -1,29 +0,0 @@
import { Injectable, UnauthorizedException } from '@nestjs/common';
import {
BeforeCreateOneHook,
CreateOneInputType,
} from '@ptc-org/nestjs-query-graphql';
import { CreateRelationInput } from 'src/engine/metadata-modules/relation-metadata/dtos/create-relation.input';
@Injectable()
export class BeforeCreateOneRelation<T extends CreateRelationInput>
implements BeforeCreateOneHook<T>
{
async run(
instance: CreateOneInputType<T>,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
context: any,
): Promise<CreateOneInputType<T>> {
const workspaceId = context?.req?.workspace?.id;
if (!workspaceId) {
throw new UnauthorizedException();
}
instance.input.workspaceId = workspaceId;
return instance;
}
}

62
packages/twenty-server/src/engine/metadata-modules/relation-metadata/hooks/before-delete-one-relation.hook.ts
View File

@ -1,62 +0,0 @@
import {
BadRequestException,
Injectable,
UnauthorizedException,
} from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import {
BeforeDeleteOneHook,
DeleteOneInputType,
} from '@ptc-org/nestjs-query-graphql';
import { Repository } from 'typeorm';
import { RelationMetadataEntity } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.entity';
@Injectable()
export class BeforeDeleteOneRelation implements BeforeDeleteOneHook {
constructor(
@InjectRepository(RelationMetadataEntity, 'metadata')
private readonly relationMetadataRepository: Repository<RelationMetadataEntity>,
) {}
async run(
instance: DeleteOneInputType,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
context: any,
): Promise<DeleteOneInputType> {
const workspaceId = context?.req?.workspace?.id;
if (!workspaceId) {
throw new UnauthorizedException();
}
const relationMetadata = await this.relationMetadataRepository.findOne({
where: {
workspaceId,
id: instance.id.toString(),
},
relations: ['fromFieldMetadata', 'toFieldMetadata'],
});
if (!relationMetadata) {
throw new BadRequestException('Relation does not exist');
}
if (
!relationMetadata.toFieldMetadata.isCustom ||
!relationMetadata.fromFieldMetadata.isCustom
) {
throw new BadRequestException("Standard Relations can't be deleted");
}
if (
relationMetadata.toFieldMetadata.isActive ||
relationMetadata.fromFieldMetadata.isActive
) {
throw new BadRequestException("Active relations can't be deleted");
}
return instance;
}
}

18
packages/twenty-server/src/engine/metadata-modules/relation-metadata/interceptors/relation-metadata-graphql-api-exception.interceptor.ts
View File

@ -1,18 +0,0 @@
import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
import { Observable, catchError } from 'rxjs';
import { relationMetadataGraphqlApiExceptionHandler } from 'src/engine/metadata-modules/relation-metadata/utils/relation-metadata-graphql-api-exception-handler.util';
export class RelationMetadataGraphqlApiExceptionInterceptor
implements NestInterceptor
{
// eslint-disable-next-line @typescript-eslint/no-explicit-any
intercept(_: ExecutionContext, next: CallHandler): Observable<any> {
return next
.handle()
.pipe(
catchError((err) => relationMetadataGraphqlApiExceptionHandler(err)),
);
}
}

100
packages/twenty-server/src/engine/metadata-modules/relation-metadata/relation-metadata.entity.ts
View File

@ -1,100 +0,0 @@
import {
Column,
CreateDateColumn,
Entity,
JoinColumn,
ManyToOne,
OneToOne,
PrimaryGeneratedColumn,
Relation,
UpdateDateColumn,
} from 'typeorm';
import { RelationMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-metadata.interface';
import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
export enum RelationMetadataType {
ONE_TO_ONE = 'ONE_TO_ONE',
ONE_TO_MANY = 'ONE_TO_MANY',
MANY_TO_ONE = 'MANY_TO_ONE',
MANY_TO_MANY = 'MANY_TO_MANY',
}
export enum RelationOnDeleteAction {
CASCADE = 'CASCADE',
RESTRICT = 'RESTRICT',
SET_NULL = 'SET_NULL',
NO_ACTION = 'NO_ACTION',
}
@Entity('relationMetadata')
export class RelationMetadataEntity implements RelationMetadataInterface {
@PrimaryGeneratedColumn('uuid')
id: string;
@Column({ nullable: false })
relationType: RelationMetadataType;
@Column({
nullable: false,
default: RelationOnDeleteAction.SET_NULL,
type: 'enum',
enum: RelationOnDeleteAction,
})
onDeleteAction: RelationOnDeleteAction;
@Column({ nullable: false, type: 'uuid' })
fromObjectMetadataId: string;
@Column({ nullable: false, type: 'uuid' })
toObjectMetadataId: string;
@Column({ nullable: false, type: 'uuid' })
fromFieldMetadataId: string;
@Column({ nullable: false, type: 'uuid' })
toFieldMetadataId: string;
@Column({ nullable: false, type: 'uuid' })
workspaceId: string;
@ManyToOne(
() => ObjectMetadataEntity,
(object: ObjectMetadataEntity) => object.fromRelations,
{
onDelete: 'CASCADE',
},
)
fromObjectMetadata: Relation<ObjectMetadataEntity>;
@ManyToOne(
() => ObjectMetadataEntity,
(object: ObjectMetadataEntity) => object.toRelations,
{
onDelete: 'CASCADE',
},
)
toObjectMetadata: Relation<ObjectMetadataEntity>;
@OneToOne(
() => FieldMetadataEntity,
(field: FieldMetadataEntity) => field.fromRelationMetadata,
)
@JoinColumn()
fromFieldMetadata: Relation<FieldMetadataEntity>;
@OneToOne(
() => FieldMetadataEntity,
(field: FieldMetadataEntity) => field.toRelationMetadata,
)
@JoinColumn()
toFieldMetadata: Relation<FieldMetadataEntity>;
@CreateDateColumn({ type: 'timestamptz' })
createdAt: Date;
@UpdateDateColumn({ type: 'timestamptz' })
updatedAt: Date;
}

15
packages/twenty-server/src/engine/metadata-modules/relation-metadata/relation-metadata.exception.ts
View File

@ -1,15 +0,0 @@
import { CustomException } from 'src/utils/custom-exception';
export class RelationMetadataException extends CustomException {
declare code: RelationMetadataExceptionCode;
constructor(message: string, code: RelationMetadataExceptionCode) {
super(message, code);
}
}
export enum RelationMetadataExceptionCode {
RELATION_METADATA_NOT_FOUND = 'RELATION_METADATA_NOT_FOUND',
INVALID_RELATION_INPUT = 'INVALID_RELATION_INPUT',
RELATION_ALREADY_EXISTS = 'RELATION_ALREADY_EXISTS',
FOREIGN_KEY_NOT_FOUND = 'FOREIGN_KEY_NOT_FOUND',
}

76
packages/twenty-server/src/engine/metadata-modules/relation-metadata/relation-metadata.module.ts
View File

@ -1,76 +0,0 @@
import { Module } from '@nestjs/common';
import {
NestjsQueryGraphQLModule,
PagingStrategies,
} from '@ptc-org/nestjs-query-graphql';
import { NestjsQueryTypeOrmModule } from '@ptc-org/nestjs-query-typeorm';
import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-flag.module';
import { SettingsPermissionsGuard } from 'src/engine/guards/settings-permissions.guard';
import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.guard';
import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
import { FieldMetadataModule } from 'src/engine/metadata-modules/field-metadata/field-metadata.module';
import { IndexMetadataModule } from 'src/engine/metadata-modules/index-metadata/index-metadata.module';
import { ObjectMetadataModule } from 'src/engine/metadata-modules/object-metadata/object-metadata.module';
import { SettingPermissionType } from 'src/engine/metadata-modules/permissions/constants/setting-permission-type.constants';
import { PermissionsModule } from 'src/engine/metadata-modules/permissions/permissions.module';
import { PermissionsGraphqlApiExceptionFilter } from 'src/engine/metadata-modules/permissions/utils/permissions-graphql-api-exception.filter';
import { RelationMetadataGraphqlApiExceptionInterceptor } from 'src/engine/metadata-modules/relation-metadata/interceptors/relation-metadata-graphql-api-exception.interceptor';
import { RelationMetadataResolver } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.resolver';
import { WorkspaceMetadataVersionModule } from 'src/engine/metadata-modules/workspace-metadata-version/workspace-metadata-version.module';
import { WorkspaceMigrationModule } from 'src/engine/metadata-modules/workspace-migration/workspace-migration.module';
import { WorkspaceCacheStorageModule } from 'src/engine/workspace-cache-storage/workspace-cache-storage.module';
import { WorkspaceMigrationRunnerModule } from 'src/engine/workspace-manager/workspace-migration-runner/workspace-migration-runner.module';
import { RelationMetadataEntity } from './relation-metadata.entity';
import { RelationMetadataService } from './relation-metadata.service';
import { CreateRelationInput } from './dtos/create-relation.input';
import { RelationMetadataDTO } from './dtos/relation-metadata.dto';
@Module({
imports: [
NestjsQueryGraphQLModule.forFeature({
imports: [
NestjsQueryTypeOrmModule.forFeature(
[RelationMetadataEntity, FieldMetadataEntity],
'metadata',
),
ObjectMetadataModule,
FieldMetadataModule,
IndexMetadataModule,
WorkspaceMigrationRunnerModule,
WorkspaceMigrationModule,
WorkspaceCacheStorageModule,
WorkspaceMetadataVersionModule,
FeatureFlagModule,
PermissionsModule,
],
services: [RelationMetadataService],
resolvers: [
{
EntityClass: RelationMetadataEntity,
DTOClass: RelationMetadataDTO,
ServiceClass: RelationMetadataService,
CreateDTOClass: CreateRelationInput,
pagingStrategy: PagingStrategies.CURSOR,
create: {
many: { disabled: true },
guards: [
SettingsPermissionsGuard(SettingPermissionType.DATA_MODEL),
],
},
update: { disabled: true },
delete: { disabled: true },
guards: [WorkspaceAuthGuard],
interceptors: [RelationMetadataGraphqlApiExceptionInterceptor],
filters: [PermissionsGraphqlApiExceptionFilter],
},
],
}),
],
providers: [RelationMetadataService, RelationMetadataResolver],
exports: [RelationMetadataService],
})
export class RelationMetadataModule {}

38
packages/twenty-server/src/engine/metadata-modules/relation-metadata/relation-metadata.resolver.ts
View File

@ -1,38 +0,0 @@
import { UseFilters, UseGuards } from '@nestjs/common';
import { Args, Mutation, Resolver } from '@nestjs/graphql';
import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
import { SettingsPermissionsGuard } from 'src/engine/guards/settings-permissions.guard';
import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.guard';
import { SettingPermissionType } from 'src/engine/metadata-modules/permissions/constants/setting-permission-type.constants';
import { PermissionsGraphqlApiExceptionFilter } from 'src/engine/metadata-modules/permissions/utils/permissions-graphql-api-exception.filter';
import { DeleteOneRelationInput } from 'src/engine/metadata-modules/relation-metadata/dtos/delete-relation.input';
import { RelationMetadataDTO } from 'src/engine/metadata-modules/relation-metadata/dtos/relation-metadata.dto';
import { RelationMetadataService } from 'src/engine/metadata-modules/relation-metadata/relation-metadata.service';
import { relationMetadataGraphqlApiExceptionHandler } from 'src/engine/metadata-modules/relation-metadata/utils/relation-metadata-graphql-api-exception-handler.util';
@UseGuards(WorkspaceAuthGuard)
@Resolver()
@UseFilters(PermissionsGraphqlApiExceptionFilter)
export class RelationMetadataResolver {
constructor(
private readonly relationMetadataService: RelationMetadataService,
) {}
@UseGuards(SettingsPermissionsGuard(SettingPermissionType.DATA_MODEL))
@Mutation(() => RelationMetadataDTO)
async deleteOneRelation(
@Args('input') input: DeleteOneRelationInput,
@AuthWorkspace() { id: workspaceId }: Workspace,
) {
try {
return await this.relationMetadataService.deleteOneRelation(
input.id,
workspaceId,
);
} catch (error) {
relationMetadataGraphqlApiExceptionHandler(error);
}
}
}

586
packages/twenty-server/src/engine/metadata-modules/relation-metadata/relation-metadata.service.ts
View File

@ -1,586 +0,0 @@
import { Injectable, NotFoundException } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { TypeOrmQueryService } from '@ptc-org/nestjs-query-typeorm';
import camelCase from 'lodash.camelcase';
import { FieldMetadataType } from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
import { FindOneOptions, In, Repository } from 'typeorm';
import { v4 as uuidV4 } from 'uuid';
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 { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
import { FieldMetadataService } from 'src/engine/metadata-modules/field-metadata/field-metadata.service';
import { IndexMetadataService } from 'src/engine/metadata-modules/index-metadata/index-metadata.service';
import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
import { ObjectMetadataService } from 'src/engine/metadata-modules/object-metadata/object-metadata.service';
import { CreateRelationInput } from 'src/engine/metadata-modules/relation-metadata/dtos/create-relation.input';
import {
RelationMetadataException,
RelationMetadataExceptionCode,
} from 'src/engine/metadata-modules/relation-metadata/relation-metadata.exception';
import { InvalidMetadataException } from 'src/engine/metadata-modules/utils/exceptions/invalid-metadata.exception';
import { validateFieldNameAvailabilityOrThrow } from 'src/engine/metadata-modules/utils/validate-field-name-availability.utils';
import { validateMetadataNameOrThrow } from 'src/engine/metadata-modules/utils/validate-metadata-name.utils';
import { WorkspaceMetadataVersionService } from 'src/engine/metadata-modules/workspace-metadata-version/services/workspace-metadata-version.service';
import { generateMigrationName } from 'src/engine/metadata-modules/workspace-migration/utils/generate-migration-name.util';
import {
WorkspaceMigrationColumnActionType,
WorkspaceMigrationColumnDrop,
WorkspaceMigrationTableActionType,
} from 'src/engine/metadata-modules/workspace-migration/workspace-migration.entity';
import { WorkspaceMigrationService } from 'src/engine/metadata-modules/workspace-migration/workspace-migration.service';
import { computeObjectTargetTable } from 'src/engine/utils/compute-object-target-table.util';
import { WorkspaceCacheStorageService } from 'src/engine/workspace-cache-storage/workspace-cache-storage.service';
import { WorkspaceMigrationRunnerService } from 'src/engine/workspace-manager/workspace-migration-runner/workspace-migration-runner.service';
import { BASE_OBJECT_STANDARD_FIELD_IDS } from 'src/engine/workspace-manager/workspace-sync-metadata/constants/standard-field-ids';
import {
RelationMetadataEntity,
RelationMetadataType,
RelationOnDeleteAction,
} from './relation-metadata.entity';
@Injectable()
export class RelationMetadataService extends TypeOrmQueryService<RelationMetadataEntity> {
constructor(
@InjectRepository(RelationMetadataEntity, 'metadata')
private readonly relationMetadataRepository: Repository<RelationMetadataEntity>,
@InjectRepository(FieldMetadataEntity, 'metadata')
private readonly fieldMetadataRepository: Repository<FieldMetadataEntity>,
private readonly objectMetadataService: ObjectMetadataService,
private readonly fieldMetadataService: FieldMetadataService,
private readonly workspaceMigrationService: WorkspaceMigrationService,
private readonly workspaceMigrationRunnerService: WorkspaceMigrationRunnerService,
private readonly workspaceMetadataVersionService: WorkspaceMetadataVersionService,
private readonly indexMetadataService: IndexMetadataService,
private readonly workspaceCacheStorageService: WorkspaceCacheStorageService,
) {
super(relationMetadataRepository);
}
override async createOne(
relationMetadataInput: CreateRelationInput,
): Promise<RelationMetadataEntity> {
const objectMetadataMap = await this.getObjectMetadataMap(
relationMetadataInput,
);
try {
validateMetadataNameOrThrow(relationMetadataInput.fromName);
validateMetadataNameOrThrow(relationMetadataInput.toName);
} catch (error) {
if (error instanceof InvalidMetadataException)
throw new RelationMetadataException(
error.message,
RelationMetadataExceptionCode.INVALID_RELATION_INPUT,
);
throw error;
}
await this.validateCreateRelationMetadataInput(
relationMetadataInput,
objectMetadataMap,
);
// NOTE: this logic is called to create relation through metadata graphql endpoint (so only for custom field relations)
const isCustom = true;
const columnName = `${camelCase(relationMetadataInput.toName)}Id`;
const fromId = uuidV4();
const toId = uuidV4();
const createdRelationFieldsMetadata =
await this.fieldMetadataRepository.save(
[
this.createFieldMetadataForRelationMetadata(
relationMetadataInput,
'from',
isCustom,
fromId,
),
this.createFieldMetadataForRelationMetadata(
relationMetadataInput,
'to',
isCustom,
toId,
),
].flat(),
);
const createdRelationMetadata = await super.createOne({
...relationMetadataInput,
fromFieldMetadataId: fromId,
toFieldMetadataId: toId,
});
const fromFieldMetadata = createdRelationFieldsMetadata.find(
(fieldMetadata) => fieldMetadata.id === fromId,
);
if (!fromFieldMetadata) {
throw new RelationMetadataException(
`From field metadata not found`,
RelationMetadataExceptionCode.RELATION_METADATA_NOT_FOUND,
);
}
const toFieldMetadata = createdRelationFieldsMetadata.find(
(fieldMetadata) => fieldMetadata.id === toId,
);
if (!toFieldMetadata) {
throw new RelationMetadataException(
`To field metadata not found`,
RelationMetadataExceptionCode.RELATION_METADATA_NOT_FOUND,
);
}
await this.fieldMetadataRepository.update(fromId, {
settings: {
relationType: RelationType.ONE_TO_MANY,
} as Partial<FieldMetadataDefaultSettings>,
relationTargetFieldMetadataId: toId,
relationTargetObjectMetadataId: relationMetadataInput.toObjectMetadataId,
});
await this.fieldMetadataRepository.update(toId, {
settings: {
relationType: RelationType.MANY_TO_ONE,
joinColumnName: `${relationMetadataInput.toName}Id`,
} as Partial<FieldMetadataDefaultSettings>,
relationTargetFieldMetadataId: fromId,
relationTargetObjectMetadataId:
relationMetadataInput.fromObjectMetadataId,
});
await this.createWorkspaceCustomMigration(
relationMetadataInput,
objectMetadataMap,
columnName,
);
const toObjectMetadata =
objectMetadataMap[relationMetadataInput.toObjectMetadataId];
const deletedAtFieldMetadata = toObjectMetadata.fields.find(
(fieldMetadata) =>
fieldMetadata.standardId === BASE_OBJECT_STANDARD_FIELD_IDS.deletedAt,
);
this.throwIfDeletedAtFieldMetadataNotFound(deletedAtFieldMetadata);
await this.workspaceMigrationRunnerService.executeMigrationFromPendingMigrations(
relationMetadataInput.workspaceId,
);
await this.workspaceMetadataVersionService.incrementMetadataVersion(
relationMetadataInput.workspaceId,
);
return createdRelationMetadata;
}
private async validateCreateRelationMetadataInput(
relationMetadataInput: CreateRelationInput,
objectMetadataMap: { [key: string]: ObjectMetadataEntity },
) {
if (
relationMetadataInput.relationType === RelationMetadataType.MANY_TO_MANY
) {
throw new RelationMetadataException(
'Many to many relations are not supported yet',
RelationMetadataExceptionCode.INVALID_RELATION_INPUT,
);
}
if (
objectMetadataMap[relationMetadataInput.fromObjectMetadataId] ===
undefined ||
objectMetadataMap[relationMetadataInput.toObjectMetadataId] === undefined
) {
throw new RelationMetadataException(
"Can't find an existing object matching with fromObjectMetadataId or toObjectMetadataId",
RelationMetadataExceptionCode.RELATION_METADATA_NOT_FOUND,
);
}
await this.checkIfFieldMetadataRelationNameExists(
relationMetadataInput,
objectMetadataMap,
'from',
);
await this.checkIfFieldMetadataRelationNameExists(
relationMetadataInput,
objectMetadataMap,
'to',
);
validateFieldNameAvailabilityOrThrow(
relationMetadataInput.fromName,
objectMetadataMap[relationMetadataInput.fromObjectMetadataId],
);
validateFieldNameAvailabilityOrThrow(
relationMetadataInput.toName,
objectMetadataMap[relationMetadataInput.toObjectMetadataId],
);
}
private async checkIfFieldMetadataRelationNameExists(
relationMetadataInput: CreateRelationInput,
objectMetadataMap: { [key: string]: ObjectMetadataEntity },
relationDirection: 'from' | 'to',
) {
const fieldAlreadyExists =
await this.fieldMetadataService.findOneWithinWorkspace(
relationMetadataInput.workspaceId,
{
where: {
name: relationMetadataInput[`${relationDirection}Name`],
objectMetadataId:
relationMetadataInput[`${relationDirection}ObjectMetadataId`],
},
},
);
if (fieldAlreadyExists) {
throw new RelationMetadataException(
`Field on ${
objectMetadataMap[
relationMetadataInput[`${relationDirection}ObjectMetadataId`]
].nameSingular
} already exists`,
RelationMetadataExceptionCode.RELATION_ALREADY_EXISTS,
);
}
}
private async createWorkspaceCustomMigration(
relationMetadataInput: CreateRelationInput,
objectMetadataMap: { [key: string]: ObjectMetadataEntity },
columnName: string,
) {
await this.workspaceMigrationService.createCustomMigration(
generateMigrationName(`create-${relationMetadataInput.fromName}`),
relationMetadataInput.workspaceId,
[
// Create the column
{
name: computeObjectTargetTable(
objectMetadataMap[relationMetadataInput.toObjectMetadataId],
),
action: WorkspaceMigrationTableActionType.ALTER,
columns: [
{
action: WorkspaceMigrationColumnActionType.CREATE,
columnName,
columnType: 'uuid',
isNullable: true,
defaultValue: null,
},
],
},
// Create the foreignKey
{
name: computeObjectTargetTable(
objectMetadataMap[relationMetadataInput.toObjectMetadataId],
),
action: WorkspaceMigrationTableActionType.ALTER,
columns: [
{
action: WorkspaceMigrationColumnActionType.CREATE_FOREIGN_KEY,
columnName,
referencedTableName: computeObjectTargetTable(
objectMetadataMap[relationMetadataInput.fromObjectMetadataId],
),
referencedTableColumnName: 'id',
isUnique:
relationMetadataInput.relationType ===
RelationMetadataType.ONE_TO_ONE,
onDelete: RelationOnDeleteAction.SET_NULL,
},
],
},
],
);
}
private createFieldMetadataForRelationMetadata(
relationMetadataInput: CreateRelationInput,
relationDirection: 'from' | 'to',
isCustom: boolean,
id?: string,
) {
return {
...(id && { id: id }),
name: relationMetadataInput[`${relationDirection}Name`],
label: relationMetadataInput[`${relationDirection}Label`],
description: relationMetadataInput[`${relationDirection}Description`],
icon: relationMetadataInput[`${relationDirection}Icon`],
isCustom,
isActive: true,
isNullable: true,
type: FieldMetadataType.RELATION,
objectMetadataId:
relationMetadataInput[`${relationDirection}ObjectMetadataId`],
workspaceId: relationMetadataInput.workspaceId,
};
}
private createForeignKeyFieldMetadata(
relationMetadataInput: CreateRelationInput,
columnName: string,
) {
return {
name: columnName,
label: `${relationMetadataInput.toLabel} Foreign Key`,
description: relationMetadataInput.toDescription
? `${relationMetadataInput.toDescription} Foreign Key`
: undefined,
icon: undefined,
isCustom: true,
isActive: true,
isNullable: true,
isSystem: true,
type: FieldMetadataType.UUID,
objectMetadataId: relationMetadataInput.toObjectMetadataId,
workspaceId: relationMetadataInput.workspaceId,
settings: { isForeignKey: true },
};
}
private async getObjectMetadataMap(
relationMetadataInput: CreateRelationInput,
): Promise<{ [key: string]: ObjectMetadataEntity }> {
const objectMetadataEntries =
await this.objectMetadataService.findManyWithinWorkspace(
relationMetadataInput.workspaceId,
{
where: {
id: In([
relationMetadataInput.fromObjectMetadataId,
relationMetadataInput.toObjectMetadataId,
]),
},
},
);
return objectMetadataEntries.reduce(
(acc, curr) => {
acc[curr.id] = curr;
return acc;
},
{} as { [key: string]: ObjectMetadataEntity },
);
}
public async findOneWithinWorkspace(
workspaceId: string,
options: FindOneOptions<RelationMetadataEntity>,
) {
return this.relationMetadataRepository.findOne({
...options,
where: {
...options.where,
workspaceId,
},
relations: ['fromFieldMetadata', 'toFieldMetadata'],
});
}
public async deleteOneRelation(
id: string,
workspaceId: string,
): Promise<RelationMetadataEntity> {
// TODO: This logic is duplicated with the BeforeDeleteOneRelation hook
const relationMetadata = await this.relationMetadataRepository.findOne({
where: { id },
relations: [
'fromFieldMetadata',
'toFieldMetadata',
'fromObjectMetadata',
'toObjectMetadata',
],
});
if (!relationMetadata) {
throw new RelationMetadataException(
'Relation does not exist',
RelationMetadataExceptionCode.RELATION_METADATA_NOT_FOUND,
);
}
const foreignKeyFieldMetadataName = `${camelCase(
relationMetadata.toFieldMetadata.name,
)}Id`;
const foreignKeyFieldMetadata = await this.fieldMetadataRepository.findOne({
where: {
name: foreignKeyFieldMetadataName,
objectMetadataId: relationMetadata.toObjectMetadataId,
workspaceId: relationMetadata.workspaceId,
},
});
if (!foreignKeyFieldMetadata) {
throw new RelationMetadataException(
`Foreign key fieldMetadata not found (${foreignKeyFieldMetadataName}) for relation ${relationMetadata.id}`,
RelationMetadataExceptionCode.FOREIGN_KEY_NOT_FOUND,
);
}
await super.deleteOne(id);
// TODO: Move to a cdc scheduler
await this.fieldMetadataService.deleteMany({
id: {
in: [
relationMetadata.fromFieldMetadataId,
relationMetadata.toFieldMetadataId,
foreignKeyFieldMetadata.id,
],
},
});
const columnName = `${camelCase(relationMetadata.toFieldMetadata.name)}Id`;
const objectTargetTable = computeObjectTargetTable(
relationMetadata.toObjectMetadata,
);
await this.deleteRelationWorkspaceCustomMigration(
relationMetadata,
objectTargetTable,
columnName,
);
const deletedAtFieldMetadata = await this.fieldMetadataRepository.findOneBy(
{
objectMetadataId: relationMetadata.toObjectMetadataId,
name: 'deletedAt',
},
);
this.throwIfDeletedAtFieldMetadataNotFound(deletedAtFieldMetadata);
await this.indexMetadataService.deleteIndexMetadata(
workspaceId,
relationMetadata.toObjectMetadata,
[
foreignKeyFieldMetadata,
deletedAtFieldMetadata as FieldMetadataEntity<FieldMetadataType>,
],
);
await this.workspaceMigrationRunnerService.executeMigrationFromPendingMigrations(
relationMetadata.workspaceId,
);
await this.workspaceMetadataVersionService.incrementMetadataVersion(
workspaceId,
);
// TODO: Return id for delete endpoints
return relationMetadata;
}
async findManyRelationMetadataByFieldMetadataIds(
fieldMetadataItems: Array<
Pick<FieldMetadataInterface, 'id' | 'type' | 'objectMetadataId'>
>,
workspaceId: string,
): Promise<(RelationMetadataEntity | NotFoundException)[]> {
const objectMetadataMaps =
await this.workspaceCacheStorageService.getObjectMetadataMapsOrThrow(
workspaceId,
);
const mappedResult = fieldMetadataItems.map((fieldMetadataItem) => {
const objectMetadata =
objectMetadataMaps.byId[fieldMetadataItem.objectMetadataId];
if (!objectMetadata) {
return new NotFoundException(
`Object metadata not found for field ${fieldMetadataItem.id}`,
);
}
const fieldMetadata = objectMetadata.fieldsById[fieldMetadataItem.id];
const relationMetadata =
fieldMetadata.fromRelationMetadata ?? fieldMetadata.toRelationMetadata;
if (!relationMetadata) {
return new NotFoundException(
`From object metadata not found for relation ${fieldMetadata?.id}`,
);
}
const fromObjectMetadata =
objectMetadataMaps.byId[relationMetadata.fromObjectMetadataId];
const toObjectMetadata =
objectMetadataMaps.byId[relationMetadata.toObjectMetadataId];
const fromFieldMetadata =
objectMetadataMaps.byId[fromObjectMetadata.id].fieldsById[
relationMetadata.fromFieldMetadataId
];
const toFieldMetadata =
objectMetadataMaps.byId[toObjectMetadata.id].fieldsById[
relationMetadata.toFieldMetadataId
];
return {
...relationMetadata,
fromObjectMetadata,
toObjectMetadata,
fromFieldMetadata,
toFieldMetadata,
};
});
return mappedResult as (RelationMetadataEntity | NotFoundException)[];
}
private async deleteRelationWorkspaceCustomMigration(
relationMetadata: RelationMetadataEntity,
objectTargetTable: string,
columnName: string,
) {
await this.workspaceMigrationService.createCustomMigration(
generateMigrationName(
`delete-relation-from-${relationMetadata.fromObjectMetadata.nameSingular}-to-${relationMetadata.toObjectMetadata.nameSingular}`,
),
relationMetadata.workspaceId,
[
// Delete the column
{
name: objectTargetTable,
action: WorkspaceMigrationTableActionType.ALTER,
columns: [
{
action: WorkspaceMigrationColumnActionType.DROP,
columnName,
} satisfies WorkspaceMigrationColumnDrop,
],
},
],
);
}
private throwIfDeletedAtFieldMetadataNotFound(
deletedAtFieldMetadata?: FieldMetadataEntity<FieldMetadataType> | null,
) {
if (!isDefined(deletedAtFieldMetadata)) {
throw new RelationMetadataException(
`Deleted field metadata not found`,
RelationMetadataExceptionCode.RELATION_METADATA_NOT_FOUND,
);
}
}
}

6
packages/twenty-server/src/engine/metadata-modules/relation-metadata/relation-on-delete-action.type.ts Normal file
View File

@ -0,0 +1,6 @@
export enum RelationOnDeleteAction {
CASCADE = 'CASCADE',
RESTRICT = 'RESTRICT',
SET_NULL = 'SET_NULL',
NO_ACTION = 'NO_ACTION',
}

14
packages/twenty-server/src/engine/metadata-modules/relation-metadata/types/relation-to-delete.ts
View File

@ -1,14 +0,0 @@
export type RelationToDelete = {
id: string;
fromFieldMetadataId: string;
toFieldMetadataId: string;
fromFieldMetadataName: string;
toFieldMetadataName: string;
fromObjectMetadataId: string;
toObjectMetadataId: string;
fromObjectName: string;
toObjectName: string;
toFieldMetadataIsCustom: boolean;
toObjectMetadataIsCustom: boolean;
direction: string;
};

5
packages/twenty-server/src/engine/metadata-modules/relation-metadata/utils/create-relation-foreign-key-field-metadata-name.util.ts
View File

@ -1,5 +0,0 @@
import { camelCase } from 'src/utils/camel-case';
export const createRelationForeignKeyFieldMetadataName = (name: string) => {
return `${camelCase(name)}Id`;
};

34
packages/twenty-server/src/engine/metadata-modules/relation-metadata/utils/relation-metadata-graphql-api-exception-handler.util.ts
View File

@ -1,34 +0,0 @@
import {
ConflictError,
UserInputError,
} from 'src/engine/core-modules/graphql/utils/graphql-errors.util';
import {
RelationMetadataException,
RelationMetadataExceptionCode,
} from 'src/engine/metadata-modules/relation-metadata/relation-metadata.exception';
import { InvalidMetadataException } from 'src/engine/metadata-modules/utils/exceptions/invalid-metadata.exception';
export const relationMetadataGraphqlApiExceptionHandler = (error: Error) => {
if (error instanceof InvalidMetadataException) {
throw new UserInputError(error.message);
}
if (error instanceof RelationMetadataException) {
switch (error.code) {
case RelationMetadataExceptionCode.INVALID_RELATION_INPUT:
throw new UserInputError(error.message);
case RelationMetadataExceptionCode.RELATION_ALREADY_EXISTS:
throw new ConflictError(error.message);
case RelationMetadataExceptionCode.FOREIGN_KEY_NOT_FOUND:
case RelationMetadataExceptionCode.RELATION_METADATA_NOT_FOUND:
throw error;
default: {
const _exhaustiveCheck: never = error.code;
throw error;
}
}
}
throw error;
};

2
packages/twenty-server/src/engine/metadata-modules/remote-server/remote-server.module.ts
View File

@ -13,7 +13,7 @@ import { WorkspaceDataSourceModule } from 'src/engine/workspace-datasource/works
@Module({
imports: [
JwtModule,
TypeOrmModule.forFeature([RemoteServerEntity], 'metadata'),
TypeOrmModule.forFeature([RemoteServerEntity], 'core'),
RemoteTableModule,
WorkspaceDataSourceModule,
TypeOrmModule.forFeature([FeatureFlag], 'core'),

12
packages/twenty-server/src/engine/metadata-modules/remote-server/remote-server.service.ts
View File

@ -32,12 +32,12 @@ import { WorkspaceDataSourceService } from 'src/engine/workspace-datasource/work
@Injectable()
export class RemoteServerService<T extends RemoteServerType> {
constructor(
@InjectRepository(RemoteServerEntity, 'metadata')
@InjectRepository(RemoteServerEntity, 'core')
private readonly remoteServerRepository: Repository<
RemoteServerEntity<RemoteServerType>
>,
@InjectDataSource('metadata')
private readonly metadataDataSource: DataSource,
@InjectDataSource('core')
private readonly coreDataSource: DataSource,
private readonly jwtWrapperService: JwtWrapperService,
private readonly foreignDataWrapperServerQueryFactory: ForeignDataWrapperServerQueryFactory,
private readonly remoteTableService: RemoteTableService,
@ -79,7 +79,7 @@ export class RemoteServerService<T extends RemoteServerType> {
};
}
return this.metadataDataSource.transaction(
return this.coreDataSource.transaction(
async (entityManager: WorkspaceEntityManager) => {
const createdRemoteServer = entityManager.create(
RemoteServerEntity,
@ -164,7 +164,7 @@ export class RemoteServerService<T extends RemoteServerType> {
};
}
return this.metadataDataSource.transaction(
return this.coreDataSource.transaction(
async (entityManager: EntityManager) => {
const updatedRemoteServer = await this.updateRemoteServer(
partialRemoteServerWithUpdates,
@ -222,7 +222,7 @@ export class RemoteServerService<T extends RemoteServerType> {
await this.remoteTableService.unsyncAll(workspaceId, remoteServer);
return this.metadataDataSource.transaction(
return this.coreDataSource.transaction(
async (entityManager: EntityManager) => {
await entityManager.query(
`DROP SERVER "${remoteServer.foreignDataWrapperId}" CASCADE`,

2
packages/twenty-server/src/engine/metadata-modules/remote-server/remote-table/distant-table/distant-table.module.ts
View File

@ -8,7 +8,7 @@ import { WorkspaceDataSourceModule } from 'src/engine/workspace-datasource/works
@Module({
imports: [
WorkspaceDataSourceModule,
TypeOrmModule.forFeature([RemoteServerEntity], 'metadata'),
TypeOrmModule.forFeature([RemoteServerEntity], 'core'),
],
providers: [DistantTableService],
exports: [DistantTableService],

7
packages/twenty-server/src/engine/metadata-modules/remote-server/remote-table/distant-table/distant-table.service.ts
View File

@ -1,7 +1,6 @@
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { EntityManager, Repository } from 'typeorm';
import { EntityManager } from 'typeorm';
import { v4 } from 'uuid';
import {
@ -22,10 +21,6 @@ import { WorkspaceDataSourceService } from 'src/engine/workspace-datasource/work
export class DistantTableService {
constructor(
private readonly workspaceDataSourceService: WorkspaceDataSourceService,
@InjectRepository(RemoteServerEntity, 'metadata')
private readonly remoteServerRepository: Repository<
RemoteServerEntity<RemoteServerType>
>,
) {}
public async fetchDistantTables(

2
packages/twenty-server/src/engine/metadata-modules/remote-server/remote-table/remote-table-relations/remote-table-relations.module.ts
View File

@ -10,7 +10,7 @@ import { WorkspaceMigrationModule } from 'src/engine/metadata-modules/workspace-
imports: [
TypeOrmModule.forFeature(
[ObjectMetadataEntity, FieldMetadataEntity],
'metadata',
'core',
),
WorkspaceMigrationModule,
],

11
packages/twenty-server/src/engine/metadata-modules/remote-server/remote-table/remote-table-relations/remote-table-relations.service.ts
View File

@ -1,14 +1,13 @@
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { In, Repository } from 'typeorm';
import { FieldMetadataType } from 'twenty-shared/types';
import { In, Repository } from 'typeorm';
import { FieldMetadataSettings } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata-settings.interface';
import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
import { createRelationForeignKeyFieldMetadataName } from 'src/engine/metadata-modules/relation-metadata/utils/create-relation-foreign-key-field-metadata-name.util';
import { buildMigrationsToCreateRemoteTableRelations } from 'src/engine/metadata-modules/remote-server/remote-table/remote-table-relations/utils/build-migrations-to-create-remote-table-relations.util';
import { buildMigrationsToRemoveRemoteTableRelations } from 'src/engine/metadata-modules/remote-server/remote-table/remote-table-relations/utils/build-migrations-to-remove-remote-table-relations.util';
import { mapUdtNameToFieldType } from 'src/engine/metadata-modules/remote-server/remote-table/utils/udt-name-mapper.util';
@ -24,10 +23,10 @@ import { createForeignKeyDeterministicUuid } from 'src/engine/workspace-manager/
@Injectable()
export class RemoteTableRelationsService {
constructor(
@InjectRepository(ObjectMetadataEntity, 'metadata')
@InjectRepository(ObjectMetadataEntity, 'core')
private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
@InjectRepository(FieldMetadataEntity, 'metadata')
@InjectRepository(FieldMetadataEntity, 'core')
private readonly fieldMetadataRepository: Repository<FieldMetadataEntity>,
private readonly workspaceMigrationService: WorkspaceMigrationService,
) {}
@ -108,9 +107,7 @@ export class RemoteTableRelationsService {
});
// compute the target column name
const targetColumnName = createRelationForeignKeyFieldMetadataName(
remoteObjectMetadata.nameSingular,
);
const targetColumnName = `${remoteObjectMetadata.nameSingular}Id`;
// find the foreign key fields to delete
const foreignKeyFieldsToDelete = await this.fieldMetadataRepository.find({

5
packages/twenty-server/src/engine/metadata-modules/remote-server/remote-table/remote-table.module.ts
View File

@ -17,10 +17,7 @@ import { WorkspaceDataSourceModule } from 'src/engine/workspace-datasource/works
@Module({
imports: [
DistantTableModule,
TypeOrmModule.forFeature(
[RemoteServerEntity, RemoteTableEntity],
'metadata',
),
TypeOrmModule.forFeature([RemoteServerEntity, RemoteTableEntity], 'core'),
DataSourceModule,
ObjectMetadataModule,
FieldMetadataModule,

4
packages/twenty-server/src/engine/metadata-modules/remote-server/remote-table/remote-table.service.ts
View File

@ -49,9 +49,9 @@ export class RemoteTableService {
private readonly logger = new Logger(RemoteTableService.name);
constructor(
@InjectRepository(RemoteTableEntity, 'metadata')
@InjectRepository(RemoteTableEntity, 'core')
private readonly remoteTableRepository: Repository<RemoteTableEntity>,
@InjectRepository(RemoteServerEntity, 'metadata')
@InjectRepository(RemoteServerEntity, 'core')
private readonly remoteServerRepository: Repository<
RemoteServerEntity<RemoteServerType>
>,

2
packages/twenty-server/src/engine/metadata-modules/remote-server/remote-table/utils/get-remote-table-local-name.util.ts
View File

@ -22,7 +22,7 @@ const isNameAvailable = async (
// TO DO workspaceDataSource.query method is not allowed, this will throw
const numberOfTablesWithSameName = +(
await workspaceDataSource.query(
`SELECT count(table_name) FROM information_schema.tables WHERE table_name LIKE '${tableName}' AND table_schema IN ('core', 'metadata', '${workspaceSchemaName}')`,
`SELECT count(table_name) FROM information_schema.tables WHERE table_name LIKE '${tableName}' AND table_schema IN ('core', '${workspaceSchemaName}')`,
)
)[0].count;

2
packages/twenty-server/src/engine/metadata-modules/role/role.module.ts
View File

@ -18,7 +18,7 @@ import { WorkspacePermissionsCacheModule } from 'src/engine/metadata-modules/wor
@Module({
imports: [
TypeOrmModule.forFeature([RoleEntity, UserWorkspaceRoleEntity], 'metadata'),
TypeOrmModule.forFeature([RoleEntity, UserWorkspaceRoleEntity], 'core'),
TypeOrmModule.forFeature([UserWorkspace, Workspace], 'core'),
UserRoleModule,
PermissionsModule,

4
packages/twenty-server/src/engine/metadata-modules/role/role.service.ts
View File

@ -26,9 +26,9 @@ export class RoleService {
constructor(
@InjectRepository(Workspace, 'core')
private readonly workspaceRepository: Repository<Workspace>,
@InjectRepository(RoleEntity, 'metadata')
@InjectRepository(RoleEntity, 'core')
private readonly roleRepository: Repository<RoleEntity>,
@InjectRepository(UserWorkspaceRoleEntity, 'metadata')
@InjectRepository(UserWorkspaceRoleEntity, 'core')
private readonly userWorkspaceRoleRepository: Repository<UserWorkspaceRoleEntity>,
private readonly userRoleService: UserRoleService,
private readonly workspacePermissionsCacheService: WorkspacePermissionsCacheService,

2
packages/twenty-server/src/engine/metadata-modules/search-vector/search-vector.module.ts
View File

@ -12,7 +12,7 @@ import { WorkspaceMigrationModule } from 'src/engine/metadata-modules/workspace-
imports: [
NestjsQueryTypeOrmModule.forFeature(
[ObjectMetadataEntity, FieldMetadataEntity],
'metadata',
'core',
),
IndexMetadataModule,
WorkspaceMigrationModule,

Some files were not shown because too many files have changed in this diff Show More