Add db event trigger and cron trigger to migration v2 (#14772)

## Context
Add DB events triggers and Cron triggers to migration v2 builder/runner
(and adding corresponding services/resolvers)

packages/twenty-server/src/engine/metadata-modules/cron-trigger/constants/flat-cron-trigger-editable-properties.constant.ts

@@ -0,0 +1,5 @@
+import { type FlatCronTrigger } from 'src/engine/metadata-modules/cron-trigger/types/flat-cron-trigger.type';
+
+export const FLAT_CRON_TRIGGER_EDITABLE_PROPERTIES = [
+  'settings',
+] as const satisfies (keyof FlatCronTrigger)[];

packages/twenty-server/src/engine/metadata-modules/cron-trigger/constants/flat-cron-trigger-properties-to-compare.constant.ts

@@ -0,0 +1,6 @@
+import { FLAT_CRON_TRIGGER_EDITABLE_PROPERTIES } from 'src/engine/metadata-modules/cron-trigger/constants/flat-cron-trigger-editable-properties.constant';
+import { type FlatCronTrigger } from 'src/engine/metadata-modules/cron-trigger/types/flat-cron-trigger.type';
+
+export const FLAT_CRON_TRIGGER_PROPERTIES_TO_COMPARE = [
+  ...FLAT_CRON_TRIGGER_EDITABLE_PROPERTIES,
+] as const satisfies (keyof FlatCronTrigger)[];

packages/twenty-server/src/engine/metadata-modules/cron-trigger/cron-trigger.module.ts

@@ -0,0 +1,33 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { WorkspaceManyOrAllFlatEntityMapsCacheModule } from 'src/engine/core-modules/common/services/workspace-many-or-all-flat-entity-maps-cache.module';
+import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { CronTriggerCronCommand } from 'src/engine/metadata-modules/cron-trigger/crons/commands/cron-trigger.cron.command';
+import { CronTriggerCronJob } from 'src/engine/metadata-modules/cron-trigger/crons/jobs/cron-trigger.cron.job';
+import { CronTrigger } from 'src/engine/metadata-modules/cron-trigger/entities/cron-trigger.entity';
+import { CronTriggerResolver } from 'src/engine/metadata-modules/cron-trigger/resolvers/cron-trigger.resolver';
+import { CronTriggerV2Service } from 'src/engine/metadata-modules/cron-trigger/services/cron-trigger-v2.service';
+import { WorkspaceFlatCronTriggerMapCacheService } from 'src/engine/metadata-modules/cron-trigger/services/workspace-flat-cron-trigger-map-cache.service';
+import { WorkspaceMigrationV2Module } from 'src/engine/workspace-manager/workspace-migration-v2/workspace-migration-v2.module';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([Workspace, CronTrigger]),
+    WorkspaceManyOrAllFlatEntityMapsCacheModule,
+    WorkspaceMigrationV2Module,
+  ],
+  providers: [
+    CronTriggerCronJob,
+    CronTriggerCronCommand,
+    CronTriggerResolver,
+    CronTriggerV2Service,
+    WorkspaceFlatCronTriggerMapCacheService,
+  ],
+  exports: [
+    CronTriggerCronCommand,
+    CronTriggerV2Service,
+    WorkspaceFlatCronTriggerMapCacheService,
+  ],
+})
+export class CronTriggerModule {}

packages/twenty-server/src/engine/metadata-modules/cron-trigger/crons/commands/cron-trigger.cron.command.ts

