Skip to content

The open alternative to Salesforce, designed for AI.

feat(server): add command converting existing application logic functions to prebuilt (#25178)

martmull13be0a346b23
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-39/2-39-upgrade-version-command.module.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-39/2-39-upgrade-version-command.module.ts
new file mode 100644
index 00000000000..7cf316895e6
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-39/2-39-upgrade-version-command.module.ts
@@ -0,0 +1,20 @@
+import { Module } from '@nestjs/common';
+
+import { WorkspaceIteratorModule } from 'src/database/commands/command-runners/workspace-iterator.module';
+import { ConvertLogicFunctionsToPrebuiltCommand } from 'src/database/commands/upgrade-version-command/2-39/2-39-workspace-command-1788338950836-convert-logic-functions-to-prebuilt.command';
+import { TypeORMModule } from 'src/database/typeorm/typeorm.module';
+import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-flag.module';
+import { WorkspaceManyOrAllFlatEntityMapsCacheModule } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.module';
+import { WorkspaceSchemaMigrationRunnerActionHandlersModule } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workspace-schema-migration-runner-action-handlers.module';
+
+@Module({
+ imports: [
+ FeatureFlagModule,
+ TypeORMModule,
+ WorkspaceIteratorModule,
+ WorkspaceManyOrAllFlatEntityMapsCacheModule,
+ WorkspaceSchemaMigrationRunnerActionHandlersModule,
+ ],
+ providers: [ConvertLogicFunctionsToPrebuiltCommand],
+})
+export class V2_39_UpgradeVersionCommandModule {}
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-39/2-39-workspace-command-1788338950836-convert-logic-functions-to-prebuilt.command.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-39/2-39-workspace-command-1788338950836-convert-logic-functions-to-prebuilt.command.ts
new file mode 100644
index 00000000000..060d3137bc3
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-39/2-39-workspace-command-1788338950836-convert-logic-functions-to-prebuilt.command.ts
@@ -0,0 +1,251 @@
+import { InjectDataSource } from '@nestjs/typeorm';
+
+import chunk from 'lodash.chunk';
+import { Command } from 'nest-commander';
+
+import { FeatureFlagKey } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+import { DataSource } from 'typeorm';
+
+import { ProvisionedWorkspaceCommandRunner } from 'src/database/commands/command-runners/provisioned-workspace.command-runner';
+import { WorkspaceIteratorService } from 'src/database/commands/command-runners/workspace-iterator.service';
+import { type RunOnWorkspaceArgs } from 'src/database/commands/command-runners/workspace.command-runner';
+import { type FlatApplicationCacheMaps } from 'src/engine/core-modules/application/types/flat-application-cache-maps.type';
+import { type FlatApplication } from 'src/engine/core-modules/application/types/flat-application.type';
+import { findActiveFlatApplicationById } from 'src/engine/core-modules/application/utils/find-active-flat-application-by-id.util';
+import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
+import { RegisteredWorkspaceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-workspace-command.decorator';
+import { createEmptyAllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-all-flat-entity-maps.constant';
+import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
+import { type AllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-maps.type';
+import { LogicFunctionExecutionMode } from 'src/engine/metadata-modules/logic-function/logic-function.entity';
+import { type FlatLogicFunctionMaps } from 'src/engine/metadata-modules/logic-function/types/flat-logic-function-maps.type';
+import { type FlatLogicFunction } from 'src/engine/metadata-modules/logic-function/types/flat-logic-function.type';
+import { isLogicFunctionEligibleForPrebuiltConversion } from 'src/engine/metadata-modules/logic-function/utils/is-logic-function-eligible-for-prebuilt-conversion.util';
+import { UpdateLogicFunctionActionHandlerService } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/logic-function/services/update-logic-function-action-handler.service';
+
+const LOGIC_FUNCTION_PREBUILT_CONVERSION_BATCH_SIZE = 100;
+
+type LogicFunctionConversionTarget = {
+ flatLogicFunction: FlatLogicFunction;
+ flatApplication: FlatApplication;
+};
+
+@RegisteredWorkspaceCommand('2.39.0', 1788338950836)
+@Command({
+ name: 'upgrade:2-39:convert-logic-functions-to-prebuilt',
+ description:
+ 'Convert packaged application logic functions from LIVE to PREBUILT execution mode. Idempotent.',
+})
+export class ConvertLogicFunctionsToPrebuiltCommand extends ProvisionedWorkspaceCommandRunner {
+ constructor(
+ protected readonly workspaceIteratorService: WorkspaceIteratorService,
+ private readonly featureFlagService: FeatureFlagService,
+ private readonly flatEntityMapsCacheService: WorkspaceManyOrAllFlatEntityMapsCacheService,
+ private readonly updateLogicFunctionActionHandlerService: UpdateLogicFunctionActionHandlerService,
+ @InjectDataSource()
+ private readonly coreDataSource: DataSource,
+ ) {
+ super(workspaceIteratorService);
+ }
+
+ override async runOnWorkspace({
+ workspaceId,
+ options,
+ }: RunOnWorkspaceArgs): Promise<void> {
+ const dryRun = options.dryRun ?? false;
+
+ const isPrebuiltModeEnabled =
+ await this.featureFlagService.isFeatureEnabled(
+ FeatureFlagKey.IS_LOGIC_FUNCTION_PREBUILT_MODE_ENABLED,
+ workspaceId,
+ );
+
+ if (!isPrebuiltModeEnabled && !dryRun) {
+ await this.featureFlagService.enableFeatureFlags(
+ [FeatureFlagKey.IS_LOGIC_FUNCTION_PREBUILT_MODE_ENABLED],
+ workspaceId,
+ );
+ }
+
+ const { flatLogicFunctionMaps, flatApplicationMaps } =
+ await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+ {
+ workspaceId,
+ flatMapsKeys: ['flatLogicFunctionMaps', 'flatApplicationMaps'],
+ },
+ );
+
+ const conversionTargets = this.findLogicFunctionsToConvert({
+ flatLogicFunctionMaps,
+ flatApplicationMaps,
+ });
+
+ if (conversionTargets.length === 0) {
+ return;
+ }
+
+ if (dryRun) {
+ this.logger.log(
+ `Would ensure ${FeatureFlagKey.IS_LOGIC_FUNCTION_PREBUILT_MODE_ENABLED} is enabled and convert ${conversionTargets.length} logic function(s) on workspace ${workspaceId}`,
+ );
+
+ return;
+ }
+
+ const convertedCount = await this.convertLogicFunctionsInBatches({
+ conversionTargets,
+ workspaceId,
+ allFlatEntityMaps: {
+ ...createEmptyAllFlatEntityMaps(),
+ flatLogicFunctionMaps,
+ },
+ });
+
+ if (convertedCount > 0) {
+ await this.flatEntityMapsCacheService.invalidateFlatEntityMaps({
+ workspaceId,
+ flatMapsKeys: ['flatLogicFunctionMaps'],
+ });
+ }
+ }
+
+ private async convertLogicFunctionsInBatches({
+ conversionTargets,
+ workspaceId,
+ allFlatEntityMaps,
+ }: {
+ conversionTargets: LogicFunctionConversionTarget[];
+ workspaceId: string;
+ allFlatEntityMaps: AllFlatEntityMaps;
+ }): Promise<number> {
+ let convertedCount = 0;
+ const failedLogicFunctionIds: string[] = [];
+
+ for (const batch of chunk(
+ conversionTargets,
+ LOGIC_FUNCTION_PREBUILT_CONVERSION_BATCH_SIZE,
+ )) {
+ const results = await Promise.allSettled(
+ batch.map((conversionTarget) =>
+ this.convertLogicFunctionToPrebuilt({
+ conversionTarget,
+ workspaceId,
+ allFlatEntityMaps,
+ }),
+ ),
+ );
+
+ results.forEach((result, batchIndex) => {
+ if (result.status === 'fulfilled') {
+ convertedCount += 1;
+
+ return;
+ }
+
+ const { flatLogicFunction } = batch[batchIndex];
+
+ failedLogicFunctionIds.push(flatLogicFunction.id);
+
+ this.logger.error(
+ `Failed to convert logic function '${flatLogicFunction.id}' on workspace ${workspaceId}: ${
+ result.reason instanceof Error
+ ? result.reason.message
+ : String(result.reason)
+ }`,
+ );
+ });
+ }
+
+ this.logger.log(
+ `Converted ${convertedCount} logic function(s) on workspace ${workspaceId}` +
+ (failedLogicFunctionIds.length > 0
+ ? `, ${failedLogicFunctionIds.length} failed: ${failedLogicFunctionIds.join(', ')}`
+ : ''),
+ );
+
+ return convertedCount;
+ }
+
+ private async convertLogicFunctionToPrebuilt({
+ conversionTarget: { flatLogicFunction, flatApplication },
+ workspaceId,
+ allFlatEntityMaps,
+ }: {
+ conversionTarget: LogicFunctionConversionTarget;
+ workspaceId: string;
+ allFlatEntityMaps: AllFlatEntityMaps;
+ }): Promise<void> {
+ const queryRunner = this.coreDataSource.createQueryRunner();
+
+ try {
+ await queryRunner.connect();
+ await queryRunner.startTransaction();
+
+ await this.updateLogicFunctionActionHandlerService.executeForMetadata({
+ queryRunner,
+ workspaceId,
+ allFlatEntityMaps,
+ flatApplication,
+ action: {
+ type: 'update',
+ metadataName: 'logicFunction',
+ universalIdentifier: flatLogicFunction.universalIdentifier,
+ update: { executionMode: LogicFunctionExecutionMode.PREBUILT },
+ },
+ flatAction: {
+ type: 'update',
+ metadataName: 'logicFunction',
+ entityId: flatLogicFunction.id,
+ update: { executionMode: LogicFunctionExecutionMode.PREBUILT },
+ },
+ });
+
+ await queryRunner.commitTransaction();
+ } catch (error) {
+ if (queryRunner.isTransactionActive) {
+ await queryRunner.rollbackTransaction();
+ }
+
+ throw error;
+ } finally {
+ await queryRunner.release();
+ }
+ }
+
+ private findLogicFunctionsToConvert({
+ flatLogicFunctionMaps,
+ flatApplicationMaps,
+ }: {
+ flatLogicFunctionMaps: FlatLogicFunctionMaps;
+ flatApplicationMaps: FlatApplicationCacheMaps;
+ }): LogicFunctionConversionTarget[] {
+ return Object.entries(
+ flatLogicFunctionMaps.universalIdentifiersByApplicationId,
+ ).flatMap(([applicationId, universalIdentifiers]) => {
+ const flatApplication = findActiveFlatApplicationById(
+ flatApplicationMaps,
+ applicationId,
+ );
+
+ if (!isDefined(flatApplication)) {
+ return [];
+ }
+
+ return (universalIdentifiers ?? [])
+ .map(
+ (universalIdentifier) =>
+ flatLogicFunctionMaps.byUniversalIdentifier[universalIdentifier],
+ )
+ .filter(
+ (flatLogicFunction): flatLogicFunction is FlatLogicFunction =>
+ isDefined(flatLogicFunction) &&
+ isLogicFunctionEligibleForPrebuiltConversion({
+ flatLogicFunction,
+ applicationSourceType: flatApplication.sourceType,
+ }),
+ )
+ .map((flatLogicFunction) => ({ flatLogicFunction, flatApplication }));
+ });
+ }
+}
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/workspace-command-provider.module.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/workspace-command-provider.module.ts
index 3b673c9c492..2a3ee4dc1e4 100644
--- a/packages/twenty-server/src/database/commands/upgrade-version-command/workspace-command-provider.module.ts
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/workspace-command-provider.module.ts
@@ -31,6 +31,7 @@ import { V2_35_UpgradeVersionCommandModule } from 'src/database/commands/upgrade
import { V2_36_UpgradeVersionCommandModule } from 'src/database/commands/upgrade-version-command/2-36/2-36-upgrade-version-command.module';
import { V2_37_UpgradeVersionCommandModule } from 'src/database/commands/upgrade-version-command/2-37/2-37-upgrade-version-command.module';
import { V2_38_UpgradeVersionCommandModule } from 'src/database/commands/upgrade-version-command/2-38/2-38-upgrade-version-command.module';
+import { V2_39_UpgradeVersionCommandModule } from 'src/database/commands/upgrade-version-command/2-39/2-39-upgrade-version-command.module';
import { V2_4_UpgradeVersionCommandModule } from 'src/database/commands/upgrade-version-command/2-4/2-4-upgrade-version-command.module';
import { V2_5_UpgradeVersionCommandModule } from 'src/database/commands/upgrade-version-command/2-5/2-5-upgrade-version-command.module';
import { V2_7_UpgradeVersionCommandModule } from 'src/database/commands/upgrade-version-command/2-7/2-7-upgrade-version-command.module';
@@ -75,6 +76,7 @@ import { V2_9_UpgradeVersionCommandModule } from 'src/database/commands/upgrade-
V2_36_UpgradeVersionCommandModule,
V2_37_UpgradeVersionCommandModule,
V2_38_UpgradeVersionCommandModule,
+ V2_39_UpgradeVersionCommandModule,
],
})
export class WorkspaceCommandProviderModule {}
diff --git a/packages/twenty-server/src/engine/core-modules/workflow/services/workspace-workflow-automated-trigger-map-cache.service.ts b/packages/twenty-server/src/engine/core-modules/workflow/services/workspace-workflow-automated-trigger-map-cache.service.ts
index a612bb8d9ed..805c984f93b 100644
--- a/packages/twenty-server/src/engine/core-modules/workflow/services/workspace-workflow-automated-trigger-map-cache.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/workflow/services/workspace-workflow-automated-trigger-map-cache.service.ts
@@ -1,5 +1,6 @@
import { Injectable, Logger } from '@nestjs/common';
+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
import { isDefined } from 'twenty-shared/utils';
import { In } from 'typeorm';
@@ -14,6 +15,7 @@ import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system
import { InjectWorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/inject-workspace-scoped-repository.decorator';
import { WorkspaceScopedRepository } from 'src/engine/twenty-orm/workspace-scoped-repository/workspace-scoped-repository';
import { WorkspaceCache } from 'src/engine/workspace-cache/decorators/workspace-cache.decorator';
+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
import { WorkspaceCacheProvider } from 'src/engine/workspace-cache/interfaces/workspace-cache-provider.service';
import { type WorkspaceCacheProviderContext } from 'src/engine/workspace-cache/types/workspace-cache-provider-context.type';
import { type WorkflowVersionWorkspaceEntity } from 'src/modules/workflow/common/standard-objects/workflow-version.workspace-entity';
@@ -29,6 +31,7 @@ export class WorkspaceWorkflowAutomatedTriggerMapCacheService extends WorkspaceC
@InjectWorkspaceScopedRepository(WorkflowVersionEntity)
private readonly workflowVersionRepository: WorkspaceScopedRepository<WorkflowVersionEntity>,
private readonly workspaceOrmManager: WorkspaceOrmManager,
+ private readonly workspaceCacheService: WorkspaceCacheService,
) {
super();
}
@@ -75,6 +78,14 @@ export class WorkspaceWorkflowAutomatedTriggerMapCacheService extends WorkspaceC
return {};
}
+ if (!(await this.workspaceHasCoreWorkflowVersionIdField(workspaceId))) {
+ this.logger.warn(
+ `workflowVersion.coreWorkflowVersionId field missing for workspace ${workspaceId}, skipping workspace twin resolution`,
+ );
+
+ return {};
+ }
+
const authContext = buildSystemAuthContext(workspaceId);
return this.workspaceOrmManager.executeInWorkspaceContext(async () => {
@@ -143,4 +154,20 @@ export class WorkspaceWorkflowAutomatedTriggerMapCacheService extends WorkspaceC
);
}, authContext);
}
+
+ private async workspaceHasCoreWorkflowVersionIdField(
+ workspaceId: string,
+ ): Promise<boolean> {
+ const { flatFieldMetadataMaps } =
+ await this.workspaceCacheService.getOrRecompute(workspaceId, [
+ 'flatFieldMetadataMaps',
+ ]);
+
+ return isDefined(
+ flatFieldMetadataMaps.byUniversalIdentifier[
+ STANDARD_OBJECTS.workflowVersion.fields.coreWorkflowVersionId
+ .universalIdentifier
+ ],
+ );
+ }
}
diff --git a/packages/twenty-server/src/engine/metadata-modules/logic-function/utils/__tests__/is-logic-function-eligible-for-prebuilt-conversion.util.spec.ts b/packages/twenty-server/src/engine/metadata-modules/logic-function/utils/__tests__/is-logic-function-eligible-for-prebuilt-conversion.util.spec.ts
new file mode 100644
index 00000000000..1c97705a718
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/logic-function/utils/__tests__/is-logic-function-eligible-for-prebuilt-conversion.util.spec.ts
@@ -0,0 +1,88 @@
+import { ApplicationRegistrationSourceType } from 'src/engine/core-modules/application/application-registration/enums/application-registration-source-type.enum';
+import { LogicFunctionExecutionMode } from 'src/engine/metadata-modules/logic-function/logic-function.entity';
+import {
+ isLogicFunctionEligibleForPrebuiltConversion,
+ type LogicFunctionPrebuiltConversionFields,
+} from 'src/engine/metadata-modules/logic-function/utils/is-logic-function-eligible-for-prebuilt-conversion.util';
+
+const buildFlatLogicFunction = (
+ overrides: Partial<LogicFunctionPrebuiltConversionFields> = {},
+): LogicFunctionPrebuiltConversionFields => ({
+ executionMode: LogicFunctionExecutionMode.LIVE,
+ isBuildUpToDate: true,
+ checksum: 'checksum-1',
+ deletedAt: null,
+ ...overrides,
+});
+
+describe('isLogicFunctionEligibleForPrebuiltConversion', () => {
+ it.each([
+ ApplicationRegistrationSourceType.TARBALL,
+ ApplicationRegistrationSourceType.NPM,
+ ])(
+ 'should be eligible for a built LIVE function on a %s application',
+ (applicationSourceType) => {
+ expect(
+ isLogicFunctionEligibleForPrebuiltConversion({
+ flatLogicFunction: buildFlatLogicFunction(),
+ applicationSourceType,
+ }),
+ ).toBe(true);
+ },
+ );
+
+ it.each([
+ ApplicationRegistrationSourceType.LOCAL,
+ ApplicationRegistrationSourceType.OAUTH_ONLY,
+ ])('should not be eligible on a %s application', (applicationSourceType) => {
+ expect(
+ isLogicFunctionEligibleForPrebuiltConversion({
+ flatLogicFunction: buildFlatLogicFunction(),
+ applicationSourceType,
+ }),
+ ).toBe(false);
+ });
+
+ it('should not be eligible when the function is already prebuilt', () => {
+ expect(
+ isLogicFunctionEligibleForPrebuiltConversion({
+ flatLogicFunction: buildFlatLogicFunction({
+ executionMode: LogicFunctionExecutionMode.PREBUILT,
+ }),
+ applicationSourceType: ApplicationRegistrationSourceType.TARBALL,
+ }),
+ ).toBe(false);
+ });
+
+ it('should not be eligible when the build is out of date', () => {
+ expect(
+ isLogicFunctionEligibleForPrebuiltConversion({
+ flatLogicFunction: buildFlatLogicFunction({ isBuildUpToDate: false }),
+ applicationSourceType: ApplicationRegistrationSourceType.TARBALL,
+ }),
+ ).toBe(false);
+ });
+
+ it.each([null, ''])(
+ 'should not be eligible when the checksum is %p',
+ (checksum) => {
+ expect(
+ isLogicFunctionEligibleForPrebuiltConversion({
+ flatLogicFunction: buildFlatLogicFunction({ checksum }),
+ applicationSourceType: ApplicationRegistrationSourceType.TARBALL,
+ }),
+ ).toBe(false);
+ },
+ );
+
+ it('should not be eligible when the function is soft deleted', () => {
+ expect(
+ isLogicFunctionEligibleForPrebuiltConversion({
+ flatLogicFunction: buildFlatLogicFunction({
+ deletedAt: new Date().toISOString(),
+ }),
+ applicationSourceType: ApplicationRegistrationSourceType.TARBALL,
+ }),
+ ).toBe(false);
+ });
+});
diff --git a/packages/twenty-server/src/engine/metadata-modules/logic-function/utils/is-logic-function-eligible-for-prebuilt-conversion.util.ts b/packages/twenty-server/src/engine/metadata-modules/logic-function/utils/is-logic-function-eligible-for-prebuilt-conversion.util.ts
new file mode 100644
index 00000000000..128cdf67a4d
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/logic-function/utils/is-logic-function-eligible-for-prebuilt-conversion.util.ts
@@ -0,0 +1,25 @@
+import { isNonEmptyString } from '@sniptt/guards';
+import { isDefined } from 'twenty-shared/utils';
+
+import { type ApplicationRegistrationSourceType } from 'src/engine/core-modules/application/application-registration/enums/application-registration-source-type.enum';
+import { isPackagedApplicationSource } from 'src/engine/core-modules/application/application-registration/utils/is-packaged-application-source.util';
+import { LogicFunctionExecutionMode } from 'src/engine/metadata-modules/logic-function/logic-function.entity';
+import { type FlatLogicFunction } from 'src/engine/metadata-modules/logic-function/types/flat-logic-function.type';
+
+export type LogicFunctionPrebuiltConversionFields = Pick<
+ FlatLogicFunction,
+ 'executionMode' | 'isBuildUpToDate' | 'checksum' | 'deletedAt'
+>;
+
+export const isLogicFunctionEligibleForPrebuiltConversion = ({
+ flatLogicFunction,
+ applicationSourceType,
+}: {
+ flatLogicFunction: LogicFunctionPrebuiltConversionFields;
+ applicationSourceType: ApplicationRegistrationSourceType;
+}): boolean =>
+ !isDefined(flatLogicFunction.deletedAt) &&
+ flatLogicFunction.executionMode === LogicFunctionExecutionMode.LIVE &&
+ isPackagedApplicationSource(applicationSourceType) &&
+ flatLogicFunction.isBuildUpToDate &&
+ isNonEmptyString(flatLogicFunction.checksum);
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workspace-schema-migration-runner-action-handlers.module.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workspace-schema-migration-runner-action-handlers.module.ts
index 9fb774904d3..654c0b141b3 100644
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workspace-schema-migration-runner-action-handlers.module.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/workspace-schema-migration-runner-action-handlers.module.ts
@@ -237,5 +237,6 @@ import { UpdateSearchFieldMetadataActionHandlerService } from 'src/engine/worksp
UpdateSearchFieldMetadataActionHandlerService,
DeleteSearchFieldMetadataActionHandlerService,
],
+ exports: [UpdateLogicFunctionActionHandlerService],
})
export class WorkspaceSchemaMigrationRunnerActionHandlersModule {}