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

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,

6
packages/twenty-server/src/engine/metadata-modules/search-vector/search-vector.service.ts
View File

@ -1,9 +1,9 @@
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { FieldMetadataType } from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
import { Repository } from 'typeorm';
import { FieldMetadataInterface } from 'src/engine/metadata-modules/field-metadata/interfaces/field-metadata.interface';
@ -33,11 +33,11 @@ import { SearchableFieldType } from 'src/engine/workspace-manager/workspace-sync
@Injectable()
export class SearchVectorService {
constructor(
@InjectRepository(ObjectMetadataEntity, 'metadata')
@InjectRepository(ObjectMetadataEntity, 'core')
private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
private readonly tsVectorColumnActionFactory: TsVectorColumnActionFactory,
private readonly indexMetadataService: IndexMetadataService,
@InjectRepository(FieldMetadataEntity, 'metadata')
@InjectRepository(FieldMetadataEntity, 'core')
private readonly fieldMetadataRepository: Repository<FieldMetadataEntity>,
private readonly workspaceMigrationService: WorkspaceMigrationService,
private readonly workspaceMigrationFactory: WorkspaceMigrationFactory,

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

@ -15,7 +15,7 @@ import { ServerlessFunctionService } from 'src/engine/metadata-modules/serverles
@Module({
imports: [
FileUploadModule,
NestjsQueryTypeOrmModule.forFeature([ServerlessFunctionEntity], 'metadata'),
NestjsQueryTypeOrmModule.forFeature([ServerlessFunctionEntity], 'core'),
TypeOrmModule.forFeature([FeatureFlag], 'core'),
FileModule,
ThrottlerModule,

4
packages/twenty-server/src/engine/metadata-modules/serverless-function/serverless-function.resolver.ts
View File

@ -18,13 +18,13 @@ import { ServerlessFunctionExecutionResultDTO } from 'src/engine/metadata-module
import { ServerlessFunctionIdInput } from 'src/engine/metadata-modules/serverless-function/dtos/serverless-function-id.input';
import { ServerlessFunctionDTO } from 'src/engine/metadata-modules/serverless-function/dtos/serverless-function.dto';
import { UpdateServerlessFunctionInput } from 'src/engine/metadata-modules/serverless-function/dtos/update-serverless-function.input';
import { ServerlessFunctionEntity } from 'src/engine/metadata-modules/serverless-function/serverless-function.entity';
import {
ServerlessFunctionException,
ServerlessFunctionExceptionCode,
} from 'src/engine/metadata-modules/serverless-function/serverless-function.exception';
import { ServerlessFunctionService } from 'src/engine/metadata-modules/serverless-function/serverless-function.service';
import { serverlessFunctionGraphQLApiExceptionHandler } from 'src/engine/metadata-modules/serverless-function/utils/serverless-function-graphql-api-exception-handler.utils';
import { ServerlessFunctionEntity } from 'src/engine/metadata-modules/serverless-function/serverless-function.entity';
@UseGuards(WorkspaceAuthGuard)
@Resolver()
@ -33,7 +33,7 @@ export class ServerlessFunctionResolver {
private readonly serverlessFunctionService: ServerlessFunctionService,
@InjectRepository(FeatureFlag, 'core')
private readonly featureFlagRepository: Repository<FeatureFlag>,
@InjectRepository(ServerlessFunctionEntity, 'metadata')
@InjectRepository(ServerlessFunctionEntity, 'core')
private readonly serverlessFunctionRepository: Repository<ServerlessFunctionEntity>,
) {}

2
packages/twenty-server/src/engine/metadata-modules/serverless-function/serverless-function.service.ts
View File

@ -36,7 +36,7 @@ export class ServerlessFunctionService {
constructor(
private readonly fileStorageService: FileStorageService,
private readonly serverlessService: ServerlessService,
@InjectRepository(ServerlessFunctionEntity, 'metadata')
@InjectRepository(ServerlessFunctionEntity, 'core')
private readonly serverlessFunctionRepository: Repository<ServerlessFunctionEntity>,
private readonly throttlerService: ThrottlerService,
private readonly twentyConfigService: TwentyConfigService,

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

@ -7,7 +7,7 @@ import { SettingPermissionService } from 'src/engine/metadata-modules/setting-pe
@Module({
imports: [
TypeOrmModule.forFeature([SettingPermissionEntity, RoleEntity], 'metadata'),
TypeOrmModule.forFeature([SettingPermissionEntity, RoleEntity], 'core'),
],
providers: [SettingPermissionService],
exports: [SettingPermissionService],

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

@ -15,12 +15,12 @@ import { SettingPermissionEntity } from 'src/engine/metadata-modules/setting-per
export class SettingPermissionService {
constructor(
@InjectRepository(SettingPermissionEntity, 'metadata')
@InjectRepository(SettingPermissionEntity, 'core')
private readonly settingPermissionRepository: Repository<SettingPermissionEntity>,
@InjectRepository(RoleEntity, 'metadata')
@InjectRepository(RoleEntity, 'core')
private readonly roleRepository: Repository<RoleEntity>,
@InjectDataSource('metadata')
private readonly metadataDataSource: DataSource,
@InjectDataSource('core')
private readonly coreDataSource: DataSource,
) {}
public async upsertSettingPermissions({
@ -46,7 +46,7 @@ export class SettingPermissionService {
);
}
const queryRunner = this.metadataDataSource.createQueryRunner();
const queryRunner = this.coreDataSource.createQueryRunner();
await queryRunner.connect();
await queryRunner.startTransaction();

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

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

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

@ -18,9 +18,9 @@ import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/sta
export class UserRoleService {
constructor(
@InjectRepository(RoleEntity, 'metadata')
@InjectRepository(RoleEntity, 'core')
private readonly roleRepository: Repository<RoleEntity>,
@InjectRepository(UserWorkspaceRoleEntity, 'metadata')
@InjectRepository(UserWorkspaceRoleEntity, 'core')
private readonly userWorkspaceRoleRepository: Repository<UserWorkspaceRoleEntity>,
@InjectRepository(UserWorkspace, 'core')
private readonly userWorkspaceRepository: Repository<UserWorkspace>,

4
packages/twenty-server/src/engine/metadata-modules/workspace-metadata-cache/services/workspace-metadata-cache.service.ts
View File

@ -22,7 +22,7 @@ export class WorkspaceMetadataCacheService {
@InjectRepository(Workspace, 'core')
private readonly workspaceRepository: Repository<Workspace>,
private readonly workspaceCacheStorageService: WorkspaceCacheStorageService,
@InjectRepository(ObjectMetadataEntity, 'metadata')
@InjectRepository(ObjectMetadataEntity, 'core')
private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
) {}
@ -85,8 +85,6 @@ export class WorkspaceMetadataCacheService {
where: { workspaceId },
relations: [
'fields',
'fields.fromRelationMetadata',
'fields.toRelationMetadata',
'indexMetadatas',
'indexMetadatas.indexFieldMetadatas',
],

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

@ -9,7 +9,7 @@ import { WorkspaceCacheStorageModule } from 'src/engine/workspace-cache-storage/
@Module({
imports: [
TypeOrmModule.forFeature([Workspace], 'core'),
TypeOrmModule.forFeature([ObjectMetadataEntity], 'metadata'),
TypeOrmModule.forFeature([ObjectMetadataEntity], 'core'),
WorkspaceCacheStorageModule,
],
exports: [WorkspaceMetadataCacheService],

11
packages/twenty-server/src/engine/metadata-modules/workspace-migration/factories/relation-column-action.factory.ts
View File

@ -39,8 +39,7 @@ export class RelationColumnActionFactory extends ColumnActionAbstractFactory<Fie
columnType: fieldMetadataTypeToColumnType(FieldMetadataType.UUID),
isArray: false,
isNullable: fieldMetadata.isNullable ?? true,
isUnique:
fieldMetadata.settings.relationType === RelationType.ONE_TO_ONE,
isUnique: false,
defaultValue: null,
},
];
@ -82,9 +81,7 @@ export class RelationColumnActionFactory extends ColumnActionAbstractFactory<Fie
columnType: fieldMetadataTypeToColumnType(FieldMetadataType.UUID),
isArray: false,
isNullable: currentFieldMetadata.isNullable ?? true,
isUnique:
currentFieldMetadata.settings.relationType ===
RelationType.ONE_TO_ONE,
isUnique: false,
defaultValue: null,
},
alteredColumnDefinition: {
@ -92,9 +89,7 @@ export class RelationColumnActionFactory extends ColumnActionAbstractFactory<Fie
columnType: fieldMetadataTypeToColumnType(FieldMetadataType.UUID),
isArray: false,
isNullable: alteredFieldMetadata.isNullable ?? true,
isUnique:
alteredFieldMetadata.settings.relationType ===
RelationType.ONE_TO_ONE,
isUnique: false,
defaultValue: null,
},
},

2
packages/twenty-server/src/engine/metadata-modules/workspace-migration/workspace-migration.entity.ts
View File

@ -6,7 +6,7 @@ import {
} from 'typeorm';
import { IndexType } from 'src/engine/metadata-modules/index-metadata/index-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';
export enum WorkspaceMigrationColumnActionType {
CREATE = 'CREATE',

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

@ -8,7 +8,7 @@ import { WorkspaceMigrationEntity } from './workspace-migration.entity';
import { WorkspaceMigrationService } from './workspace-migration.service';
@Module({
imports: [TypeOrmModule.forFeature([WorkspaceMigrationEntity], 'metadata')],
imports: [TypeOrmModule.forFeature([WorkspaceMigrationEntity], 'core')],
providers: [
...workspaceColumnActionFactories,
WorkspaceMigrationFactory,

2
packages/twenty-server/src/engine/metadata-modules/workspace-migration/workspace-migration.service.ts
View File

@ -11,7 +11,7 @@ import {
@Injectable()
export class WorkspaceMigrationService {
constructor(
@InjectRepository(WorkspaceMigrationEntity, 'metadata')
@InjectRepository(WorkspaceMigrationEntity, 'core')
private readonly workspaceMigrationRepository: Repository<WorkspaceMigrationEntity>,
) {}

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

@ -16,7 +16,7 @@ import { WorkspacePermissionsCacheService } from './workspace-permissions-cache.
TypeOrmModule.forFeature([Workspace], 'core'),
TypeOrmModule.forFeature(
[ObjectMetadataEntity, RoleEntity, UserWorkspaceRoleEntity],
'metadata',
'core',
),
WorkspaceCacheStorageModule,
FeatureFlagModule,

6
packages/twenty-server/src/engine/metadata-modules/workspace-permissions-cache/workspace-permissions-cache.service.ts
View File

@ -32,11 +32,11 @@ export class WorkspacePermissionsCacheService {
logger = new Logger(WorkspacePermissionsCacheService.name);
constructor(
@InjectRepository(ObjectMetadataEntity, 'metadata')
@InjectRepository(ObjectMetadataEntity, 'core')
private readonly objectMetadataRepository: Repository<ObjectMetadataEntity>,
@InjectRepository(RoleEntity, 'metadata')
@InjectRepository(RoleEntity, 'core')
private readonly roleRepository: Repository<RoleEntity>,
@InjectRepository(UserWorkspaceRoleEntity, 'metadata')
@InjectRepository(UserWorkspaceRoleEntity, 'core')
private readonly userWorkspaceRoleRepository: Repository<UserWorkspaceRoleEntity>,
private readonly workspacePermissionsCacheStorageService: WorkspacePermissionsCacheStorageService,
private readonly workspaceCacheStorageService: WorkspaceCacheStorageService,