@@ -6,7 +6,7 @@ import { MessageQueueService } from 'src/engine/core-modules/message-queue/servi
 import {
   CRON_TRIGGER_CRON_PATTERN,
   CronTriggerCronJob,
-} from 'src/engine/metadata-modules/trigger/crons/jobs/cron-trigger.cron.job';
+} from 'src/engine/metadata-modules/cron-trigger/crons/jobs/cron-trigger.cron.job';
 @Command({
   name: 'cron:trigger:start-cron-trigger',
   description:

packages/twenty-server/src/engine/metadata-modules/cron-trigger/crons/jobs/cron-trigger.cron.job.ts

@@ -10,7 +10,7 @@ import { Process } from 'src/engine/core-modules/message-queue/decorators/proces
 import { Processor } from 'src/engine/core-modules/message-queue/decorators/processor.decorator';
 import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
 import { MessageQueueService } from 'src/engine/core-modules/message-queue/services/message-queue.service';
-import { CronTrigger } from 'src/engine/metadata-modules/trigger/entities/cron-trigger.entity';
+import { CronTrigger } from 'src/engine/metadata-modules/cron-trigger/entities/cron-trigger.entity';
 import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
 import {
   ServerlessFunctionTriggerJob,

packages/twenty-server/src/engine/metadata-modules/cron-trigger/dtos/create-cron-trigger.input.ts

@@ -0,0 +1,19 @@
+import { Field, InputType } from '@nestjs/graphql';
+
+import { IsNotEmpty, IsObject, IsUUID } from 'class-validator';
+import GraphQLJSON from 'graphql-type-json';
+
+import { CronTriggerSettings } from 'src/engine/metadata-modules/cron-trigger/entities/cron-trigger.entity';
+
+@InputType()
+export class CreateCronTriggerInput {
+  @IsObject()
+  @IsNotEmpty()
+  @Field(() => GraphQLJSON)
+  settings: CronTriggerSettings;
+
+  @IsUUID()
+  @IsNotEmpty()
+  @Field()
+  serverlessFunctionId: string;
+}

packages/twenty-server/src/engine/metadata-modules/cron-trigger/dtos/cron-trigger-id.input.ts

@@ -0,0 +1,11 @@
+import { Field, InputType } from '@nestjs/graphql';
+
+import { IsNotEmpty, IsUUID } from 'class-validator';
+
+@InputType()
+export class CronTriggerIdInput {
+  @IsUUID()
+  @IsNotEmpty()
+  @Field(() => String)
+  id: string;
+}

packages/twenty-server/src/engine/metadata-modules/cron-trigger/dtos/cron-trigger.dto.ts

@@ -0,0 +1,35 @@
+import { Field, HideField, ObjectType } from '@nestjs/graphql';
+
+import { IDField } from '@ptc-org/nestjs-query-graphql';
+import { IsDateString, IsNotEmpty, IsObject, IsUUID } from 'class-validator';
+import GraphQLJSON from 'graphql-type-json';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+import { CronTriggerSettings } from 'src/engine/metadata-modules/cron-trigger/entities/cron-trigger.entity';
+
+@ObjectType('CronTrigger')
+export class CronTriggerDTO {
+  @IsUUID()
+  @IsNotEmpty()
+  @IDField(() => UUIDScalarType)
+  id: string;
+
+  @IsObject()
+  @Field(() => GraphQLJSON)
+  settings: CronTriggerSettings;
+
+  @HideField()
+  workspaceId: string;
+
+  @IsUUID()
+  @Field()
+  serverlessFunctionId: string;
+
+  @IsDateString()
+  @Field()
+  createdAt: Date;
+
+  @IsDateString()
+  @Field()
+  updatedAt: Date;
+}

packages/twenty-server/src/engine/metadata-modules/cron-trigger/dtos/update-cron-trigger.input.ts

@@ -0,0 +1,19 @@
+import { Field, InputType } from '@nestjs/graphql';
+
+import { IsNotEmpty, IsObject, IsUUID } from 'class-validator';
+import GraphQLJSON from 'graphql-type-json';
+
+import { CronTriggerSettings } from 'src/engine/metadata-modules/cron-trigger/entities/cron-trigger.entity';
+
+@InputType()
+export class UpdateCronTriggerInput {
+  @IsUUID()
+  @IsNotEmpty()
+  @Field(() => String)
+  id: string;
+
+  @IsObject()
+  @IsNotEmpty()
+  @Field(() => GraphQLJSON)
+  settings: CronTriggerSettings;
+}

packages/twenty-server/src/engine/metadata-modules/cron-trigger/entities/cron-trigger.entity.ts

@@ -2,22 +2,27 @@ import {
   Column,
   CreateDateColumn,
   Entity,
+  Index,
   JoinColumn,
   ManyToOne,
   PrimaryGeneratedColumn,
-  UpdateDateColumn,
   Relation,
-  Index,
+  UpdateDateColumn,
 } from 'typeorm';
 
 import { SyncableEntity } from 'src/engine/workspace-manager/workspace-sync/interfaces/syncable-entity.interface';
 
+import { CronTriggerEntityRelationProperties } from 'src/engine/metadata-modules/cron-trigger/types/flat-cron-trigger.type';
 import { ServerlessFunctionEntity } from 'src/engine/metadata-modules/serverless-function/serverless-function.entity';
 
 export type CronTriggerSettings = {
   pattern: string;
 };
 
+export const CRON_TRIGGER_ENTITY_RELATION_PROPERTIES = [
+  'serverlessFunction',
+] as const satisfies readonly CronTriggerEntityRelationProperties[];
+
 @Entity({ name: 'cronTrigger', schema: 'core' })
 @Index('IDX_CRON_TRIGGER_WORKSPACE_ID', ['workspaceId'])
 export class CronTrigger extends SyncableEntity {
@@ -35,6 +40,9 @@ export class CronTrigger extends SyncableEntity {
   @JoinColumn({ name: 'serverlessFunctionId' })
   serverlessFunction: Relation<ServerlessFunctionEntity>;
 
+  @Column({ nullable: true, type: 'uuid' })
+  serverlessFunctionId: string | null;
+
   @Column({ nullable: false, type: 'uuid' })
   workspaceId: string;
 

packages/twenty-server/src/engine/metadata-modules/cron-trigger/exceptions/cron-trigger.exception.ts

@@ -0,0 +1,12 @@
+import { CustomException } from 'src/utils/custom-exception';
+
+export class CronTriggerException extends CustomException {
+  constructor(message: string, code: CronTriggerExceptionCode) {
+    super(message, code);
+  }
+}
+
+export enum CronTriggerExceptionCode {
+  CRON_TRIGGER_NOT_FOUND = 'CRON_TRIGGER_NOT_FOUND',
+  CRON_TRIGGER_ALREADY_EXIST = 'CRON_TRIGGER_ALREADY_EXIST',
+}

packages/twenty-server/src/engine/metadata-modules/cron-trigger/resolvers/cron-trigger.resolver.ts

@@ -0,0 +1,99 @@
+import { UseFilters, UseGuards, UsePipes } from '@nestjs/common';
+import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { Repository } from 'typeorm';
+
+import { PreventNestToAutoLogGraphqlErrorsFilter } from 'src/engine/core-modules/graphql/filters/prevent-nest-to-auto-log-graphql-errors.filter';
+import { ResolverValidationPipe } from 'src/engine/core-modules/graphql/pipes/resolver-validation.pipe';
+import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
+import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.guard';
+import { CreateCronTriggerInput } from 'src/engine/metadata-modules/cron-trigger/dtos/create-cron-trigger.input';
+import { CronTriggerIdInput } from 'src/engine/metadata-modules/cron-trigger/dtos/cron-trigger-id.input';
+import { CronTriggerDTO } from 'src/engine/metadata-modules/cron-trigger/dtos/cron-trigger.dto';
+import { UpdateCronTriggerInput } from 'src/engine/metadata-modules/cron-trigger/dtos/update-cron-trigger.input';
+import { CronTrigger } from 'src/engine/metadata-modules/cron-trigger/entities/cron-trigger.entity';
+import { CronTriggerV2Service } from 'src/engine/metadata-modules/cron-trigger/services/cron-trigger-v2.service';
+import { cronTriggerGraphQLApiExceptionHandler } from 'src/engine/metadata-modules/cron-trigger/utils/cron-trigger-graphql-api-exception-handler.util';
+
+@UseGuards(WorkspaceAuthGuard)
+@Resolver()
+@UsePipes(ResolverValidationPipe)
+@UseFilters(PreventNestToAutoLogGraphqlErrorsFilter)
+export class CronTriggerResolver {
+  constructor(
+    private readonly cronTriggerV2Service: CronTriggerV2Service,
+    @InjectRepository(CronTrigger)
+    private readonly cronTriggerRepository: Repository<CronTrigger>,
+  ) {}
+
+  @Query(() => CronTriggerDTO)
+  async findOneCronTrigger(
+    @Args('input') { id }: CronTriggerIdInput,
+    @AuthWorkspace() { id: workspaceId }: Workspace,
+  ) {
+    try {
+      return await this.cronTriggerRepository.findOneOrFail({
+        where: {
+          id,
+          workspaceId,
+        },
+      });
+    } catch (error) {
+      cronTriggerGraphQLApiExceptionHandler(error);
+    }
+  }
+
+  @Query(() => [CronTriggerDTO])
+  async findManyCronTriggers(@AuthWorkspace() { id: workspaceId }: Workspace) {
+    try {
+      return await this.cronTriggerRepository.find({
+        where: { workspaceId },
+      });
+    } catch (error) {
+      cronTriggerGraphQLApiExceptionHandler(error);
+    }
+  }
+
+  @Mutation(() => CronTriggerDTO)
+  async deleteOneCronTrigger(
+    @Args('input') input: CronTriggerIdInput,
+    @AuthWorkspace() { id: workspaceId }: Workspace,
+  ) {
+    try {
+      return await this.cronTriggerV2Service.destroyOne({
+        destroyCronTriggerInput: input,
+        workspaceId,
+      });
+    } catch (error) {
+      cronTriggerGraphQLApiExceptionHandler(error);
+    }
+  }
+
+  @Mutation(() => CronTriggerDTO)
+  async updateOneCronTrigger(
+    @Args('input')
+    input: UpdateCronTriggerInput,
+    @AuthWorkspace() { id: workspaceId }: Workspace,
+  ) {
+    try {
+      return await this.cronTriggerV2Service.updateOne(input, workspaceId);
+    } catch (error) {
+      cronTriggerGraphQLApiExceptionHandler(error);
+    }
+  }
+
+  @Mutation(() => CronTriggerDTO)
+  async createOneCronTrigger(
+    @Args('input')
+    input: CreateCronTriggerInput,
+    @AuthWorkspace() { id: workspaceId }: Workspace,
+  ) {
+    try {
+      return await this.cronTriggerV2Service.createOne(input, workspaceId);
+    } catch (error) {
+      cronTriggerGraphQLApiExceptionHandler(error);
+    }
+  }
+}

packages/twenty-server/src/engine/metadata-modules/cron-trigger/services/cron-trigger-v2.service.ts

@@ -0,0 +1,222 @@
+import { Injectable } from '@nestjs/common';
+
+import { isDefined } from 'twenty-shared/utils';
+
+import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/core-modules/common/services/workspace-many-or-all-flat-entity-maps-cache.service.';
+import { addFlatEntityToFlatEntityMapsOrThrow } from 'src/engine/core-modules/common/utils/add-flat-entity-to-flat-entity-maps-or-throw.util';
+import { deleteFlatEntityFromFlatEntityMapsOrThrow } from 'src/engine/core-modules/common/utils/delete-flat-entity-from-flat-entity-maps-or-throw.util';
+import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/core-modules/common/utils/find-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
+import { getSubFlatEntityMapsOrThrow } from 'src/engine/core-modules/common/utils/get-sub-flat-entity-maps-or-throw.util';
+import { replaceFlatEntityInFlatEntityMapsOrThrow } from 'src/engine/core-modules/common/utils/replace-flat-entity-in-flat-entity-maps-or-throw.util';
+import { CreateCronTriggerInput } from 'src/engine/metadata-modules/cron-trigger/dtos/create-cron-trigger.input';
+import { CronTriggerIdInput } from 'src/engine/metadata-modules/cron-trigger/dtos/cron-trigger-id.input';
+import { UpdateCronTriggerInput } from 'src/engine/metadata-modules/cron-trigger/dtos/update-cron-trigger.input';
+import {
+  CronTriggerException,
+  CronTriggerExceptionCode,
+} from 'src/engine/metadata-modules/cron-trigger/exceptions/cron-trigger.exception';
+import { FlatCronTrigger } from 'src/engine/metadata-modules/cron-trigger/types/flat-cron-trigger.type';
+import { fromCreateCronTriggerInputToFlatCronTrigger } from 'src/engine/metadata-modules/cron-trigger/utils/from-create-cron-trigger-input-to-flat-cron-trigger.util';
+import { fromUpdateCronTriggerInputToFlatCronTriggerToUpdateOrThrow } from 'src/engine/metadata-modules/cron-trigger/utils/from-update-cron-trigger-input-to-flat-cron-trigger-to-update-or-throw.util';
+import { WorkspaceMigrationBuilderExceptionV2 } from 'src/engine/workspace-manager/workspace-migration-v2/exceptions/workspace-migration-builder-exception-v2';
+import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration-v2/services/workspace-migration-validate-build-and-run-service';
+
+@Injectable()
+export class CronTriggerV2Service {
+  constructor(
+    private readonly flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
+    private readonly workspaceMigrationValidateBuildAndRunService: WorkspaceMigrationValidateBuildAndRunService,
+  ) {}
+
+  async createOne(
+    cronTriggerInput: CreateCronTriggerInput,
+    workspaceId: string,
+  ) {
+    const flatEntityMaps =
+      await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+        {
+          workspaceId,
+          flatEntities: ['flatCronTriggerMaps'],
+        },
+      );
+
+    const existingFlatCronTriggerMaps = flatEntityMaps.flatCronTriggerMaps;
+
+    const flatCronTriggerToCreate = fromCreateCronTriggerInputToFlatCronTrigger(
+      {
+        createCronTriggerInput: cronTriggerInput,
+        workspaceId,
+      },
+    );
+
+    const toFlatCronTriggerMaps = addFlatEntityToFlatEntityMapsOrThrow({
+      flatEntity: flatCronTriggerToCreate,
+      flatEntityMaps: existingFlatCronTriggerMaps,
+    });
+
+    const validateAndBuildResult =
+      await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(
+        {
+          workspaceId,
+          fromToAllFlatEntityMaps: {
+            flatCronTriggerMaps: {
+              from: existingFlatCronTriggerMaps,
+              to: toFlatCronTriggerMaps,
+            },
+          },
+          buildOptions: {
+            isSystemBuild: false,
+            inferDeletionFromMissingEntities: false,
+          },
+        },
+      );
+
+    if (isDefined(validateAndBuildResult)) {
+      throw new WorkspaceMigrationBuilderExceptionV2(
+        validateAndBuildResult,
+        'Multiple validation errors occurred while creating cron trigger',
+      );
+    }
+
+    const { flatCronTriggerMaps: recomputedExistingFlatCronTriggerMaps } =
+      await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+        {
+          workspaceId,
+          flatEntities: ['flatCronTriggerMaps'],
+        },
+      );
+
+    return findFlatEntityByIdInFlatEntityMapsOrThrow({
+      flatEntityId: flatCronTriggerToCreate.id,
+      flatEntityMaps: recomputedExistingFlatCronTriggerMaps,
+    });
+  }
+
+  async updateOne(
+    cronTriggerInput: UpdateCronTriggerInput,
+    workspaceId: string,
+  ) {
+    const flatEntityMaps =
+      await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+        {
+          workspaceId,
+          flatEntities: ['flatCronTriggerMaps'],
+        },
+      );
+
+    const existingFlatCronTriggerMaps = flatEntityMaps.flatCronTriggerMaps;
+
+    const optimisticallyUpdatedFlatCronTrigger =
+      fromUpdateCronTriggerInputToFlatCronTriggerToUpdateOrThrow({
+        flatCronTriggerMaps: existingFlatCronTriggerMaps,
+        updateCronTriggerInput: cronTriggerInput,
+      });
+
+    const fromFlatCronTriggerMaps = getSubFlatEntityMapsOrThrow({
+      flatEntityIds: [optimisticallyUpdatedFlatCronTrigger.id],
+      flatEntityMaps: existingFlatCronTriggerMaps,
+    });
+    const toFlatCronTriggerMaps = replaceFlatEntityInFlatEntityMapsOrThrow({
+      flatEntity: optimisticallyUpdatedFlatCronTrigger,
+      flatEntityMaps: fromFlatCronTriggerMaps,
+    });
+
+    const validateAndBuildResult =
+      await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(
+        {
+          workspaceId,
+          fromToAllFlatEntityMaps: {
+            flatCronTriggerMaps: {
+              from: existingFlatCronTriggerMaps,
+              to: toFlatCronTriggerMaps,
+            },
+          },
+          buildOptions: {
+            isSystemBuild: false,
+            inferDeletionFromMissingEntities: false,
+          },
+        },
+      );
+
+    if (isDefined(validateAndBuildResult)) {
+      throw new WorkspaceMigrationBuilderExceptionV2(
+        validateAndBuildResult,
+        'Multiple validation errors occurred while updating cron trigger',
+      );
+    }
+
+    const { flatCronTriggerMaps: recomputedExistingFlatCronTriggerMaps } =
+      await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+        {
+          workspaceId,
+          flatEntities: ['flatCronTriggerMaps'],
+        },
+      );
+
+    return findFlatEntityByIdInFlatEntityMapsOrThrow({
+      flatEntityId: optimisticallyUpdatedFlatCronTrigger.id,
+      flatEntityMaps: recomputedExistingFlatCronTriggerMaps,
+    });
+  }
+
+  async destroyOne({
+    destroyCronTriggerInput,
+    workspaceId,
+  }: {
+    destroyCronTriggerInput: CronTriggerIdInput;
+    workspaceId: string;
+  }): Promise<FlatCronTrigger> {
+    const { flatCronTriggerMaps: existingFlatCronTriggerMaps } =
+      await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+        {
+          workspaceId,
+          flatEntities: ['flatCronTriggerMaps'],
+        },
+      );
+
+    const existingFlatCronTrigger =
+      existingFlatCronTriggerMaps.byId[destroyCronTriggerInput.id];
+
+    if (!isDefined(existingFlatCronTrigger)) {
+      throw new CronTriggerException(
+        'Cron trigger to destroy not found',
+        CronTriggerExceptionCode.CRON_TRIGGER_NOT_FOUND,
+      );
+    }
+
+    const fromFlatCronTriggerMaps = getSubFlatEntityMapsOrThrow({
+      flatEntityIds: [existingFlatCronTrigger.id],
+      flatEntityMaps: existingFlatCronTriggerMaps,
+    });
+    const toFlatCronTriggerMaps = deleteFlatEntityFromFlatEntityMapsOrThrow({
+      flatEntityMaps: fromFlatCronTriggerMaps,
+      entityToDeleteId: existingFlatCronTrigger.id,
+    });
+
+    const validateAndBuildResult =
+      await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(
+        {
+          fromToAllFlatEntityMaps: {
+            flatCronTriggerMaps: {
+              from: fromFlatCronTriggerMaps,
+              to: toFlatCronTriggerMaps,
+            },
+          },
+          buildOptions: {
+            isSystemBuild: false,
+            inferDeletionFromMissingEntities: true,
+          },
+          workspaceId,
+        },
+      );
+
+    if (isDefined(validateAndBuildResult)) {
+      throw new WorkspaceMigrationBuilderExceptionV2(
+        validateAndBuildResult,
+        'Multiple validation errors occurred while destroying cron trigger',
+      );
+    }
+
+    return existingFlatCronTrigger;
+  }
+}

packages/twenty-server/src/engine/metadata-modules/cron-trigger/services/workspace-flat-cron-trigger-map-cache.service.ts

@@ -0,0 +1,69 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { removePropertiesFromRecord } from 'twenty-shared/utils';
+import { Repository } from 'typeorm';
+
+import { InjectCacheStorage } from 'src/engine/core-modules/cache-storage/decorators/cache-storage.decorator';
+import { CacheStorageService } from 'src/engine/core-modules/cache-storage/services/cache-storage.service';
+import { CacheStorageNamespace } from 'src/engine/core-modules/cache-storage/types/cache-storage-namespace.enum';
+import { EMPTY_FLAT_ENTITY_MAPS } from 'src/engine/core-modules/common/constant/empty-flat-entity-maps.constant';
+import { FlatEntityMaps } from 'src/engine/core-modules/common/types/flat-entity-maps.type';
+import {
+  CRON_TRIGGER_ENTITY_RELATION_PROPERTIES,
+  CronTrigger,
+} from 'src/engine/metadata-modules/cron-trigger/entities/cron-trigger.entity';
+import { FlatCronTrigger } from 'src/engine/metadata-modules/cron-trigger/types/flat-cron-trigger.type';
+import { WorkspaceFlatMapCache } from 'src/engine/workspace-flat-map-cache/decorators/workspace-flat-map-cache.decorator';
+import { WorkspaceFlatMapCacheService } from 'src/engine/workspace-flat-map-cache/services/workspace-flat-map-cache.service';
+
+@Injectable()
+@WorkspaceFlatMapCache('flatCronTriggerMaps')
+export class WorkspaceFlatCronTriggerMapCacheService extends WorkspaceFlatMapCacheService<
+  FlatEntityMaps<FlatCronTrigger>
+> {
+  constructor(
+    @InjectCacheStorage(CacheStorageNamespace.EngineWorkspace)
+    cacheStorageService: CacheStorageService,
+    @InjectRepository(CronTrigger)
+    private readonly cronTriggerRepository: Repository<CronTrigger>,
+  ) {
+    super(cacheStorageService);
+  }
+
+  protected async computeFlatMap({
+    workspaceId,
+  }: {
+    workspaceId: string;
+  }): Promise<FlatEntityMaps<FlatCronTrigger>> {
+    const cronTriggers = await this.cronTriggerRepository.find({
+      where: {
+        workspaceId,
+      },
+    });
+
+    const flatCronTriggerMaps = cronTriggers.reduce<
+      FlatEntityMaps<FlatCronTrigger>
+    >((flatEntityMaps, cronTrigger) => {
+      const flatCronTrigger = {
+        ...removePropertiesFromRecord(cronTrigger, [
+          ...CRON_TRIGGER_ENTITY_RELATION_PROPERTIES,
+        ]),
+        universalIdentifier: cronTrigger.universalIdentifier ?? cronTrigger.id,
+      } satisfies FlatCronTrigger;
+
+      return {
+        byId: {
+          ...flatEntityMaps.byId,
+          [flatCronTrigger.id]: flatCronTrigger,
+        },
+        idByUniversalIdentifier: {
+          ...flatEntityMaps.idByUniversalIdentifier,
+          [flatCronTrigger.universalIdentifier]: flatCronTrigger.id,
+        },
+      };
+    }, EMPTY_FLAT_ENTITY_MAPS);
+
+    return flatCronTriggerMaps;
+  }
+}

packages/twenty-server/src/engine/metadata-modules/cron-trigger/types/flat-cron-trigger-properties-to-compare.type.ts

@@ -0,0 +1,6 @@
+import { type FlatCronTrigger } from 'src/engine/metadata-modules/cron-trigger/types/flat-cron-trigger.type';
+
+export type FlatCronTriggerPropertiesToCompare = keyof Pick<
+  FlatCronTrigger,
+  'settings'
+>;

packages/twenty-server/src/engine/metadata-modules/cron-trigger/types/flat-cron-trigger.type.ts

@@ -0,0 +1,17 @@
+import { type Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { type CronTrigger } from 'src/engine/metadata-modules/cron-trigger/entities/cron-trigger.entity';
+import { type ServerlessFunctionEntity } from 'src/engine/metadata-modules/serverless-function/serverless-function.entity';
+import { type ExtractRecordTypeOrmRelationProperties } from 'src/engine/workspace-manager/workspace-migration-v2/types/extract-record-typeorm-relation-properties.type';
+
+export type CronTriggerEntityRelationProperties =
+  ExtractRecordTypeOrmRelationProperties<
+    CronTrigger,
+    ServerlessFunctionEntity | Workspace
+  >;
+
+export type FlatCronTrigger = Omit<
+  CronTrigger,
+  CronTriggerEntityRelationProperties
+> & {
+  universalIdentifier: string;
+};

packages/twenty-server/src/engine/metadata-modules/cron-trigger/utils/compare-two-flat-cron-trigger.util.ts

@@ -0,0 +1,69 @@
+import diff from 'microdiff';
+import { type FromTo } from 'twenty-shared/types';
+import { parseJson } from 'twenty-shared/utils';
+
+import { FLAT_CRON_TRIGGER_PROPERTIES_TO_COMPARE } from 'src/engine/metadata-modules/cron-trigger/constants/flat-cron-trigger-properties-to-compare.constant';
+import { type CronTriggerSettings } from 'src/engine/metadata-modules/cron-trigger/entities/cron-trigger.entity';
+import { type FlatCronTriggerPropertiesToCompare } from 'src/engine/metadata-modules/cron-trigger/types/flat-cron-trigger-properties-to-compare.type';
+import { type FlatCronTrigger } from 'src/engine/metadata-modules/cron-trigger/types/flat-cron-trigger.type';
+import { type UpdateCronTriggerAction } from 'src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/types/workspace-migration-cron-trigger-action-v2.type';
+import { transformMetadataForComparison } from 'src/engine/workspace-manager/workspace-sync-metadata/comparators/utils/transform-metadata-for-comparison.util';
+
+type GetWorkspaceMigrationUpdateCronTriggerActionArgs = FromTo<
+  FlatCronTrigger,
+  'FlatCronTrigger'
+>;
+
+export const compareTwoFlatCronTrigger = ({
+  fromFlatCronTrigger,
+  toFlatCronTrigger,
+}: GetWorkspaceMigrationUpdateCronTriggerActionArgs) => {
+  const transformMetadataForComparisonParameters = {
+    shouldIgnoreProperty: (property: string) =>
+      !FLAT_CRON_TRIGGER_PROPERTIES_TO_COMPARE.includes(
+        property as FlatCronTriggerPropertiesToCompare,
+      ),
+    propertiesToStringify: ['settings'] as const,
+  };
+  const fromCompare = transformMetadataForComparison(
+    fromFlatCronTrigger,
+    transformMetadataForComparisonParameters,
+  );
+  const toCompare = transformMetadataForComparison(
+    toFlatCronTrigger,
+    transformMetadataForComparisonParameters,
+  );
+
+  const flatCronTriggerDifferences = diff(fromCompare, toCompare);
+
+  return flatCronTriggerDifferences.flatMap<
+    UpdateCronTriggerAction['updates'][number]
+  >((difference) => {
+    switch (difference.type) {
+      case 'CHANGE': {
+        const { oldValue, path, value } = difference;
+        const property = path[0] as FlatCronTriggerPropertiesToCompare;
+
+        if (property === 'settings') {
+          return {
+            from: parseJson(oldValue) as CronTriggerSettings,
+            to: parseJson(value) as CronTriggerSettings,
+            property,
+          };
+        }
+
+        return {
+          from: oldValue,
+          to: value,
+          property,
+        };
+      }
+      case 'CREATE':
+      case 'REMOVE':
+      default: {
+        // Should never occurs, we should only provide null never undefined and so on
+        return [];
+      }
+    }
+  });
+};

packages/twenty-server/src/engine/metadata-modules/cron-trigger/utils/cron-trigger-graphql-api-exception-handler.util.ts

@@ -0,0 +1,23 @@
+import {
+  ConflictError,
+  NotFoundError,
+} from 'src/engine/core-modules/graphql/utils/graphql-errors.util';
+import {
+  CronTriggerException,
+  CronTriggerExceptionCode,
+} from 'src/engine/metadata-modules/cron-trigger/exceptions/cron-trigger.exception';
+
+export const cronTriggerGraphQLApiExceptionHandler = (error: Error): void => {
+  if (error instanceof CronTriggerException) {
+    switch (error.code) {
+      case CronTriggerExceptionCode.CRON_TRIGGER_NOT_FOUND:
+        throw new NotFoundError('Cron trigger not found');
+      case CronTriggerExceptionCode.CRON_TRIGGER_ALREADY_EXIST:
+        throw new ConflictError('Cron trigger already exists');
+      default:
+        throw error;
+    }
+  }
+
+  throw error;
+};

packages/twenty-server/src/engine/metadata-modules/cron-trigger/utils/cron-trigger-graphql-api-exception-handler.utils.ts

@@ -0,0 +1,9 @@
+import { CronTriggerException } from 'src/engine/metadata-modules/cron-trigger/exceptions/cron-trigger.exception';
+
+export const cronTriggerGraphqlApiExceptionHandler = (error: Error) => {
+  if (error instanceof CronTriggerException) {
+    throw error;
+  }
+
+  throw error;
+};

packages/twenty-server/src/engine/metadata-modules/cron-trigger/utils/from-create-cron-trigger-input-to-flat-cron-trigger.util.ts

@@ -0,0 +1,24 @@
+import { v4 as uuidv4 } from 'uuid';
+
+import { type CreateCronTriggerInput } from 'src/engine/metadata-modules/cron-trigger/dtos/create-cron-trigger.input';
+import { type FlatCronTrigger } from 'src/engine/metadata-modules/cron-trigger/types/flat-cron-trigger.type';
+
+export const fromCreateCronTriggerInputToFlatCronTrigger = ({
+  createCronTriggerInput,
+  workspaceId,
+}: {
+  createCronTriggerInput: CreateCronTriggerInput;
+  workspaceId: string;
+}): FlatCronTrigger => {
+  const now = new Date();
+
+  return {
+    id: uuidv4(),
+    universalIdentifier: uuidv4(),
+    settings: createCronTriggerInput.settings,
+    serverlessFunctionId: createCronTriggerInput.serverlessFunctionId,
+    workspaceId,
+    createdAt: now,
+    updatedAt: now,
+  };
+};

packages/twenty-server/src/engine/metadata-modules/cron-trigger/utils/from-update-cron-trigger-input-to-flat-cron-trigger-to-update-or-throw.util.ts

@@ -0,0 +1,31 @@
+import { type FlatEntityMaps } from 'src/engine/core-modules/common/types/flat-entity-maps.type';
+import { type UpdateCronTriggerInput } from 'src/engine/metadata-modules/cron-trigger/dtos/update-cron-trigger.input';
+import {
+  CronTriggerException,
+  CronTriggerExceptionCode,
+} from 'src/engine/metadata-modules/cron-trigger/exceptions/cron-trigger.exception';
+import { type FlatCronTrigger } from 'src/engine/metadata-modules/cron-trigger/types/flat-cron-trigger.type';
+
+export const fromUpdateCronTriggerInputToFlatCronTriggerToUpdateOrThrow = ({
+  flatCronTriggerMaps,
+  updateCronTriggerInput,
+}: {
+  flatCronTriggerMaps: FlatEntityMaps<FlatCronTrigger>;
+  updateCronTriggerInput: UpdateCronTriggerInput;
+}): FlatCronTrigger => {
+  const existingFlatCronTrigger =
+    flatCronTriggerMaps.byId[updateCronTriggerInput.id];
+
+  if (!existingFlatCronTrigger) {
+    throw new CronTriggerException(
+      'Cron trigger not found',
+      CronTriggerExceptionCode.CRON_TRIGGER_NOT_FOUND,
+    );
+  }
+
+  return {
+    ...existingFlatCronTrigger,
+    settings: updateCronTriggerInput.settings,
+    updatedAt: new Date(),
+  };
+};

packages/twenty-server/src/engine/metadata-modules/database-event-trigger/constants/flat-database-event-trigger-editable-properties.constant.ts

@@ -0,0 +1,5 @@
+import { type FlatDatabaseEventTrigger } from 'src/engine/metadata-modules/database-event-trigger/types/flat-database-event-trigger.type';
+
+export const FLAT_DATABASE_EVENT_TRIGGER_EDITABLE_PROPERTIES = [
+  'settings',
+] as const satisfies (keyof FlatDatabaseEventTrigger)[];

packages/twenty-server/src/engine/metadata-modules/database-event-trigger/constants/flat-database-event-trigger-properties-to-compare.constant.ts

@@ -0,0 +1,6 @@
+import { FLAT_DATABASE_EVENT_TRIGGER_EDITABLE_PROPERTIES } from 'src/engine/metadata-modules/database-event-trigger/constants/flat-database-event-trigger-editable-properties.constant';
+import { type FlatDatabaseEventTrigger } from 'src/engine/metadata-modules/database-event-trigger/types/flat-database-event-trigger.type';
+
+export const FLAT_DATABASE_EVENT_TRIGGER_PROPERTIES_TO_COMPARE = [
+  ...FLAT_DATABASE_EVENT_TRIGGER_EDITABLE_PROPERTIES,
+] as const satisfies (keyof FlatDatabaseEventTrigger)[];

packages/twenty-server/src/engine/metadata-modules/database-event-trigger/database-event-trigger.module.ts

@@ -0,0 +1,27 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { WorkspaceManyOrAllFlatEntityMapsCacheModule } from 'src/engine/core-modules/common/services/workspace-many-or-all-flat-entity-maps-cache.module';
+import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { DatabaseEventTrigger } from 'src/engine/metadata-modules/database-event-trigger/entities/database-event-trigger.entity';
+import { CallDatabaseEventTriggerJobsJob } from 'src/engine/metadata-modules/database-event-trigger/jobs/call-database-event-trigger-jobs.job';
+import { DatabaseEventTriggerResolver } from 'src/engine/metadata-modules/database-event-trigger/resolvers/database-event-trigger.resolver';
+import { DatabaseEventTriggerV2Service } from 'src/engine/metadata-modules/database-event-trigger/services/database-event-trigger-v2.service';
+import { WorkspaceFlatDatabaseEventTriggerMapCacheService } from 'src/engine/metadata-modules/database-event-trigger/services/workspace-flat-database-event-trigger-map-cache.service';
+import { WorkspaceMigrationV2Module } from 'src/engine/workspace-manager/workspace-migration-v2/workspace-migration-v2.module';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([Workspace, DatabaseEventTrigger]),
+    WorkspaceManyOrAllFlatEntityMapsCacheModule,
+    WorkspaceMigrationV2Module,
+  ],
+  providers: [
+    CallDatabaseEventTriggerJobsJob,
+    DatabaseEventTriggerV2Service,
+    DatabaseEventTriggerResolver,
+    WorkspaceFlatDatabaseEventTriggerMapCacheService,
+  ],
+  exports: [DatabaseEventTriggerV2Service],
+})
+export class DatabaseEventTriggerModule {}

packages/twenty-server/src/engine/metadata-modules/database-event-trigger/dtos/create-database-event-trigger.input.ts

@@ -0,0 +1,19 @@
+import { Field, InputType } from '@nestjs/graphql';
+
+import { IsNotEmpty, IsObject, IsUUID } from 'class-validator';
+import GraphQLJSON from 'graphql-type-json';
+
+import { DatabaseEventTriggerSettings } from 'src/engine/metadata-modules/database-event-trigger/entities/database-event-trigger.entity';
+
+@InputType()
+export class CreateDatabaseEventTriggerInput {
+  @IsObject()
+  @IsNotEmpty()
+  @Field(() => GraphQLJSON)
+  settings: DatabaseEventTriggerSettings;
+
+  @IsUUID()
+  @IsNotEmpty()
+  @Field()
+  serverlessFunctionId: string;
+}

packages/twenty-server/src/engine/metadata-modules/database-event-trigger/dtos/database-event-trigger-id.input.ts

@@ -0,0 +1,11 @@
+import { Field, InputType } from '@nestjs/graphql';
+
+import { IsNotEmpty, IsUUID } from 'class-validator';
+
+@InputType()
+export class DatabaseEventTriggerIdInput {
+  @IsUUID()
+  @IsNotEmpty()
+  @Field()
+  id: string;
+}

packages/twenty-server/src/engine/metadata-modules/database-event-trigger/dtos/database-event-trigger.dto.ts

@@ -0,0 +1,35 @@
+import { Field, HideField, ObjectType } from '@nestjs/graphql';
+
+import { IDField } from '@ptc-org/nestjs-query-graphql';
+import { IsDateString, IsNotEmpty, IsObject, IsUUID } from 'class-validator';
+import GraphQLJSON from 'graphql-type-json';
+
+import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+import { DatabaseEventTriggerSettings } from 'src/engine/metadata-modules/database-event-trigger/entities/database-event-trigger.entity';
+
+@ObjectType('DatabaseEventTrigger')
+export class DatabaseEventTriggerDTO {
+  @IsUUID()
+  @IsNotEmpty()
+  @IDField(() => UUIDScalarType)
+  id: string;
+
+  @IsObject()
+  @Field(() => GraphQLJSON)
+  settings: DatabaseEventTriggerSettings;
+
+  @HideField()
+  workspaceId: string;
+
+  @IsUUID()
+  @Field()
+  serverlessFunctionId: string;
+
+  @IsDateString()
+  @Field()
+  createdAt: Date;
+
+  @IsDateString()
+  @Field()
+  updatedAt: Date;
+}

packages/twenty-server/src/engine/metadata-modules/database-event-trigger/dtos/update-database-event-trigger.input.ts

@@ -0,0 +1,19 @@
+import { Field, InputType } from '@nestjs/graphql';
+
+import { IsNotEmpty, IsObject, IsUUID } from 'class-validator';
+import GraphQLJSON from 'graphql-type-json';
+
+import { DatabaseEventTriggerSettings } from 'src/engine/metadata-modules/database-event-trigger/entities/database-event-trigger.entity';
+
+@InputType()
+export class UpdateDatabaseEventTriggerInput {
+  @IsUUID()
+  @IsNotEmpty()
+  @Field()
+  id: string;
+
+  @IsObject()
+  @IsNotEmpty()
+  @Field(() => GraphQLJSON)
+  settings: DatabaseEventTriggerSettings;
+}

packages/twenty-server/src/engine/metadata-modules/database-event-trigger/entities/database-event-trigger.entity.ts

@@ -2,25 +2,33 @@ import {
   Column,
   CreateDateColumn,
   Entity,
+  Index,
   JoinColumn,
   ManyToOne,
   PrimaryGeneratedColumn,
-  UpdateDateColumn,
   Relation,
-  Index,
+  UpdateDateColumn,
 } from 'typeorm';
 
 import { SyncableEntity } from 'src/engine/workspace-manager/workspace-sync/interfaces/syncable-entity.interface';
 
+import { DatabaseEventTriggerEntityRelationProperties } from 'src/engine/metadata-modules/database-event-trigger/types/flat-database-event-trigger.type';
 import { ServerlessFunctionEntity } from 'src/engine/metadata-modules/serverless-function/serverless-function.entity';
 
 export type DatabaseEventTriggerSettings = {
   eventName: string;
 };
 
-@Entity({ name: 'databaseEventTrigger', schema: 'core' })
+export const DATABASE_EVENT_TRIGGER_ENTITY_RELATION_PROPERTIES = [
+  'serverlessFunction',
+] as const satisfies readonly DatabaseEventTriggerEntityRelationProperties[];
+
+@Entity('databaseEventTrigger')
 @Index('IDX_DATABASE_EVENT_TRIGGER_WORKSPACE_ID', ['workspaceId'])
-export class DatabaseEventTrigger extends SyncableEntity {
+export class DatabaseEventTrigger
+  extends SyncableEntity
+  implements Required<DatabaseEventTrigger>
+{
   @PrimaryGeneratedColumn('uuid')
   id: string;
 
@@ -35,6 +43,9 @@ export class DatabaseEventTrigger extends SyncableEntity {
   @JoinColumn({ name: 'serverlessFunctionId' })
   serverlessFunction: Relation<ServerlessFunctionEntity>;
 
+  @Column({ nullable: true, type: 'uuid' })
+  serverlessFunctionId: string | null;
+
   @Column({ nullable: false, type: 'uuid' })
   workspaceId: string;
 

packages/twenty-server/src/engine/metadata-modules/database-event-trigger/exceptions/database-event-trigger.exception.ts

@@ -0,0 +1,12 @@
+import { CustomException } from 'src/utils/custom-exception';
+
+export class DatabaseEventTriggerException extends CustomException {
+  constructor(message: string, code: DatabaseEventTriggerExceptionCode) {
+    super(message, code);
+  }
+}
+
+export enum DatabaseEventTriggerExceptionCode {
+  DATABASE_EVENT_TRIGGER_NOT_FOUND = 'DATABASE_EVENT_TRIGGER_NOT_FOUND',
+  DATABASE_EVENT_TRIGGER_ALREADY_EXIST = 'DATABASE_EVENT_TRIGGER_ALREADY_EXIST',
+}

packages/twenty-server/src/engine/metadata-modules/database-event-trigger/jobs/call-database-event-trigger-jobs.job.ts

@@ -2,18 +2,18 @@ import { InjectRepository } from '@nestjs/typeorm';
 
 import { Repository } from 'typeorm';
 
+import type { ObjectRecordEvent } from 'src/engine/core-modules/event-emitter/types/object-record-event.event';
+import { InjectMessageQueue } from 'src/engine/core-modules/message-queue/decorators/message-queue.decorator';
 import { Process } from 'src/engine/core-modules/message-queue/decorators/process.decorator';
 import { Processor } from 'src/engine/core-modules/message-queue/decorators/processor.decorator';
 import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
-import { WorkspaceEventBatch } from 'src/engine/workspace-event-emitter/types/workspace-event.type';
-import type { ObjectRecordEvent } from 'src/engine/core-modules/event-emitter/types/object-record-event.event';
-import { DatabaseEventTrigger } from 'src/engine/metadata-modules/trigger/entities/database-event-trigger.entity';
+import { MessageQueueService } from 'src/engine/core-modules/message-queue/services/message-queue.service';
+import { DatabaseEventTrigger } from 'src/engine/metadata-modules/database-event-trigger/entities/database-event-trigger.entity';
 import {
   ServerlessFunctionTriggerJob,
   ServerlessFunctionTriggerJobData,
 } from 'src/engine/metadata-modules/serverless-function/jobs/serverless-function-trigger.job';
-import { InjectMessageQueue } from 'src/engine/core-modules/message-queue/decorators/message-queue.decorator';
-import { MessageQueueService } from 'src/engine/core-modules/message-queue/services/message-queue.service';
+import { WorkspaceEventBatch } from 'src/engine/workspace-event-emitter/types/workspace-event.type';
 
 @Processor(MessageQueue.triggerQueue)
 export class CallDatabaseEventTriggerJobsJob {

packages/twenty-server/src/engine/metadata-modules/database-event-trigger/resolvers/database-event-trigger.resolver.ts

@@ -0,0 +1,107 @@
+import { UseFilters, UseGuards, UsePipes } from '@nestjs/common';
+import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { Repository } from 'typeorm';
+
+import { PreventNestToAutoLogGraphqlErrorsFilter } from 'src/engine/core-modules/graphql/filters/prevent-nest-to-auto-log-graphql-errors.filter';
+import { ResolverValidationPipe } from 'src/engine/core-modules/graphql/pipes/resolver-validation.pipe';
+import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
+import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.guard';
+import { CreateDatabaseEventTriggerInput } from 'src/engine/metadata-modules/database-event-trigger/dtos/create-database-event-trigger.input';
+import { DatabaseEventTriggerIdInput } from 'src/engine/metadata-modules/database-event-trigger/dtos/database-event-trigger-id.input';
+import { DatabaseEventTriggerDTO } from 'src/engine/metadata-modules/database-event-trigger/dtos/database-event-trigger.dto';
+import { UpdateDatabaseEventTriggerInput } from 'src/engine/metadata-modules/database-event-trigger/dtos/update-database-event-trigger.input';
+import { DatabaseEventTrigger } from 'src/engine/metadata-modules/database-event-trigger/entities/database-event-trigger.entity';
+import { DatabaseEventTriggerV2Service } from 'src/engine/metadata-modules/database-event-trigger/services/database-event-trigger-v2.service';
+import { databaseEventTriggerGraphQLApiExceptionHandler } from 'src/engine/metadata-modules/database-event-trigger/utils/database-event-trigger-graphql-api-exception-handler.utils';
+
+@UseGuards(WorkspaceAuthGuard)
+@Resolver()
+@UsePipes(ResolverValidationPipe)
+@UseFilters(PreventNestToAutoLogGraphqlErrorsFilter)
+export class DatabaseEventTriggerResolver {
+  constructor(
+    private readonly databaseEventTriggerV2Service: DatabaseEventTriggerV2Service,
+    @InjectRepository(DatabaseEventTrigger)
+    private readonly databaseEventTriggerRepository: Repository<DatabaseEventTrigger>,
+  ) {}
+
+  @Query(() => DatabaseEventTriggerDTO)
+  async findOneDatabaseEventTrigger(
+    @Args('input') { id }: DatabaseEventTriggerIdInput,
+    @AuthWorkspace() { id: workspaceId }: Workspace,
+  ) {
+    try {
+      return await this.databaseEventTriggerRepository.findOneOrFail({
+        where: {
+          id,
+          workspaceId,
+        },
+      });
+    } catch (error) {
+      databaseEventTriggerGraphQLApiExceptionHandler(error);
+    }
+  }
+
+  @Query(() => [DatabaseEventTriggerDTO])
+  async findManyDatabaseEventTriggers(
+    @AuthWorkspace() { id: workspaceId }: Workspace,
+  ) {
+    try {
+      return await this.databaseEventTriggerRepository.find({
+        where: { workspaceId },
+      });
+    } catch (error) {
+      databaseEventTriggerGraphQLApiExceptionHandler(error);
+    }
+  }
+
+  @Mutation(() => DatabaseEventTriggerDTO)
+  async deleteOneDatabaseEventTrigger(
+    @Args('input') input: DatabaseEventTriggerIdInput,
+    @AuthWorkspace() { id: workspaceId }: Workspace,
+  ) {
+    try {
+      return await this.databaseEventTriggerV2Service.destroyOne({
+        destroyDatabaseEventTriggerInput: input,
+        workspaceId,
+      });
+    } catch (error) {
+      databaseEventTriggerGraphQLApiExceptionHandler(error);
+    }
+  }
+
+  @Mutation(() => DatabaseEventTriggerDTO)
+  async updateOneDatabaseEventTrigger(
+    @Args('input')
+    input: UpdateDatabaseEventTriggerInput,
+    @AuthWorkspace() { id: workspaceId }: Workspace,
+  ) {
+    try {
+      return await this.databaseEventTriggerV2Service.updateOne(
+        input,
+        workspaceId,
+      );
+    } catch (error) {
+      databaseEventTriggerGraphQLApiExceptionHandler(error);
+    }
+  }
+
+  @Mutation(() => DatabaseEventTriggerDTO)
+  async createOneDatabaseEventTrigger(
+    @Args('input')
+    input: CreateDatabaseEventTriggerInput,
+    @AuthWorkspace() { id: workspaceId }: Workspace,
+  ) {
+    try {
+      return await this.databaseEventTriggerV2Service.createOne(
+        input,
+        workspaceId,
+      );
+    } catch (error) {
+      databaseEventTriggerGraphQLApiExceptionHandler(error);
+    }
+  }
+}

packages/twenty-server/src/engine/metadata-modules/database-event-trigger/services/database-event-trigger-v2.service.ts

@@ -0,0 +1,239 @@
+import { Injectable } from '@nestjs/common';
+
+import { isDefined } from 'twenty-shared/utils';
+
+import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/core-modules/common/services/workspace-many-or-all-flat-entity-maps-cache.service.';
+import { addFlatEntityToFlatEntityMapsOrThrow } from 'src/engine/core-modules/common/utils/add-flat-entity-to-flat-entity-maps-or-throw.util';
+import { deleteFlatEntityFromFlatEntityMapsOrThrow } from 'src/engine/core-modules/common/utils/delete-flat-entity-from-flat-entity-maps-or-throw.util';
+import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/core-modules/common/utils/find-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
+import { getSubFlatEntityMapsOrThrow } from 'src/engine/core-modules/common/utils/get-sub-flat-entity-maps-or-throw.util';
+import { replaceFlatEntityInFlatEntityMapsOrThrow } from 'src/engine/core-modules/common/utils/replace-flat-entity-in-flat-entity-maps-or-throw.util';
+import { CreateDatabaseEventTriggerInput } from 'src/engine/metadata-modules/database-event-trigger/dtos/create-database-event-trigger.input';
+import { DatabaseEventTriggerIdInput } from 'src/engine/metadata-modules/database-event-trigger/dtos/database-event-trigger-id.input';
+import { UpdateDatabaseEventTriggerInput } from 'src/engine/metadata-modules/database-event-trigger/dtos/update-database-event-trigger.input';
+import {
+  DatabaseEventTriggerException,
+  DatabaseEventTriggerExceptionCode,
+} from 'src/engine/metadata-modules/database-event-trigger/exceptions/database-event-trigger.exception';
+import { FlatDatabaseEventTrigger } from 'src/engine/metadata-modules/database-event-trigger/types/flat-database-event-trigger.type';
+import { fromCreateDatabaseEventTriggerInputToFlatDatabaseEventTrigger } from 'src/engine/metadata-modules/database-event-trigger/utils/from-create-database-event-trigger-input-to-flat-database-event-trigger.util';
+import { fromUpdateDatabaseEventTriggerInputToFlatDatabaseEventTriggerToUpdateOrThrow } from 'src/engine/metadata-modules/database-event-trigger/utils/from-update-database-event-trigger-input-to-flat-database-event-trigger-to-update-or-throw.util';
+import { WorkspaceMigrationBuilderExceptionV2 } from 'src/engine/workspace-manager/workspace-migration-v2/exceptions/workspace-migration-builder-exception-v2';
+import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration-v2/services/workspace-migration-validate-build-and-run-service';
+
+@Injectable()
+export class DatabaseEventTriggerV2Service {
+  constructor(
+    private readonly flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
+    private readonly workspaceMigrationValidateBuildAndRunService: WorkspaceMigrationValidateBuildAndRunService,
+  ) {}
+
+  async createOne(
+    databaseEventTriggerInput: CreateDatabaseEventTriggerInput,
+    workspaceId: string,
+  ) {
+    const flatEntityMaps =
+      await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+        {
+          workspaceId,
+          flatEntities: ['flatDatabaseEventTriggerMaps'],
+        },
+      );
+
+    const existingFlatDatabaseEventTriggerMaps =
+      flatEntityMaps.flatDatabaseEventTriggerMaps;
+
+    const flatDatabaseEventTriggerToCreate =
+      fromCreateDatabaseEventTriggerInputToFlatDatabaseEventTrigger({
+        createDatabaseEventTriggerInput: databaseEventTriggerInput,
+        workspaceId,
+      });
+
+    const toFlatDatabaseEventTriggerMaps = addFlatEntityToFlatEntityMapsOrThrow(
+      {
+        flatEntity: flatDatabaseEventTriggerToCreate,
+        flatEntityMaps: existingFlatDatabaseEventTriggerMaps,
+      },
+    );
+
+    const validateAndBuildResult =
+      await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(
+        {
+          workspaceId,
+          fromToAllFlatEntityMaps: {
+            flatDatabaseEventTriggerMaps: {
+              from: existingFlatDatabaseEventTriggerMaps,
+              to: toFlatDatabaseEventTriggerMaps,
+            },
+          },
+          buildOptions: {
+            isSystemBuild: false,
+            inferDeletionFromMissingEntities: false,
+          },
+        },
+      );
+
+    if (isDefined(validateAndBuildResult)) {
+      throw new WorkspaceMigrationBuilderExceptionV2(
+        validateAndBuildResult,
+        'Multiple validation errors occurred while creating database event trigger',
+      );
+    }
+
+    const {
+      flatDatabaseEventTriggerMaps:
+        recomputedExistingFlatDatabaseEventTriggerMaps,
+    } =
+      await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+        {
+          workspaceId,
+          flatEntities: ['flatDatabaseEventTriggerMaps'],
+        },
+      );
+
+    return findFlatEntityByIdInFlatEntityMapsOrThrow({
+      flatEntityId: flatDatabaseEventTriggerToCreate.id,
+      flatEntityMaps: recomputedExistingFlatDatabaseEventTriggerMaps,
+    });
+  }
+
+  async updateOne(
+    databaseEventTriggerInput: UpdateDatabaseEventTriggerInput,
+    workspaceId: string,
+  ) {
+    const flatEntityMaps =
+      await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+        {
+          workspaceId,
+          flatEntities: ['flatDatabaseEventTriggerMaps'],
+        },
+      );
+
+    const existingFlatDatabaseEventTriggerMaps =
+      flatEntityMaps.flatDatabaseEventTriggerMaps;
+
+    const optimisticallyUpdatedFlatDatabaseEventTrigger =
+      fromUpdateDatabaseEventTriggerInputToFlatDatabaseEventTriggerToUpdateOrThrow(
+        {
+          flatDatabaseEventTriggerMaps: existingFlatDatabaseEventTriggerMaps,
+          updateDatabaseEventTriggerInput: databaseEventTriggerInput,
+        },
+      );
+
+    const fromFlatDatabaseEventTriggerMaps = getSubFlatEntityMapsOrThrow({
+      flatEntityIds: [optimisticallyUpdatedFlatDatabaseEventTrigger.id],
+      flatEntityMaps: existingFlatDatabaseEventTriggerMaps,
+    });
+    const toFlatDatabaseEventTriggerMaps =
+      replaceFlatEntityInFlatEntityMapsOrThrow({
+        flatEntity: optimisticallyUpdatedFlatDatabaseEventTrigger,
+        flatEntityMaps: fromFlatDatabaseEventTriggerMaps,
+      });
+
+    const validateAndBuildResult =
+      await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(
+        {
+          workspaceId,
+          fromToAllFlatEntityMaps: {
+            flatDatabaseEventTriggerMaps: {
+              from: existingFlatDatabaseEventTriggerMaps,
+              to: toFlatDatabaseEventTriggerMaps,
+            },
+          },
+          buildOptions: {
+            isSystemBuild: false,
+            inferDeletionFromMissingEntities: false,
+          },
+        },
+      );
+
+    if (isDefined(validateAndBuildResult)) {
+      throw new WorkspaceMigrationBuilderExceptionV2(
+        validateAndBuildResult,
+        'Multiple validation errors occurred while updating database event trigger',
+      );
+    }
+
+    const {
+      flatDatabaseEventTriggerMaps:
+        recomputedExistingFlatDatabaseEventTriggerMaps,
+    } =
+      await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+        {
+          workspaceId,
+          flatEntities: ['flatDatabaseEventTriggerMaps'],
+        },
+      );
+
+    return findFlatEntityByIdInFlatEntityMapsOrThrow({
+      flatEntityId: optimisticallyUpdatedFlatDatabaseEventTrigger.id,
+      flatEntityMaps: recomputedExistingFlatDatabaseEventTriggerMaps,
+    });
+  }
+
+  async destroyOne({
+    destroyDatabaseEventTriggerInput,
+    workspaceId,
+  }: {
+    destroyDatabaseEventTriggerInput: DatabaseEventTriggerIdInput;
+    workspaceId: string;
+  }): Promise<FlatDatabaseEventTrigger> {
+    const {
+      flatDatabaseEventTriggerMaps: existingFlatDatabaseEventTriggerMaps,
+    } =
+      await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+        {
+          workspaceId,
+          flatEntities: ['flatDatabaseEventTriggerMaps'],
+        },
+      );
+
+    const existingFlatDatabaseEventTrigger =
+      existingFlatDatabaseEventTriggerMaps.byId[
+        destroyDatabaseEventTriggerInput.id
+      ];
+
+    if (!isDefined(existingFlatDatabaseEventTrigger)) {
+      throw new DatabaseEventTriggerException(
+        'Database event trigger to destroy not found',
+        DatabaseEventTriggerExceptionCode.DATABASE_EVENT_TRIGGER_NOT_FOUND,
+      );
+    }
+
+    const fromFlatDatabaseEventTriggerMaps = getSubFlatEntityMapsOrThrow({
+      flatEntityIds: [existingFlatDatabaseEventTrigger.id],
+      flatEntityMaps: existingFlatDatabaseEventTriggerMaps,
+    });
+    const toFlatDatabaseEventTriggerMaps =
+      deleteFlatEntityFromFlatEntityMapsOrThrow({
+        flatEntityMaps: fromFlatDatabaseEventTriggerMaps,
+        entityToDeleteId: existingFlatDatabaseEventTrigger.id,
+      });
+
+    const validateAndBuildResult =
+      await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(
+        {
+          fromToAllFlatEntityMaps: {
+            flatDatabaseEventTriggerMaps: {
+              from: fromFlatDatabaseEventTriggerMaps,
+              to: toFlatDatabaseEventTriggerMaps,
+            },
+          },
+          buildOptions: {
+            isSystemBuild: false,
+            inferDeletionFromMissingEntities: true,
+          },
+          workspaceId,
+        },
+      );
+
+    if (isDefined(validateAndBuildResult)) {
+      throw new WorkspaceMigrationBuilderExceptionV2(
+        validateAndBuildResult,
+        'Multiple validation errors occurred while destroying database event trigger',
+      );
+    }
+
+    return existingFlatDatabaseEventTrigger;
+  }
+}

packages/twenty-server/src/engine/metadata-modules/database-event-trigger/services/workspace-flat-database-event-trigger-map-cache.service.ts

@@ -0,0 +1,71 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { removePropertiesFromRecord } from 'twenty-shared/utils';
+import { Repository } from 'typeorm';
+
+import { InjectCacheStorage } from 'src/engine/core-modules/cache-storage/decorators/cache-storage.decorator';
+import { CacheStorageService } from 'src/engine/core-modules/cache-storage/services/cache-storage.service';
+import { CacheStorageNamespace } from 'src/engine/core-modules/cache-storage/types/cache-storage-namespace.enum';
+import { EMPTY_FLAT_ENTITY_MAPS } from 'src/engine/core-modules/common/constant/empty-flat-entity-maps.constant';
+import { FlatEntityMaps } from 'src/engine/core-modules/common/types/flat-entity-maps.type';
+import {
+  DATABASE_EVENT_TRIGGER_ENTITY_RELATION_PROPERTIES,
+  DatabaseEventTrigger,
+} from 'src/engine/metadata-modules/database-event-trigger/entities/database-event-trigger.entity';
+import { FlatDatabaseEventTrigger } from 'src/engine/metadata-modules/database-event-trigger/types/flat-database-event-trigger.type';
+import { WorkspaceFlatMapCache } from 'src/engine/workspace-flat-map-cache/decorators/workspace-flat-map-cache.decorator';
+import { WorkspaceFlatMapCacheService } from 'src/engine/workspace-flat-map-cache/services/workspace-flat-map-cache.service';
+
+@Injectable()
+@WorkspaceFlatMapCache('flatDatabaseEventTriggerMaps')
+export class WorkspaceFlatDatabaseEventTriggerMapCacheService extends WorkspaceFlatMapCacheService<
+  FlatEntityMaps<FlatDatabaseEventTrigger>
+> {
+  constructor(
+    @InjectCacheStorage(CacheStorageNamespace.EngineWorkspace)
+    cacheStorageService: CacheStorageService,
+    @InjectRepository(DatabaseEventTrigger)
+    private readonly databaseEventTriggerRepository: Repository<DatabaseEventTrigger>,
+  ) {
+    super(cacheStorageService);
+  }
+
+  protected async computeFlatMap({
+    workspaceId,
+  }: {
+    workspaceId: string;
+  }): Promise<FlatEntityMaps<FlatDatabaseEventTrigger>> {
+    const databaseEventTriggers =
+      await this.databaseEventTriggerRepository.find({
+        where: {
+          workspaceId,
+        },
+      });
+
+    const flatDatabaseEventTriggerMaps = databaseEventTriggers.reduce<
+      FlatEntityMaps<FlatDatabaseEventTrigger>
+    >((flatEntityMaps, databaseEventTrigger) => {
+      const flatDatabaseEventTrigger = {
+        ...removePropertiesFromRecord(databaseEventTrigger, [
+          ...DATABASE_EVENT_TRIGGER_ENTITY_RELATION_PROPERTIES,
+        ]),
+        universalIdentifier: databaseEventTrigger.universalIdentifier ?? '',
+      } satisfies FlatDatabaseEventTrigger;
+
+      return {
+        byId: {
+          ...flatEntityMaps.byId,
+          [flatDatabaseEventTrigger.id]: flatDatabaseEventTrigger,
+        },
+        idByUniversalIdentifier: {
+          ...flatEntityMaps.idByUniversalIdentifier,
+          [flatDatabaseEventTrigger.universalIdentifier]:
+            flatDatabaseEventTrigger.id,
+        },
+      };
+    }, EMPTY_FLAT_ENTITY_MAPS);
+
+    return flatDatabaseEventTriggerMaps;
+  }
+}

packages/twenty-server/src/engine/metadata-modules/database-event-trigger/types/flat-database-event-trigger-properties-to-compare.type.ts

@@ -0,0 +1,4 @@
+import { type FLAT_DATABASE_EVENT_TRIGGER_PROPERTIES_TO_COMPARE } from 'src/engine/metadata-modules/database-event-trigger/constants/flat-database-event-trigger-properties-to-compare.constant';
+
+export type FlatDatabaseEventTriggerPropertiesToCompare =
+  (typeof FLAT_DATABASE_EVENT_TRIGGER_PROPERTIES_TO_COMPARE)[number];

packages/twenty-server/src/engine/metadata-modules/database-event-trigger/types/flat-database-event-trigger.type.ts

@@ -0,0 +1,17 @@
+import { type Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { type DatabaseEventTrigger } from 'src/engine/metadata-modules/database-event-trigger/entities/database-event-trigger.entity';
+import { type ServerlessFunctionEntity } from 'src/engine/metadata-modules/serverless-function/serverless-function.entity';
+import { type ExtractRecordTypeOrmRelationProperties } from 'src/engine/workspace-manager/workspace-migration-v2/types/extract-record-typeorm-relation-properties.type';
+
+export type DatabaseEventTriggerEntityRelationProperties =
+  ExtractRecordTypeOrmRelationProperties<
+    DatabaseEventTrigger,
+    ServerlessFunctionEntity | Workspace
+  >;
+
+export type FlatDatabaseEventTrigger = Omit<
+  DatabaseEventTrigger,
+  DatabaseEventTriggerEntityRelationProperties
+> & {
+  universalIdentifier: string;
+};

packages/twenty-server/src/engine/metadata-modules/database-event-trigger/utils/compare-two-flat-database-event-trigger.util.ts

@@ -0,0 +1,69 @@
+import diff from 'microdiff';
+import { type FromTo } from 'twenty-shared/types';
+import { parseJson } from 'twenty-shared/utils';
+
+import { FLAT_DATABASE_EVENT_TRIGGER_PROPERTIES_TO_COMPARE } from 'src/engine/metadata-modules/database-event-trigger/constants/flat-database-event-trigger-properties-to-compare.constant';
+import { type DatabaseEventTriggerSettings } from 'src/engine/metadata-modules/database-event-trigger/entities/database-event-trigger.entity';
+import { type FlatDatabaseEventTriggerPropertiesToCompare } from 'src/engine/metadata-modules/database-event-trigger/types/flat-database-event-trigger-properties-to-compare.type';
+import { type FlatDatabaseEventTrigger } from 'src/engine/metadata-modules/database-event-trigger/types/flat-database-event-trigger.type';
+import { type UpdateDatabaseEventTriggerAction } from 'src/engine/workspace-manager/workspace-migration-v2/workspace-migration-builder-v2/types/workspace-migration-database-event-trigger-action-v2.type';
+import { transformMetadataForComparison } from 'src/engine/workspace-manager/workspace-sync-metadata/comparators/utils/transform-metadata-for-comparison.util';
+
+type GetWorkspaceMigrationUpdateDatabaseEventTriggerActionArgs = FromTo<
+  FlatDatabaseEventTrigger,
+  'FlatDatabaseEventTrigger'
+>;
+
+export const compareTwoFlatDatabaseEventTrigger = ({
+  fromFlatDatabaseEventTrigger,
+  toFlatDatabaseEventTrigger,
+}: GetWorkspaceMigrationUpdateDatabaseEventTriggerActionArgs) => {
+  const transformMetadataForComparisonParameters = {
+    shouldIgnoreProperty: (property: string) =>
+      !FLAT_DATABASE_EVENT_TRIGGER_PROPERTIES_TO_COMPARE.includes(
+        property as FlatDatabaseEventTriggerPropertiesToCompare,
+      ),
+    propertiesToStringify: ['settings'] as const,
+  };
+  const fromCompare = transformMetadataForComparison(
+    fromFlatDatabaseEventTrigger,
+    transformMetadataForComparisonParameters,
+  );
+  const toCompare = transformMetadataForComparison(
+    toFlatDatabaseEventTrigger,
+    transformMetadataForComparisonParameters,
+  );
+
+  const flatDatabaseEventTriggerDifferences = diff(fromCompare, toCompare);
+
+  return flatDatabaseEventTriggerDifferences.flatMap<
+    UpdateDatabaseEventTriggerAction['updates'][number]
+  >((difference) => {
+    switch (difference.type) {
+      case 'CHANGE': {
+        const { oldValue, path, value } = difference;
+        const property = path[0] as FlatDatabaseEventTriggerPropertiesToCompare;
+
+        if (property === 'settings') {
+          return {
+            from: parseJson(oldValue) as DatabaseEventTriggerSettings,
+            to: parseJson(value) as DatabaseEventTriggerSettings,
+            property,
+          };
+        }
+
+        return {
+          from: oldValue,
+          to: value,
+          property,
+        };
+      }
+      case 'CREATE':
+      case 'REMOVE':
+      default: {
+        // Should never occurs, we should only provide null never undefined and so on
+        return [];
+      }
+    }
+  });
+};

packages/twenty-server/src/engine/metadata-modules/database-event-trigger/utils/database-event-trigger-graphql-api-exception-handler.utils.ts

@@ -0,0 +1,25 @@
+import {
+  ConflictError,
+  NotFoundError,
+} from 'src/engine/core-modules/graphql/utils/graphql-errors.util';
+import {
+  DatabaseEventTriggerException,
+  DatabaseEventTriggerExceptionCode,
+} from 'src/engine/metadata-modules/database-event-trigger/exceptions/database-event-trigger.exception';
+
+export const databaseEventTriggerGraphQLApiExceptionHandler = (
+  error: Error,
+): void => {
+  if (error instanceof DatabaseEventTriggerException) {
+    switch (error.code) {
+      case DatabaseEventTriggerExceptionCode.DATABASE_EVENT_TRIGGER_NOT_FOUND:
+        throw new NotFoundError('Database event trigger not found');
+      case DatabaseEventTriggerExceptionCode.DATABASE_EVENT_TRIGGER_ALREADY_EXIST:
+        throw new ConflictError('Database event trigger already exists');
+      default:
+        throw error;
+    }
+  }
+
+  throw error;
+};

packages/twenty-server/src/engine/metadata-modules/database-event-trigger/utils/from-create-database-event-trigger-input-to-flat-database-event-trigger.util.ts

@@ -0,0 +1,24 @@
+import { v4 as uuidV4 } from 'uuid';
+
+import { type CreateDatabaseEventTriggerInput } from 'src/engine/metadata-modules/database-event-trigger/dtos/create-database-event-trigger.input';
+import { type FlatDatabaseEventTrigger } from 'src/engine/metadata-modules/database-event-trigger/types/flat-database-event-trigger.type';
+
+export const fromCreateDatabaseEventTriggerInputToFlatDatabaseEventTrigger = ({
+  createDatabaseEventTriggerInput,
+  workspaceId,
+}: {
+  createDatabaseEventTriggerInput: CreateDatabaseEventTriggerInput;
+  workspaceId: string;
+}): FlatDatabaseEventTrigger => {
+  const now = new Date();
+
+  return {
+    id: uuidV4(),
+    universalIdentifier: uuidV4(),
+    settings: createDatabaseEventTriggerInput.settings,
+    serverlessFunctionId: createDatabaseEventTriggerInput.serverlessFunctionId,
+    workspaceId,
+    createdAt: now,
+    updatedAt: now,
+  };
+};

packages/twenty-server/src/engine/metadata-modules/database-event-trigger/utils/from-update-database-event-trigger-input-to-flat-database-event-trigger-to-update-or-throw.util.ts

@@ -0,0 +1,32 @@
+import { type FlatEntityMaps } from 'src/engine/core-modules/common/types/flat-entity-maps.type';
+import { type UpdateDatabaseEventTriggerInput } from 'src/engine/metadata-modules/database-event-trigger/dtos/update-database-event-trigger.input';
+import {
+  DatabaseEventTriggerException,
+  DatabaseEventTriggerExceptionCode,
+} from 'src/engine/metadata-modules/database-event-trigger/exceptions/database-event-trigger.exception';
+import { type FlatDatabaseEventTrigger } from 'src/engine/metadata-modules/database-event-trigger/types/flat-database-event-trigger.type';
+
+export const fromUpdateDatabaseEventTriggerInputToFlatDatabaseEventTriggerToUpdateOrThrow =
+  ({
+    flatDatabaseEventTriggerMaps,
+    updateDatabaseEventTriggerInput,
+  }: {
+    flatDatabaseEventTriggerMaps: FlatEntityMaps<FlatDatabaseEventTrigger>;
+    updateDatabaseEventTriggerInput: UpdateDatabaseEventTriggerInput;
+  }): FlatDatabaseEventTrigger => {
+    const existingFlatDatabaseEventTrigger =
+      flatDatabaseEventTriggerMaps.byId[updateDatabaseEventTriggerInput.id];
+
+    if (!existingFlatDatabaseEventTrigger) {
+      throw new DatabaseEventTriggerException(
+        'Database event trigger not found',
+        DatabaseEventTriggerExceptionCode.DATABASE_EVENT_TRIGGER_NOT_FOUND,
+      );
+    }
+
+    return {
+      ...existingFlatDatabaseEventTrigger,
+      settings: updateDatabaseEventTriggerInput.settings,
+      updatedAt: new Date(),
+    };
+  };

packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/utils/throw-on-field-input-transpilations-error.util.ts

@@ -35,6 +35,8 @@ export const throwOnFieldInputTranspilationsError: ThrowOnFieldInputTranspilatio
               },
             ],
             serverlessFunction: [],
+            databaseEventTrigger: [],
+            cronTrigger: [],
           },
           status: 'fail',
         },

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

@@ -1,17 +1,19 @@
 import { Module } from '@nestjs/common';
 
 import { AgentModule } from 'src/engine/metadata-modules/agent/agent.module';
+import { CronTriggerModule } from 'src/engine/metadata-modules/cron-trigger/cron-trigger.module';
 import { DataSourceModule } from 'src/engine/metadata-modules/data-source/data-source.module';
+import { DatabaseEventTriggerModule } from 'src/engine/metadata-modules/database-event-trigger/database-event-trigger.module';
 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 { RemoteServerModule } from 'src/engine/metadata-modules/remote-server/remote-server.module';
 import { RoleModule } from 'src/engine/metadata-modules/role/role.module';
+import { RouteModule } from 'src/engine/metadata-modules/route/route.module';
 import { SearchFieldMetadataModule } from 'src/engine/metadata-modules/search-field-metadata/search-field-metadata.module';
 import { ServerlessFunctionModule } from 'src/engine/metadata-modules/serverless-function/serverless-function.module';
 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 { RouteModule } from 'src/engine/metadata-modules/route/route.module';
 
 @Module({
   imports: [
@@ -27,6 +29,8 @@ import { RouteModule } from 'src/engine/metadata-modules/route/route.module';
     RoleModule,
     PermissionsModule,
     RouteModule,
+    CronTriggerModule,
+    DatabaseEventTriggerModule,
   ],
   providers: [],
   exports: [

packages/twenty-server/src/engine/metadata-modules/serverless-function/serverless-function.entity.ts

@@ -12,10 +12,10 @@ import {
 
 import { SyncableEntity } from 'src/engine/workspace-manager/workspace-sync/interfaces/syncable-entity.interface';
 
+import { CronTrigger } from 'src/engine/metadata-modules/cron-trigger/entities/cron-trigger.entity';
+import { DatabaseEventTrigger } from 'src/engine/metadata-modules/database-event-trigger/entities/database-event-trigger.entity';
 import { Route } from 'src/engine/metadata-modules/route/route.entity';
 import { ServerlessFunctionEntityRelationProperties } from 'src/engine/metadata-modules/serverless-function/types/flat-serverless-function.type';
-import { CronTrigger } from 'src/engine/metadata-modules/trigger/entities/cron-trigger.entity';
-import { DatabaseEventTrigger } from 'src/engine/metadata-modules/trigger/entities/database-event-trigger.entity';
 import { InputSchema } from 'src/modules/workflow/workflow-builder/workflow-schema/types/input-schema.type';
 
 const DEFAULT_SERVERLESS_TIMEOUT_SECONDS = 300; // 5 minutes

packages/twenty-server/src/engine/metadata-modules/serverless-function/types/flat-serverless-function.type.ts

@@ -1,8 +1,8 @@
 import { type Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { type CronTrigger } from 'src/engine/metadata-modules/cron-trigger/entities/cron-trigger.entity';
+import { type DatabaseEventTrigger } from 'src/engine/metadata-modules/database-event-trigger/entities/database-event-trigger.entity';
 import { type Route } from 'src/engine/metadata-modules/route/route.entity';
 import { type ServerlessFunctionEntity } from 'src/engine/metadata-modules/serverless-function/serverless-function.entity';
-import { type CronTrigger } from 'src/engine/metadata-modules/trigger/entities/cron-trigger.entity';
-import { type DatabaseEventTrigger } from 'src/engine/metadata-modules/trigger/entities/database-event-trigger.entity';
 import { type ExtractRecordTypeOrmRelationProperties } from 'src/engine/workspace-manager/workspace-migration-v2/types/extract-record-typeorm-relation-properties.type';
 
 export type ServerlessFunctionEntityRelationProperties =

packages/twenty-server/src/engine/metadata-modules/trigger/trigger.module.ts

@@ -1,22 +0,0 @@
-import { Module } from '@nestjs/common';
-import { TypeOrmModule } from '@nestjs/typeorm';
-
-import { CronTriggerCronCommand } from 'src/engine/metadata-modules/trigger/crons/commands/cron-trigger.cron.command';
-import { CronTriggerCronJob } from 'src/engine/metadata-modules/trigger/crons/jobs/cron-trigger.cron.job';
-import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
-import { CronTrigger } from 'src/engine/metadata-modules/trigger/entities/cron-trigger.entity';
-import { CallDatabaseEventTriggerJobsJob } from 'src/engine/metadata-modules/trigger/jobs/call-database-event-trigger-jobs.job';
-import { DatabaseEventTrigger } from 'src/engine/metadata-modules/trigger/entities/database-event-trigger.entity';
-
-@Module({
-  imports: [
-    TypeOrmModule.forFeature([Workspace, CronTrigger, DatabaseEventTrigger]),
-  ],
-  providers: [
-    CronTriggerCronJob,
-    CronTriggerCronCommand,
-    CallDatabaseEventTriggerJobsJob,
-  ],
-  exports: [CronTriggerCronCommand],
-})
-export class TriggerModule {}