Skip to content

The open alternative to Salesforce, designed for AI.

Run application uninstall hooks when deleting a workspace (#23633)

nitinb68c2602875f
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-33/2-33-instance-command-fast-1787151824000-add-uninstall-hook-completed-for-requested-at-to-application.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-33/2-33-instance-command-fast-1787151824000-add-uninstall-hook-completed-for-requested-at-to-application.ts
new file mode 100644
index 00000000000..0d82f8b2101
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-33/2-33-instance-command-fast-1787151824000-add-uninstall-hook-completed-for-requested-at-to-application.ts
@@ -0,0 +1,21 @@
+import { QueryRunner } from 'typeorm';
+
+import { RegisteredInstanceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-instance-command.decorator';
+import { FastInstanceCommand } from 'src/engine/core-modules/upgrade/interfaces/fast-instance-command.interface';
+
+@RegisteredInstanceCommand('2.33.0', 1787151824000)
+export class AddUninstallHookCompletedForRequestedAtToApplicationFastInstanceCommand
+ implements FastInstanceCommand
+{
+ public async up(queryRunner: QueryRunner): Promise<void> {
+ await queryRunner.query(
+ 'ALTER TABLE "core"."application" ADD COLUMN IF NOT EXISTS "uninstallHookCompletedForRequestedAt" TIMESTAMP WITH TIME ZONE',
+ );
+ }
+
+ public async down(queryRunner: QueryRunner): Promise<void> {
+ await queryRunner.query(
+ 'ALTER TABLE "core"."application" DROP COLUMN IF EXISTS "uninstallHookCompletedForRequestedAt"',
+ );
+ }
+}
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/instance-commands.constant.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/instance-commands.constant.ts
index 4788d9e8ef9..46517206fe2 100644
--- a/packages/twenty-server/src/database/commands/upgrade-version-command/instance-commands.constant.ts
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/instance-commands.constant.ts
@@ -148,6 +148,7 @@ import { EncryptEmptyApplicationVariablesSlowInstanceCommand } from 'src/databas
import { AddWritabilityToMetadataFastInstanceCommand } from 'src/database/commands/upgrade-version-command/2-32/2-32-instance-command-fast-1786713600000-add-writability-to-metadata';
import { AddUninstallLogicFunctionIdToApplicationFastInstanceCommand } from 'src/database/commands/upgrade-version-command/2-32/2-32-instance-command-fast-1786959731000-add-uninstall-logic-function-id-to-application';
import { BackfillUninstallLogicFunctionIdOnApplicationSlowInstanceCommand } from 'src/database/commands/upgrade-version-command/2-32/2-32-instance-command-slow-1786959731001-backfill-uninstall-logic-function-id-on-application';
+import { AddUninstallHookCompletedForRequestedAtToApplicationFastInstanceCommand } from 'src/database/commands/upgrade-version-command/2-33/2-33-instance-command-fast-1787151824000-add-uninstall-hook-completed-for-requested-at-to-application';
export const INSTANCE_COMMANDS = [
AddViewFieldGroupIdIndexOnViewFieldFastInstanceCommand,
@@ -298,4 +299,5 @@ export const INSTANCE_COMMANDS = [
AddWritabilityToMetadataFastInstanceCommand,
AddUninstallLogicFunctionIdToApplicationFastInstanceCommand,
BackfillUninstallLogicFunctionIdOnApplicationSlowInstanceCommand,
+ AddUninstallHookCompletedForRequestedAtToApplicationFastInstanceCommand,
];
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-exception-filter.ts b/packages/twenty-server/src/engine/core-modules/application/application-exception-filter.ts
index 2cd9c9ca364..a536418d8f2 100644
--- a/packages/twenty-server/src/engine/core-modules/application/application-exception-filter.ts
+++ b/packages/twenty-server/src/engine/core-modules/application/application-exception-filter.ts
@@ -41,6 +41,7 @@ export class ApplicationExceptionFilter implements ExceptionFilter {
case ApplicationExceptionCode.PACKAGE_RESOLUTION_FAILED:
case ApplicationExceptionCode.POST_INSTALL_ERROR:
case ApplicationExceptionCode.PRE_INSTALL_ERROR:
+ case ApplicationExceptionCode.UNINSTALL_ERROR:
case ApplicationExceptionCode.TARBALL_EXTRACTION_FAILED:
case ApplicationExceptionCode.UPGRADE_FAILED:
case ApplicationExceptionCode.INVALID_SERVER_VERSION:
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/application-manifest.module.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/application-manifest.module.ts
index 6baaf177104..128ee2349ee 100644
--- a/packages/twenty-server/src/engine/core-modules/application/application-manifest/application-manifest.module.ts
+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/application-manifest.module.ts
@@ -2,8 +2,10 @@ import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { ApplicationModule } from 'src/engine/core-modules/application/application.module';
+import { ApplicationEntity } from 'src/engine/core-modules/application/application.entity';
import { ApplicationManifestApplyService } from 'src/engine/core-modules/application/application-manifest/application-manifest-apply.service';
import { ApplicationManifestMigrationService } from 'src/engine/core-modules/application/application-manifest/application-manifest-migration.service';
+import { ApplicationUninstallService } from 'src/engine/core-modules/application/application-manifest/services/application-uninstall.service';
import { ComputeApplicationManifestAllUniversalFlatEntityMapsService } from 'src/engine/core-modules/application/application-manifest/services/compute-application-manifest-all-universal-flat-entity-maps.service';
import { ApplicationSyncService } from 'src/engine/core-modules/application/application-manifest/application-sync.service';
import { ApplicationRegistrationModule } from 'src/engine/core-modules/application/application-registration/application-registration.module';
@@ -21,7 +23,7 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace
@Module({
imports: [
- TypeOrmModule.forFeature([FrontComponentEntity]),
+ TypeOrmModule.forFeature([ApplicationEntity, FrontComponentEntity]),
ApplicationModule,
ApplicationRegistrationModule,
ApplicationTranslationModule,
@@ -39,12 +41,14 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace
ApplicationManifestApplyService,
ApplicationManifestMigrationService,
ApplicationSyncService,
+ ApplicationUninstallService,
ComputeApplicationManifestAllUniversalFlatEntityMapsService,
],
exports: [
ApplicationManifestApplyService,
ApplicationManifestMigrationService,
ApplicationSyncService,
+ ApplicationUninstallService,
],
})
export class ApplicationManifestModule {}
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/application-sync.service.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/application-sync.service.ts
index c258434a41e..9479e354b1e 100644
--- a/packages/twenty-server/src/engine/core-modules/application/application-manifest/application-sync.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/application-sync.service.ts
@@ -11,6 +11,7 @@ import { v4 } from 'uuid';
import { ApplicationRegistrationSourceType } from 'src/engine/core-modules/application/application-registration/enums/application-registration-source-type.enum';
import { ApplicationManifestMigrationService } from 'src/engine/core-modules/application/application-manifest/application-manifest-migration.service';
+import { ApplicationUninstallService } from 'src/engine/core-modules/application/application-manifest/services/application-uninstall.service';
import { enrichApplicationManifestSyncError } from 'src/engine/core-modules/application/application-manifest/utils/enrich-application-manifest-sync-error.util';
import { buildFromToAllUniversalFlatEntityMaps } from 'src/engine/core-modules/application/application-manifest/utils/build-from-to-all-universal-flat-entity-maps.util';
import { ApplicationTranslationSyncService } from 'src/engine/core-modules/application/application-translation/application-translation-sync.service';
@@ -25,7 +26,6 @@ import { type FlatApplication } from 'src/engine/core-modules/application/types/
import { FileStorageService } from 'src/engine/core-modules/file-storage/services/file-storage.service';
import { LOGIC_FUNCTION_DRIVER_FACTORY_TOKEN } from 'src/engine/core-modules/logic-function/logic-function-drivers/constants/logic-function-driver-factory.token';
import { type LogicFunctionDriverFactory } from 'src/engine/core-modules/logic-function/logic-function-drivers/logic-function-driver.factory';
-import { LogicFunctionExecutorService } from 'src/engine/core-modules/logic-function/logic-function-executor/logic-function-executor.service';
import { createEmptyAllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-all-flat-entity-maps.constant';
import { getMetadataFlatEntityMapsKey } from 'src/engine/metadata-modules/flat-entity/utils/get-metadata-flat-entity-maps-key.util';
import { FrontComponentEntity } from 'src/engine/metadata-modules/front-component/entities/front-component.entity';
@@ -49,7 +49,7 @@ export class ApplicationSyncService {
private readonly applicationTranslationSyncService: ApplicationTranslationSyncService,
@Inject(LOGIC_FUNCTION_DRIVER_FACTORY_TOKEN)
private readonly logicFunctionDriverFactory: LogicFunctionDriverFactory,
- private readonly logicFunctionExecutorService: LogicFunctionExecutorService,
+ private readonly applicationUninstallService: ApplicationUninstallService,
@InjectRepository(FrontComponentEntity)
private readonly frontComponentRepository: Repository<FrontComponentEntity>,
private readonly workspaceEventBroadcaster: WorkspaceEventBroadcaster,
@@ -170,6 +170,7 @@ export class ApplicationSyncService {
defaultRole: null,
settingsCustomTabFrontComponentId: null,
uninstallLogicFunctionId: null,
+ uninstallHookCompletedForRequestedAt: null,
canBeUninstalled: true,
autoUpgrade: false,
isSdkLayerStale: false,
@@ -349,7 +350,10 @@ export class ApplicationSyncService {
}
if (shouldRunUninstallHook) {
- await this.runUninstallHook({ application, workspaceId });
+ await this.applicationUninstallService.runUninstallHookBestEffort({
+ application,
+ workspaceId,
+ });
}
const flatEntityMapsCacheKeys = Object.values(ALL_METADATA_NAME).map(
@@ -409,47 +413,6 @@ export class ApplicationSyncService {
return validateAndBuildResult.workspaceMigration;
}
- // The uninstall hook must run before the deletion migration: once the
- // migration is applied, the hook's logic function metadata, code, and the
- // application's data are gone, so nothing can be executed anymore. It is
- // best-effort cleanup: a failure must never prevent the application from
- // being removed. uninstallLogicFunctionId is resolved from the manifest at
- // sync time, so it always points at the installed release, not at whatever
- // the application registration currently publishes.
- private async runUninstallHook({
- application,
- workspaceId,
- }: {
- application: ApplicationEntity;
- workspaceId: string;
- }): Promise<void> {
- if (!isDefined(application.uninstallLogicFunctionId)) {
- return;
- }
-
- try {
- this.logger.log(
- `Executing uninstall hook for app ${application.universalIdentifier}`,
- );
-
- const result = await this.logicFunctionExecutorService.execute({
- logicFunctionId: application.uninstallLogicFunctionId,
- workspaceId,
- payload: { version: application.version ?? undefined },
- });
-
- if (isDefined(result.error)) {
- this.logger.warn(
- `Uninstall hook failed for application ${application.universalIdentifier}: ${result.error.errorMessage}`,
- );
- }
- } catch (error) {
- this.logger.warn(
- `Uninstall hook failed for application ${application.universalIdentifier}: ${error instanceof Error ? error.message : String(error)}`,
- );
- }
- }
-
private async cleanupApplicationRuntimeResources({
workspaceId,
applicationUniversalIdentifier,
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/services/application-uninstall.service.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/services/application-uninstall.service.ts
new file mode 100644
index 00000000000..1c7744f4b58
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/services/application-uninstall.service.ts
@@ -0,0 +1,225 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { In, type Repository } from 'typeorm';
+import { isDefined, isNonEmptyArray } from 'twenty-shared/utils';
+
+import { ApplicationEntity } from 'src/engine/core-modules/application/application.entity';
+import {
+ ApplicationException,
+ ApplicationExceptionCode,
+} from 'src/engine/core-modules/application/application.exception';
+import { ApplicationService } from 'src/engine/core-modules/application/application.service';
+import {
+ buildWorkspaceUninstallHookPayload,
+ type UninstallHookPayload,
+} from 'src/engine/core-modules/application/application-manifest/utils/build-workspace-uninstall-hook-payload.util';
+import { isApplicationUninstallHookPending } from 'src/engine/core-modules/application/utils/is-application-uninstall-hook-pending.util';
+import { LogicFunctionExecutorService } from 'src/engine/core-modules/logic-function/logic-function-executor/logic-function-executor.service';
+
+type ApplicationForUninstallHook = Pick<
+ ApplicationEntity,
+ | 'id'
+ | 'uninstallLogicFunctionId'
+ | 'uninstallHookCompletedForRequestedAt'
+ | 'universalIdentifier'
+ | 'version'
+>;
+
+@Injectable()
+export class ApplicationUninstallService {
+ private readonly logger = new Logger(ApplicationUninstallService.name);
+
+ constructor(
+ @InjectRepository(ApplicationEntity)
+ private readonly applicationRepository: Repository<ApplicationEntity>,
+ private readonly applicationService: ApplicationService,
+ private readonly logicFunctionExecutorService: LogicFunctionExecutorService,
+ ) {}
+
+ async runUninstallHooksForWorkspaceDeletion({
+ workspaceId,
+ workspaceDeletedAt,
+ }: {
+ workspaceId: string;
+ workspaceDeletedAt: Date;
+ }): Promise<void> {
+ const applications =
+ await this.applicationService.findManyApplications(workspaceId);
+ const pendingApplications = applications.filter((application) =>
+ isApplicationUninstallHookPending(application, workspaceDeletedAt),
+ );
+ const applicationUninstallHookFailures: string[] = [];
+
+ for (const application of pendingApplications) {
+ try {
+ await this.runUninstallHookForWorkspaceDeletion({
+ application,
+ workspaceId,
+ workspaceDeletedAt,
+ });
+ await this.applicationRepository.update(application.id, {
+ uninstallHookCompletedForRequestedAt: workspaceDeletedAt,
+ });
+ } catch (error) {
+ const applicationUninstallHookFailure = `${application.universalIdentifier}: ${error instanceof Error ? error.message : String(error)}`;
+
+ applicationUninstallHookFailures.push(applicationUninstallHookFailure);
+ this.logger.warn(
+ `workspace-deletion uninstall hook failed: ${applicationUninstallHookFailure}`,
+ );
+ }
+ }
+
+ if (isNonEmptyArray(applicationUninstallHookFailures)) {
+ throw new ApplicationException(
+ `Application uninstall hooks failed for workspace ${workspaceId}: ${applicationUninstallHookFailures.join('; ')}`,
+ ApplicationExceptionCode.UNINSTALL_ERROR,
+ );
+ }
+ }
+
+ async runUninstallHooksForWorkspaceDeletionBestEffort({
+ workspaceId,
+ workspaceDeletedAt,
+ }: {
+ workspaceId: string;
+ workspaceDeletedAt: Date;
+ }): Promise<void> {
+ try {
+ await this.runUninstallHooksForWorkspaceDeletion({
+ workspaceId,
+ workspaceDeletedAt,
+ });
+ } catch (error) {
+ this.logger.warn(
+ `Uninstall hooks failed before hard deleting workspace ${workspaceId}: ${error instanceof Error ? error.message : String(error)}`,
+ );
+ }
+ }
+
+ async findWorkspaceIdsWithPendingUninstallHooks(
+ workspaceUninstallRequests: {
+ workspaceId: string;
+ uninstallRequestedAt: Date;
+ }[],
+ ): Promise<Set<string>> {
+ if (!isNonEmptyArray(workspaceUninstallRequests)) {
+ return new Set();
+ }
+
+ const applications = await this.applicationRepository.find({
+ select: [
+ 'workspaceId',
+ 'uninstallLogicFunctionId',
+ 'uninstallHookCompletedForRequestedAt',
+ ],
+ where: {
+ workspaceId: In(
+ workspaceUninstallRequests.map((request) => request.workspaceId),
+ ),
+ },
+ });
+ const uninstallRequestedAtByWorkspaceId = new Map(
+ workspaceUninstallRequests.map((request) => [
+ request.workspaceId,
+ request.uninstallRequestedAt,
+ ]),
+ );
+ const workspaceIdsWithPendingUninstallHooks = new Set<string>();
+
+ for (const application of applications) {
+ const uninstallRequestedAt = uninstallRequestedAtByWorkspaceId.get(
+ application.workspaceId,
+ );
+
+ if (
+ isDefined(uninstallRequestedAt) &&
+ isApplicationUninstallHookPending(application, uninstallRequestedAt)
+ ) {
+ workspaceIdsWithPendingUninstallHooks.add(application.workspaceId);
+ }
+ }
+
+ return workspaceIdsWithPendingUninstallHooks;
+ }
+
+ async runUninstallHookBestEffort({
+ application,
+ workspaceId,
+ }: {
+ application: ApplicationForUninstallHook;
+ workspaceId: string;
+ }): Promise<void> {
+ try {
+ await this.runUninstallHook({
+ application,
+ workspaceId,
+ payload: { version: application.version ?? undefined },
+ });
+ } catch (error) {
+ this.logger.warn(
+ `Uninstall hook failed for application ${application.universalIdentifier}: ${error instanceof Error ? error.message : String(error)}`,
+ );
+ }
+ }
+
+ private async runUninstallHookForWorkspaceDeletion({
+ application,
+ workspaceId,
+ workspaceDeletedAt,
+ }: {
+ application: ApplicationForUninstallHook;
+ workspaceId: string;
+ workspaceDeletedAt: Date;
+ }): Promise<void> {
+ await this.runUninstallHook({
+ application,
+ workspaceId,
+ workspaceDeletionRequestTimestamp: workspaceDeletedAt.toISOString(),
+ payload: buildWorkspaceUninstallHookPayload({
+ applicationVersion: application.version,
+ applicationUniversalIdentifier: application.universalIdentifier,
+ workspaceId,
+ uninstallRequestedAt: workspaceDeletedAt,
+ }),
+ });
+ }
+
+ private async runUninstallHook({
+ application,
+ workspaceId,
+ payload,
+ workspaceDeletionRequestTimestamp,
+ }: {
+ application: ApplicationForUninstallHook;
+ workspaceId: string;
+ payload: UninstallHookPayload;
+ workspaceDeletionRequestTimestamp?: string;
+ }): Promise<void> {
+ if (!isDefined(application.uninstallLogicFunctionId)) {
+ return;
+ }
+
+ this.logger.log(
+ `Executing uninstall hook for application ${application.universalIdentifier}`,
+ );
+
+ const logicFunctionExecutionResult =
+ await this.logicFunctionExecutorService.execute({
+ logicFunctionId: application.uninstallLogicFunctionId,
+ workspaceId,
+ payload,
+ ...(isDefined(workspaceDeletionRequestTimestamp)
+ ? { workspaceDeletionRequestTimestamp }
+ : {}),
+ });
+
+ if (isDefined(logicFunctionExecutionResult.error)) {
+ throw new ApplicationException(
+ logicFunctionExecutionResult.error.errorMessage,
+ ApplicationExceptionCode.UNINSTALL_ERROR,
+ );
+ }
+ }
+}
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/build-workspace-uninstall-hook-payload.util.spec.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/build-workspace-uninstall-hook-payload.util.spec.ts
new file mode 100644
index 00000000000..5e0295f1243
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/build-workspace-uninstall-hook-payload.util.spec.ts
@@ -0,0 +1,18 @@
+import { buildWorkspaceUninstallHookPayload } from 'src/engine/core-modules/application/application-manifest/utils/build-workspace-uninstall-hook-payload.util';
+
+describe('buildWorkspaceUninstallHookPayload', () => {
+ it('should build a deletion-scoped idempotency key when deleting a workspace', () => {
+ expect(
+ buildWorkspaceUninstallHookPayload({
+ applicationVersion: '1.0.0',
+ applicationUniversalIdentifier: 'application-universal-identifier',
+ workspaceId: 'workspace-id',
+ uninstallRequestedAt: new Date('2026-08-18T10:00:00.000Z'),
+ }),
+ ).toEqual({
+ version: '1.0.0',
+ idempotencyKey:
+ 'workspace-deletion:workspace-id:2026-08-18T10:00:00.000Z:application-universal-identifier',
+ });
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/build-workspace-uninstall-hook-payload.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/build-workspace-uninstall-hook-payload.util.ts
new file mode 100644
index 00000000000..46544f9a718
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/build-workspace-uninstall-hook-payload.util.ts
@@ -0,0 +1,19 @@
+export type UninstallHookPayload = {
+ version?: string;
+ idempotencyKey?: string;
+};
+
+export const buildWorkspaceUninstallHookPayload = ({
+ applicationVersion,
+ applicationUniversalIdentifier,
+ workspaceId,
+ uninstallRequestedAt,
+}: {
+ applicationVersion: string | null;
+ applicationUniversalIdentifier: string;
+ workspaceId: string;
+ uninstallRequestedAt: Date;
+}): UninstallHookPayload => ({
+ version: applicationVersion ?? undefined,
+ idempotencyKey: `workspace-deletion:${workspaceId}:${uninstallRequestedAt.toISOString()}:${applicationUniversalIdentifier}`,
+});
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-rest-api-exception.filter.ts b/packages/twenty-server/src/engine/core-modules/application/application-rest-api-exception.filter.ts
index 5bf3f761a83..154366d7aef 100644
--- a/packages/twenty-server/src/engine/core-modules/application/application-rest-api-exception.filter.ts
+++ b/packages/twenty-server/src/engine/core-modules/application/application-rest-api-exception.filter.ts
@@ -41,6 +41,7 @@ const applicationExceptionCodeToHttpStatus = (
case ApplicationExceptionCode.PACKAGE_RESOLUTION_FAILED:
case ApplicationExceptionCode.POST_INSTALL_ERROR:
case ApplicationExceptionCode.PRE_INSTALL_ERROR:
+ case ApplicationExceptionCode.UNINSTALL_ERROR:
case ApplicationExceptionCode.TARBALL_EXTRACTION_FAILED:
case ApplicationExceptionCode.UPGRADE_FAILED:
case ApplicationExceptionCode.INVALID_SERVER_VERSION:
diff --git a/packages/twenty-server/src/engine/core-modules/application/application.entity.ts b/packages/twenty-server/src/engine/core-modules/application/application.entity.ts
index bafcb464673..f596ce86146 100644
--- a/packages/twenty-server/src/engine/core-modules/application/application.entity.ts
+++ b/packages/twenty-server/src/engine/core-modules/application/application.entity.ts
@@ -123,6 +123,13 @@ export class ApplicationEntity extends WorkspaceRelatedEntity {
})
uninstallLogicFunctionId: string | null;
+ @Column({ nullable: true, type: 'timestamptz' })
+ @WasIntroducedInUpgrade({
+ upgradeCommandName:
+ '2.33.0_AddUninstallHookCompletedForRequestedAtToApplicationFastInstanceCommand_1787151824000',
+ })
+ uninstallHookCompletedForRequestedAt: Date | null;
+
@Column({ nullable: false, type: 'boolean', default: true })
canBeUninstalled: boolean;
diff --git a/packages/twenty-server/src/engine/core-modules/application/application.exception.ts b/packages/twenty-server/src/engine/core-modules/application/application.exception.ts
index 95d2daa3f11..542d5cf7785 100644
--- a/packages/twenty-server/src/engine/core-modules/application/application.exception.ts
+++ b/packages/twenty-server/src/engine/core-modules/application/application.exception.ts
@@ -21,6 +21,7 @@ export enum ApplicationExceptionCode {
UPGRADE_FAILED = 'UPGRADE_FAILED',
PRE_INSTALL_ERROR = 'PRE_INSTALL_ERROR',
POST_INSTALL_ERROR = 'POST_INSTALL_ERROR',
+ UNINSTALL_ERROR = 'UNINSTALL_ERROR',
APP_ALREADY_INSTALLED = 'APP_ALREADY_INSTALLED',
CANNOT_DOWNGRADE_APPLICATION = 'CANNOT_DOWNGRADE_APPLICATION',
SERVER_VERSION_INCOMPATIBLE = 'SERVER_VERSION_INCOMPATIBLE',
@@ -66,6 +67,8 @@ const getApplicationExceptionUserFriendlyMessage = (
return msg`Application pre-install logic function failed.`;
case ApplicationExceptionCode.POST_INSTALL_ERROR:
return msg`Application post-install logic function failed.`;
+ case ApplicationExceptionCode.UNINSTALL_ERROR:
+ return msg`Application uninstall logic function failed.`;
case ApplicationExceptionCode.APP_ALREADY_INSTALLED:
return msg`This version of the application is already installed in this workspace.`;
case ApplicationExceptionCode.CANNOT_DOWNGRADE_APPLICATION:
diff --git a/packages/twenty-server/src/engine/core-modules/application/utils/__tests__/is-application-uninstall-hook-pending.util.spec.ts b/packages/twenty-server/src/engine/core-modules/application/utils/__tests__/is-application-uninstall-hook-pending.util.spec.ts
new file mode 100644
index 00000000000..c9b98ff6b31
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/application/utils/__tests__/is-application-uninstall-hook-pending.util.spec.ts
@@ -0,0 +1,55 @@
+import { isApplicationUninstallHookPending } from 'src/engine/core-modules/application/utils/is-application-uninstall-hook-pending.util';
+
+describe('isApplicationUninstallHookPending', () => {
+ const uninstallRequestedAt = new Date('2026-08-18T10:00:00.000Z');
+
+ it('should return false when the application has no uninstall hook', () => {
+ expect(
+ isApplicationUninstallHookPending(
+ {
+ uninstallLogicFunctionId: null,
+ uninstallHookCompletedForRequestedAt: null,
+ },
+ uninstallRequestedAt,
+ ),
+ ).toBe(false);
+ });
+
+ it('should return true when the hook never completed', () => {
+ expect(
+ isApplicationUninstallHookPending(
+ {
+ uninstallLogicFunctionId: 'logic-function-id',
+ uninstallHookCompletedForRequestedAt: null,
+ },
+ uninstallRequestedAt,
+ ),
+ ).toBe(true);
+ });
+
+ it('should return true when the hook only completed for an earlier request', () => {
+ expect(
+ isApplicationUninstallHookPending(
+ {
+ uninstallLogicFunctionId: 'logic-function-id',
+ uninstallHookCompletedForRequestedAt: new Date(
+ '2026-08-17T10:00:00.000Z',
+ ),
+ },
+ uninstallRequestedAt,
+ ),
+ ).toBe(true);
+ });
+
+ it('should return false when the hook completed for the same request', () => {
+ expect(
+ isApplicationUninstallHookPending(
+ {
+ uninstallLogicFunctionId: 'logic-function-id',
+ uninstallHookCompletedForRequestedAt: uninstallRequestedAt,
+ },
+ uninstallRequestedAt,
+ ),
+ ).toBe(false);
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/application/utils/is-application-uninstall-hook-pending.util.ts b/packages/twenty-server/src/engine/core-modules/application/utils/is-application-uninstall-hook-pending.util.ts
new file mode 100644
index 00000000000..7d905aaadb7
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/application/utils/is-application-uninstall-hook-pending.util.ts
@@ -0,0 +1,17 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { type ApplicationEntity } from 'src/engine/core-modules/application/application.entity';
+
+export type ApplicationUninstallHookState = Pick<
+ ApplicationEntity,
+ 'uninstallLogicFunctionId' | 'uninstallHookCompletedForRequestedAt'
+>;
+
+export const isApplicationUninstallHookPending = (
+ application: ApplicationUninstallHookState,
+ uninstallRequestedAt: Date,
+): boolean =>
+ isDefined(application.uninstallLogicFunctionId) &&
+ (!isDefined(application.uninstallHookCompletedForRequestedAt) ||
+ application.uninstallHookCompletedForRequestedAt.getTime() <
+ uninstallRequestedAt.getTime());
diff --git a/packages/twenty-server/src/engine/core-modules/auth/strategies/jwt.auth.strategy.spec.ts b/packages/twenty-server/src/engine/core-modules/auth/strategies/jwt.auth.strategy.spec.ts
index baba54800e6..93b7c7ddef7 100644
--- a/packages/twenty-server/src/engine/core-modules/auth/strategies/jwt.auth.strategy.spec.ts
+++ b/packages/twenty-server/src/engine/core-modules/auth/strategies/jwt.auth.strategy.spec.ts
@@ -1,6 +1,7 @@
import { randomUUID } from 'crypto';
import { msg } from '@lingui/core/macro';
+import { type Repository } from 'typeorm';
import {
AuthException,
@@ -23,6 +24,7 @@ describe('JwtAuthStrategy', () => {
let twentyConfigService: any;
let workspaceCacheService: any;
let coreEntityCacheService: any;
+ let workspaceRepository: { findOne: jest.Mock };
const jwt = {
sub: 'sub-default',
@@ -43,6 +45,9 @@ describe('JwtAuthStrategy', () => {
userWorkspaceRepository = {
findOne: jest.fn(),
};
+ workspaceRepository = {
+ findOne: jest.fn(),
+ };
jwtWrapperService = {
extractJwtFromRequest: jest.fn(() => () => 'token'),
@@ -134,6 +139,7 @@ describe('JwtAuthStrategy', () => {
permissionsService,
twentyConfigService,
),
+ workspaceRepository as unknown as Repository<WorkspaceEntity>,
);
describe('API_KEY validation', () => {
@@ -403,6 +409,79 @@ describe('JwtAuthStrategy', () => {
});
describe('APPLICATION_ACCESS token validation', () => {
+ it('should allow a cleanup token when its exact workspace deletion is pending', async () => {
+ const applicationId = randomUUID();
+ const workspaceId = randomUUID();
+ const workspaceDeletedAt = new Date('2026-08-18T10:00:00.000Z');
+ const workspace = Object.assign(new WorkspaceEntity(), {
+ id: workspaceId,
+ createdAt: new Date('2026-08-01T10:00:00.000Z'),
+ updatedAt: new Date('2026-08-18T10:00:00.000Z'),
+ deletedAt: workspaceDeletedAt,
+ });
+ const application = { id: applicationId };
+
+ workspaceRepository.findOne.mockResolvedValue(workspace);
+ applicationStore[workspaceId] = { [applicationId]: application };
+
+ strategy = createStrategy();
+
+ await expect(
+ strategy.validate({
+ sub: applicationId,
+ type: JwtTokenTypeEnum.APPLICATION_ACCESS,
+ applicationId,
+ workspaceId,
+ workspaceDeletionRequestTimestamp: workspaceDeletedAt.toISOString(),
+ } as JwtPayload),
+ ).resolves.toMatchObject({
+ application,
+ workspace: {
+ id: workspaceId,
+ deletedAt: workspaceDeletedAt.toISOString(),
+ },
+ tokenType: JwtTokenTypeEnum.APPLICATION_ACCESS,
+ });
+ });
+
+ it('should reject a cleanup token when it belongs to a different deletion request', async () => {
+ const applicationId = randomUUID();
+ const workspaceId = randomUUID();
+
+ workspaceStore[workspaceId] = Object.assign(new WorkspaceEntity(), {
+ id: workspaceId,
+ deletedAt: null,
+ });
+
+ workspaceRepository.findOne.mockResolvedValue(
+ Object.assign(new WorkspaceEntity(), {
+ id: workspaceId,
+ createdAt: new Date('2026-08-01T10:00:00.000Z'),
+ updatedAt: new Date('2026-08-18T10:00:00.000Z'),
+ deletedAt: new Date('2026-08-18T10:00:00.000Z'),
+ }),
+ );
+
+ strategy = createStrategy();
+
+ await expect(
+ strategy.validate({
+ sub: applicationId,
+ type: JwtTokenTypeEnum.APPLICATION_ACCESS,
+ applicationId,
+ workspaceId,
+ workspaceDeletionRequestTimestamp: '2026-08-17T10:00:00.000Z',
+ } as JwtPayload),
+ ).rejects.toMatchObject({
+ code: AuthExceptionCode.FORBIDDEN_EXCEPTION,
+ message: 'Workspace deletion request not found',
+ });
+ expect(workspaceRepository.findOne).toHaveBeenCalledWith({
+ where: { id: workspaceId },
+ withDeleted: true,
+ });
+ });
+
it('should throw AuthExceptionCode if type is APPLICATION_ACCESS, and application not found', async () => {
const validApplicationId = randomUUID();
const validWorkspaceId = randomUUID();
diff --git a/packages/twenty-server/src/engine/core-modules/auth/strategies/jwt.auth.strategy.ts b/packages/twenty-server/src/engine/core-modules/auth/strategies/jwt.auth.strategy.ts
index a84d5a8bf86..479539696f7 100644
--- a/packages/twenty-server/src/engine/core-modules/auth/strategies/jwt.auth.strategy.ts
+++ b/packages/twenty-server/src/engine/core-modules/auth/strategies/jwt.auth.strategy.ts
@@ -26,6 +26,10 @@ import { JWT_SUPPORTED_VERIFY_ALGORITHMS } from 'src/engine/core-modules/jwt/con
import { JwtWrapperService } from 'src/engine/core-modules/jwt/services/jwt-wrapper.service';
import { type FlatUserWorkspace } from 'src/engine/core-modules/user-workspace/types/flat-user-workspace.type';
import { UserWorkspaceEntity } from 'src/engine/core-modules/user-workspace/user-workspace.entity';
+import { type FlatWorkspace } from 'src/engine/core-modules/workspace/types/flat-workspace.type';
+import { fromWorkspaceEntityToFlat } from 'src/engine/core-modules/workspace/utils/from-workspace-entity-to-flat.util';
+import { isWorkspaceDeletionRequestPending } from 'src/engine/core-modules/workspace/utils/is-workspace-deletion-request-pending.util';
+import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
import { assertIsDefinedOrThrow, isDefined } from 'twenty-shared/utils';
import { WorkspaceActivationStatus } from 'twenty-shared/workspace';
@@ -40,6 +44,8 @@ export class JwtAuthStrategy extends PassportStrategy(Strategy, 'jwt') {
private readonly workspaceCacheService: WorkspaceCacheService,
private readonly coreEntityCacheService: CoreEntityCacheService,
private readonly impersonationAuthorizationService: ImpersonationAuthorizationService,
+ @InjectRepository(WorkspaceEntity)
+ private readonly workspaceRepository: Repository<WorkspaceEntity>,
) {
const secretOrKeyProvider: SecretOrKeyProvider = (
_request,
@@ -326,10 +332,7 @@ export class JwtAuthStrategy extends PassportStrategy(Strategy, 'jwt') {
private async validateApplicationToken(
payload: ApplicationAccessTokenJwtPayload,
): Promise<AuthContext> {
- const workspace = await this.coreEntityCacheService.get(
- 'workspaceEntity',
- payload.workspaceId,
- );
+ const workspace = await this.resolveWorkspaceForApplicationToken(payload);
if (!isDefined(workspace)) {
throw new AuthException(
@@ -421,6 +424,36 @@ export class JwtAuthStrategy extends PassportStrategy(Strategy, 'jwt') {
return context;
}
+ private async resolveWorkspaceForApplicationToken(
+ payload: ApplicationAccessTokenJwtPayload,
+ ): Promise<FlatWorkspace | null> {
+ if (!isDefined(payload.workspaceDeletionRequestTimestamp)) {
+ return this.coreEntityCacheService.get(
+ 'workspaceEntity',
+ payload.workspaceId,
+ );
+ }
+
+ const deletedWorkspace = await this.workspaceRepository.findOne({
+ where: { id: payload.workspaceId },
+ withDeleted: true,
+ });
+
+ if (
+ !isWorkspaceDeletionRequestPending(
+ deletedWorkspace,
+ payload.workspaceDeletionRequestTimestamp,
+ )
+ ) {
+ throw new AuthException(
+ 'Workspace deletion request not found',
+ AuthExceptionCode.FORBIDDEN_EXCEPTION,
+ );
+ }
+
+ return fromWorkspaceEntityToFlat(deletedWorkspace);
+ }
+
private isLegacyApiKeyPayload(
payload: JwtPayload,
): payload is ApiKeyTokenJwtPayload {
diff --git a/packages/twenty-server/src/engine/core-modules/auth/token/services/application-token.service.ts b/packages/twenty-server/src/engine/core-modules/auth/token/services/application-token.service.ts
index 8892a166543..bf446471952 100644
--- a/packages/twenty-server/src/engine/core-modules/auth/token/services/application-token.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/auth/token/services/application-token.service.ts
@@ -8,6 +8,7 @@ import ms from 'ms';
import { JwtWrapperService } from 'src/engine/core-modules/jwt/services/jwt-wrapper.service';
import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
+import { isWorkspaceDeletionRequestPending } from 'src/engine/core-modules/workspace/utils/is-workspace-deletion-request-pending.util';
import { type ApplicationAccessTokenJwtPayload } from 'src/engine/core-modules/auth/types/application-access-token-jwt-payload.type';
import { type ApplicationRefreshTokenJwtPayload } from 'src/engine/core-modules/auth/types/application-refresh-token-jwt-payload.type';
import { JwtTokenTypeEnum } from 'src/engine/core-modules/auth/types/jwt-token-type.enum';
@@ -66,6 +67,57 @@ export class ApplicationTokenService {
});
}
+ async generateWorkspaceDeletionApplicationAccessToken({
+ workspaceId,
+ applicationId,
+ workspaceDeletionRequestTimestamp,
+ }: {
+ workspaceId: string;
+ applicationId: string;
+ workspaceDeletionRequestTimestamp: string;
+ }): Promise<AuthToken> {
+ const workspace = await this.workspaceRepository.findOne({
+ where: { id: workspaceId },
+ withDeleted: true,
+ });
+
+ if (
+ !isWorkspaceDeletionRequestPending(
+ workspace,
+ workspaceDeletionRequestTimestamp,
+ )
+ ) {
+ throw new AuthException(
+ 'Workspace deletion request not found',
+ AuthExceptionCode.FORBIDDEN_EXCEPTION,
+ );
+ }
+
+ const application = await this.applicationRepository.findOne({
+ where: { id: applicationId, workspaceId },
+ });
+
+ assertIsDefinedOrThrow(
+ application,
+ new ApplicationException(
+ 'Application not found',
+ ApplicationExceptionCode.APPLICATION_NOT_FOUND,
+ ),
+ );
+
+ const expiresIn = this.twentyConfigService.get(
+ 'APPLICATION_ACCESS_TOKEN_EXPIRES_IN',
+ );
+
+ return this.signApplicationToken({
+ workspaceId,
+ applicationId,
+ tokenType: JwtTokenTypeEnum.APPLICATION_ACCESS,
+ expiresIn,
+ workspaceDeletionRequestTimestamp,
+ });
+ }
+
async generateApplicationTokenPair({
workspaceId,
applicationId,
@@ -237,6 +289,7 @@ export class ApplicationTokenService {
userId,
tokenType,
expiresIn,
+ workspaceDeletionRequestTimestamp,
}: {
workspaceId: string;
applicationId: string;
@@ -246,6 +299,7 @@ export class ApplicationTokenService {
| JwtTokenTypeEnum.APPLICATION_ACCESS
| JwtTokenTypeEnum.APPLICATION_REFRESH;
expiresIn: string;
+ workspaceDeletionRequestTimestamp?: string;
}): Promise<AuthToken> {
const expiresAt = addMilliseconds(new Date().getTime(), ms(expiresIn));
@@ -256,6 +310,9 @@ export class ApplicationTokenService {
applicationId,
workspaceId,
type: tokenType,
+ ...(workspaceDeletionRequestTimestamp
+ ? { workspaceDeletionRequestTimestamp }
+ : {}),
...(userWorkspaceId ? { userWorkspaceId } : {}),
...(userId ? { userId } : {}),
};
diff --git a/packages/twenty-server/src/engine/core-modules/auth/types/application-access-token-jwt-payload.type.ts b/packages/twenty-server/src/engine/core-modules/auth/types/application-access-token-jwt-payload.type.ts
index da03a1dc68b..d50e7b8eb1d 100644
--- a/packages/twenty-server/src/engine/core-modules/auth/types/application-access-token-jwt-payload.type.ts
+++ b/packages/twenty-server/src/engine/core-modules/auth/types/application-access-token-jwt-payload.type.ts
@@ -7,4 +7,5 @@ export type ApplicationAccessTokenJwtPayload = CommonPropertiesJwtPayload & {
applicationId: string;
userWorkspaceId?: string;
userId?: string;
+ workspaceDeletionRequestTimestamp?: string;
};
diff --git a/packages/twenty-server/src/engine/core-modules/billing-webhook/services/billing-webhook-subscription.service.ts b/packages/twenty-server/src/engine/core-modules/billing-webhook/services/billing-webhook-subscription.service.ts
index 221a229711a..0413ba1a10b 100644
--- a/packages/twenty-server/src/engine/core-modules/billing-webhook/services/billing-webhook-subscription.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/billing-webhook/services/billing-webhook-subscription.service.ts
@@ -223,7 +223,7 @@ export class BillingWebhookSubscriptionService {
if (!isDefined(refreshedWorkspace.deletedAt)) {
switch (refreshedWorkspace.activationStatus) {
case WorkspaceActivationStatus.PENDING_CREATION:
- await this.workspaceService.deleteWorkspace(workspaceId);
+ await this.workspaceService.deleteWorkspace(workspaceId, true);
break;
case WorkspaceActivationStatus.ACTIVE:
await this.workspaceService.suspendWorkspace(workspaceId);
diff --git a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-executor/logic-function-executor.service.ts b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-executor/logic-function-executor.service.ts
index 6eb88f3979b..8ac5f74c827 100644
--- a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-executor/logic-function-executor.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-executor/logic-function-executor.service.ts
@@ -115,6 +115,7 @@ export class LogicFunctionExecutorService {
userId,
userWorkspaceId,
executionMode,
+ workspaceDeletionRequestTimestamp,
retry = { retryCount: 0, maxRetries: 0 },
}: {
logicFunctionId: string;
@@ -123,6 +124,7 @@ export class LogicFunctionExecutorService {
userId?: string;
userWorkspaceId?: string;
executionMode?: LogicFunctionExecutionMode;
+ workspaceDeletionRequestTimestamp?: string;
retry?: LogicFunctionRetryContext;
}): Promise<LogicFunctionExecuteResult> {
const { flatApplication, flatLogicFunction, applicationVariableMaps } =
@@ -143,6 +145,7 @@ export class LogicFunctionExecutorService {
applicationVariableMaps,
userId,
userWorkspaceId,
+ workspaceDeletionRequestTimestamp,
});
const context = await this.buildExecutionContext({
@@ -376,23 +379,33 @@ export class LogicFunctionExecutorService {
applicationVariableMaps,
userId,
userWorkspaceId,
+ workspaceDeletionRequestTimestamp,
}: {
workspaceId: string;
flatApplication: FlatApplication;
applicationVariableMaps: ApplicationVariableCacheMaps;
userId?: string;
userWorkspaceId?: string;
+ workspaceDeletionRequestTimestamp?: string;
}) {
// Two tokens so a handler can choose per call which access it acts with,
// rather than the whole run being locked to one of them.
const hasTriggeringPerson = isDefined(userId) && isDefined(userWorkspaceId);
const [applicationAccessToken, delegatedAccessToken] = await Promise.all([
- this.applicationTokenService.generateApplicationAccessToken({
- workspaceId,
- applicationId: flatApplication.id,
- }),
- hasTriggeringPerson
+ isDefined(workspaceDeletionRequestTimestamp)
+ ? this.applicationTokenService.generateWorkspaceDeletionApplicationAccessToken(
+ {
+ workspaceId,
+ applicationId: flatApplication.id,
+ workspaceDeletionRequestTimestamp,
+ },
+ )
+ : this.applicationTokenService.generateApplicationAccessToken({
+ workspaceId,
+ applicationId: flatApplication.id,
+ }),
+ hasTriggeringPerson && !isDefined(workspaceDeletionRequestTimestamp)
? this.applicationTokenService.generateApplicationAccessToken({
workspaceId,
applicationId: flatApplication.id,
@@ -444,6 +457,7 @@ export class LogicFunctionExecutorService {
const workspace = await this.workspaceRepository.findOne({
where: { id: workspaceId },
select: { subdomain: true },
+ withDeleted: true,
});
if (!isDefined(workspace)) {
diff --git a/packages/twenty-server/src/engine/core-modules/message-queue/jobs.module.ts b/packages/twenty-server/src/engine/core-modules/message-queue/jobs.module.ts
index 2d7e5c1085d..94a912a6b7e 100644
--- a/packages/twenty-server/src/engine/core-modules/message-queue/jobs.module.ts
+++ b/packages/twenty-server/src/engine/core-modules/message-queue/jobs.module.ts
@@ -13,6 +13,7 @@ import { BillingReminderModule } from 'src/engine/core-modules/billing/reminders
import { BillingReminderCronJob } from 'src/engine/core-modules/billing/reminders/crons/billing-reminder.cron.job';
import { StripeModule } from 'src/engine/core-modules/billing/stripe/stripe.module';
import { ApplicationInstallModule } from 'src/engine/core-modules/application/application-install/application-install.module';
+import { ApplicationManifestModule } from 'src/engine/core-modules/application/application-manifest/application-manifest.module';
import { ApplicationRegistrationModule } from 'src/engine/core-modules/application/application-registration/application-registration.module';
import { ApplicationUpgradeModule } from 'src/engine/core-modules/application/application-upgrade/application-upgrade.module';
import { UpgradeApplicationsJob } from 'src/engine/core-modules/application/jobs/upgrade-applications.job';
@@ -36,6 +37,7 @@ import { UpdateWorkspaceMemberEmailJob } from 'src/engine/core-modules/user/jobs
import { UserVarsModule } from 'src/engine/core-modules/user/user-vars/user-vars.module';
import { UserModule } from 'src/engine/core-modules/user/user.module';
import { HandleWorkspaceMemberDeletedJob } from 'src/engine/core-modules/workspace/handle-workspace-member-deleted.job';
+import { WorkspaceDeletionApplicationUninstallJob } from 'src/engine/core-modules/workspace/jobs/workspace-deletion-application-uninstall.job';
import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
import { WorkspaceModule } from 'src/engine/core-modules/workspace/workspace.module';
import { AiAgentMonitorModule } from 'src/engine/metadata-modules/ai/ai-agent-monitor/ai-agent-monitor.module';
@@ -95,6 +97,7 @@ import { WorkflowModule } from 'src/modules/workflow/workflow.module';
EnterpriseModule,
EmailingModule,
ApplicationInstallModule,
+ ApplicationManifestModule,
ApplicationRegistrationModule,
ApplicationUpgradeModule,
PreInstalledAppsModule,
@@ -111,6 +114,7 @@ import { WorkflowModule } from 'src/modules/workflow/workflow.module';
RefreshCampaignStatsJob,
UpdateSubscriptionQuantityJob,
HandleWorkspaceMemberDeletedJob,
+ WorkspaceDeletionApplicationUninstallJob,
CleanWorkspaceDeletionWarningUserVarsJob,
UpdateWorkspaceMemberEmailJob,
GenerateSdkClientJob,
diff --git a/packages/twenty-server/src/engine/core-modules/workspace/jobs/workspace-deletion-application-uninstall.job.ts b/packages/twenty-server/src/engine/core-modules/workspace/jobs/workspace-deletion-application-uninstall.job.ts
new file mode 100644
index 00000000000..841ad800c6d
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workspace/jobs/workspace-deletion-application-uninstall.job.ts
@@ -0,0 +1,64 @@
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { type Repository } from 'typeorm';
+
+import { PostgresAdvisoryLockService } from 'src/database/typeorm/postgres-advisory-lock.service';
+import { ApplicationUninstallService } from 'src/engine/core-modules/application/application-manifest/services/application-uninstall.service';
+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 { getWorkspaceApplicationUninstallLockName } from 'src/engine/core-modules/workspace/utils/get-workspace-application-uninstall-lock-name.util';
+import { isWorkspaceDeletionPending } from 'src/engine/core-modules/workspace/utils/is-workspace-deletion-pending.util';
+import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
+import {
+ WorkspaceException,
+ WorkspaceExceptionCode,
+} from 'src/engine/core-modules/workspace/workspace.exception';
+
+export type WorkspaceDeletionApplicationUninstallJobData = {
+ workspaceId: string;
+};
+
+@Processor(MessageQueue.logicFunctionQueue)
+export class WorkspaceDeletionApplicationUninstallJob {
+ constructor(
+ @InjectRepository(WorkspaceEntity)
+ private readonly workspaceRepository: Repository<WorkspaceEntity>,
+ private readonly applicationUninstallService: ApplicationUninstallService,
+ private readonly postgresAdvisoryLockService: PostgresAdvisoryLockService,
+ ) {}
+
+ @Process(WorkspaceDeletionApplicationUninstallJob.name)
+ async handle({
+ workspaceId,
+ }: WorkspaceDeletionApplicationUninstallJobData): Promise<void> {
+ const advisoryLockResult =
+ await this.postgresAdvisoryLockService.tryWithLock(
+ getWorkspaceApplicationUninstallLockName(workspaceId),
+ async () => {
+ const workspace = await this.workspaceRepository.findOne({
+ where: { id: workspaceId },
+ withDeleted: true,
+ });
+
+ if (!isWorkspaceDeletionPending(workspace)) {
+ return;
+ }
+
+ await this.applicationUninstallService.runUninstallHooksForWorkspaceDeletion(
+ {
+ workspaceId,
+ workspaceDeletedAt: workspace.deletedAt,
+ },
+ );
+ },
+ );
+
+ if (!advisoryLockResult.acquired) {
+ throw new WorkspaceException(
+ `Workspace ${workspaceId} application uninstall is already running`,
+ WorkspaceExceptionCode.APPLICATION_UNINSTALL_IN_PROGRESS,
+ );
+ }
+ }
+}
diff --git a/packages/twenty-server/src/engine/core-modules/workspace/services/workspace.service.ts b/packages/twenty-server/src/engine/core-modules/workspace/services/workspace.service.ts
index 45e6bcb10f2..39edc578653 100644
--- a/packages/twenty-server/src/engine/core-modules/workspace/services/workspace.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/workspace/services/workspace.service.ts
@@ -17,9 +17,11 @@ import {
Repository,
} from 'typeorm';
+import { PostgresAdvisoryLockService } from 'src/database/typeorm/postgres-advisory-lock.service';
import { CoreEntityCacheService } from 'src/engine/core-entity-cache/services/core-entity-cache.service';
import { ApiKeyEntity } from 'src/engine/core-modules/api-key/api-key.entity';
import { ApplicationService } from 'src/engine/core-modules/application/application.service';
+import { ApplicationUninstallService } from 'src/engine/core-modules/application/application-manifest/services/application-uninstall.service';
import { PreInstalledAppsService } from 'src/engine/core-modules/application/pre-installed-apps/pre-installed-apps.service';
import { type AuthContextUser } from 'src/engine/core-modules/auth/types/auth-context.type';
import { BillingSubscriptionService } from 'src/engine/core-modules/billing/services/billing-subscription.service';
@@ -39,6 +41,7 @@ import {
FileWorkspaceFolderDeletionJob,
type FileWorkspaceFolderDeletionJobData,
} from 'src/engine/core-modules/file/jobs/file-workspace-folder-deletion.job';
+import { LOGIC_FUNCTION_QUEUE_RETRY_BACKOFF } from 'src/engine/core-modules/logic-function/logic-function-trigger/constants/logic-function-queue-retry-backoff.constant';
import { InjectMessageQueue } from 'src/engine/core-modules/message-queue/decorators/message-queue.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';
@@ -50,6 +53,11 @@ import { UserWorkspaceEntity } from 'src/engine/core-modules/user-workspace/user
import { UserWorkspaceService } from 'src/engine/core-modules/user-workspace/user-workspace.service';
import { UserEntity } from 'src/engine/core-modules/user/user.entity';
import { WORKSPACE_FIELDS_UPDATABLE_BEFORE_ACTIVATION } from 'src/engine/core-modules/workspace/constants/workspace-fields-updatable-before-activation.constant';
+import {
+ WorkspaceDeletionApplicationUninstallJob,
+ type WorkspaceDeletionApplicationUninstallJobData,
+} from 'src/engine/core-modules/workspace/jobs/workspace-deletion-application-uninstall.job';
+import { getWorkspaceApplicationUninstallLockName } from 'src/engine/core-modules/workspace/utils/get-workspace-application-uninstall-lock-name.util';
import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
import {
WorkspaceException,
@@ -88,6 +96,7 @@ import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspa
// PENDING_CREATION) and may be retried. It is far longer than a real activation
// takes, so a genuinely in-progress activation is never reclaimed.
const WORKSPACE_ACTIVATION_STALE_LOCK_TIMEOUT_MS = 5 * 60 * 1000;
+const WORKSPACE_APPLICATION_UNINSTALL_RETRY_LIMIT = 3;
@Injectable()
// oxlint-disable-next-line twenty/inject-workspace-repository
@@ -150,13 +159,17 @@ export class WorkspaceService {
private readonly fileCorePictureService: FileCorePictureService,
private readonly aiModelRegistryService: AiModelRegistryService,
@InjectMessageQueue(MessageQueue.deleteCascadeQueue)
- private readonly messageQueueService: MessageQueueService,
+ private readonly deleteCascadeMessageQueueService: MessageQueueService,
+ @InjectMessageQueue(MessageQueue.logicFunctionQueue)
+ private readonly logicFunctionMessageQueueService: MessageQueueService,
@InjectDataSource()
private readonly coreDataSource: DataSource,
private readonly coreEntityCacheService: CoreEntityCacheService,
private readonly upgradeMigrationService: UpgradeMigrationService,
private readonly upgradeSequenceReaderService: UpgradeSequenceReaderService,
private readonly sdkClientGenerationService: SdkClientGenerationService,
+ private readonly postgresAdvisoryLockService: PostgresAdvisoryLockService,
+ private readonly applicationUninstallService: ApplicationUninstallService,
) {}
async updateWorkspaceById({
@@ -496,6 +509,7 @@ export class WorkspaceService {
}
async suspendWorkspace(id: string): Promise<boolean> {
+ const workspaceSuspendedAt = new Date();
const { affected } = await this.workspaceRepository.update(
{
id,
@@ -504,7 +518,7 @@ export class WorkspaceService {
},
{
activationStatus: WorkspaceActivationStatus.SUSPENDED,
- suspendedAt: new Date(),
+ suspendedAt: workspaceSuspendedAt,
},
);
@@ -550,6 +564,10 @@ export class WorkspaceService {
assert(workspace, 'Workspace not found');
+ if (!softDelete) {
+ return this.hardDeleteWorkspaceWithApplicationUninstallLock(workspace);
+ }
+
const userWorkspaces = await this.userWorkspaceRepository.find({
where: {
workspaceId: id,
@@ -558,74 +576,146 @@ export class WorkspaceService {
});
for (const userWorkspace of userWorkspaces) {
- await this.handleRemoveWorkspaceMember(
- id,
- userWorkspace.userId,
- softDelete,
- );
+ await this.handleRemoveWorkspaceMember(id, userWorkspace.userId, true);
}
this.logger.log(`workspace ${id} user workspaces deleted`);
this.logger.log(`workspace ${id} cache flushed`);
- if (softDelete) {
- if (this.billingService.isBillingEnabled()) {
- await this.billingSubscriptionService.cancelSubscription(workspace.id);
- }
+ if (this.billingService.isBillingEnabled()) {
+ await this.billingSubscriptionService.cancelSubscription(workspace.id);
+ }
- await this.workspaceRepository.softDelete({ id });
- await this.coreEntityCacheService.invalidate('workspaceEntity', id);
+ await this.workspaceRepository.softDelete({ id, deletedAt: IsNull() });
+ await this.coreEntityCacheService.invalidate('workspaceEntity', id);
+ await this.enqueueWorkspaceDeletionApplicationUninstall(id);
- this.logger.log(`workspace ${id} soft deleted`);
+ this.logger.log(`workspace ${id} soft deleted`);
- return workspace;
- }
+ return workspace;
+ }
- if (this.billingService.isBillingEnabled()) {
- await this.billingSubscriptionService.assertSubscriptionCanceledOrNone(
- workspace.id,
- );
- }
+ private async hardDeleteWorkspaceWithApplicationUninstallLock(
+ workspace: WorkspaceEntity,
+ ): Promise<WorkspaceEntity> {
+ const advisoryLockResult =
+ await this.postgresAdvisoryLockService.tryWithLock(
+ getWorkspaceApplicationUninstallLockName(workspace.id),
+ async () => {
+ const userWorkspaces = await this.userWorkspaceRepository.find({
+ where: {
+ workspaceId: workspace.id,
+ },
+ withDeleted: true,
+ });
- await this.deleteWorkspaceSyncableMetadataEntities(workspace);
+ for (const userWorkspace of userWorkspaces) {
+ await this.handleRemoveWorkspaceMember(
+ workspace.id,
+ userWorkspace.userId,
+ false,
+ );
+ }
+ this.logger.log(`workspace ${workspace.id} user workspaces deleted`);
- await this.workspaceDataSourceService.deleteWorkspaceDBSchema(workspace.id);
+ this.logger.log(`workspace ${workspace.id} cache flushed`);
- await this.workspaceCacheStorageService.flush(workspace.id);
- await this.flatEntityMapsCacheService.flushFlatEntityMaps({
- workspaceId: workspace.id,
- });
+ if (this.billingService.isBillingEnabled()) {
+ await this.billingSubscriptionService.assertSubscriptionCanceledOrNone(
+ workspace.id,
+ );
+ }
- await this.messageQueueService.add<FileWorkspaceFolderDeletionJobData>(
- FileWorkspaceFolderDeletionJob.name,
- { workspaceId: id },
- );
+ await this.runPendingApplicationUninstallHooksBeforeHardDelete(
+ workspace,
+ );
- const emailingDomains = await this.coreDataSource
- .getRepository(EmailingDomainEntity)
- .find({ where: { workspaceId: id } });
+ await this.deleteWorkspaceSyncableMetadataEntities(workspace);
- await this.messageQueueService.add<EmailingDomainWorkspaceCleanupJobData>(
- EmailingDomainWorkspaceCleanupJob.name,
- {
- workspaceId: id,
- domains: emailingDomains.map((emailingDomain) => emailingDomain.domain),
- },
- );
+ await this.workspaceDataSourceService.deleteWorkspaceDBSchema(
+ workspace.id,
+ );
- if (workspace.customDomain) {
- await this.dnsManagerService.deleteHostnameSilently(
- workspace.customDomain,
+ await this.workspaceCacheStorageService.flush(workspace.id);
+ await this.flatEntityMapsCacheService.flushFlatEntityMaps({
+ workspaceId: workspace.id,
+ });
+
+ await this.deleteCascadeMessageQueueService.add<FileWorkspaceFolderDeletionJobData>(
+ FileWorkspaceFolderDeletionJob.name,
+ { workspaceId: workspace.id },
+ );
+
+ const emailingDomains = await this.coreDataSource
+ .getRepository(EmailingDomainEntity)
+ .find({ where: { workspaceId: workspace.id } });
+
+ await this.deleteCascadeMessageQueueService.add<EmailingDomainWorkspaceCleanupJobData>(
+ EmailingDomainWorkspaceCleanupJob.name,
+ {
+ workspaceId: workspace.id,
+ domains: emailingDomains.map(
+ (emailingDomain) => emailingDomain.domain,
+ ),
+ },
+ );
+
+ if (workspace.customDomain) {
+ await this.dnsManagerService.deleteHostnameSilently(
+ workspace.customDomain,
+ );
+ this.logger.log(`workspace ${workspace.id} custom domain deleted`);
+ }
+
+ await this.workspaceRepository.delete(workspace.id);
+ await this.coreEntityCacheService.invalidate(
+ 'workspaceEntity',
+ workspace.id,
+ );
+
+ this.logger.log(`workspace ${workspace.id} hard deleted`);
+
+ return workspace;
+ },
+ );
+
+ if (!advisoryLockResult.acquired) {
+ throw new WorkspaceException(
+ `Cannot hard delete workspace ${workspace.id} while application uninstall is running`,
+ WorkspaceExceptionCode.APPLICATION_UNINSTALL_IN_PROGRESS,
);
- this.logger.log(`workspace ${id} custom domain deleted`);
}
- await this.workspaceRepository.delete(id);
- await this.coreEntityCacheService.invalidate('workspaceEntity', id);
+ return advisoryLockResult.value;
+ }
- this.logger.log(`workspace ${id} hard deleted`);
+ async enqueueWorkspaceDeletionApplicationUninstall(
+ workspaceId: string,
+ ): Promise<void> {
+ await this.logicFunctionMessageQueueService.add<WorkspaceDeletionApplicationUninstallJobData>(
+ WorkspaceDeletionApplicationUninstallJob.name,
+ { workspaceId },
+ {
+ id: `${WorkspaceDeletionApplicationUninstallJob.name}-${workspaceId}`,
+ retryLimit: WORKSPACE_APPLICATION_UNINSTALL_RETRY_LIMIT,
+ backoff: LOGIC_FUNCTION_QUEUE_RETRY_BACKOFF,
+ },
+ );
+ }
- return workspace;
+ private async runPendingApplicationUninstallHooksBeforeHardDelete(
+ workspace: WorkspaceEntity,
+ ): Promise<void> {
+ if (!isDefined(workspace.deletedAt)) {
+ return;
+ }
+
+ await this.applicationUninstallService.runUninstallHooksForWorkspaceDeletionBestEffort(
+ {
+ workspaceId: workspace.id,
+ workspaceDeletedAt: workspace.deletedAt,
+ },
+ );
}
private async deleteWorkspaceSyncableMetadataEntities(
diff --git a/packages/twenty-server/src/engine/core-modules/workspace/utils/__tests__/is-workspace-deletion-pending.util.spec.ts b/packages/twenty-server/src/engine/core-modules/workspace/utils/__tests__/is-workspace-deletion-pending.util.spec.ts
new file mode 100644
index 00000000000..183378d3bb9
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workspace/utils/__tests__/is-workspace-deletion-pending.util.spec.ts
@@ -0,0 +1,21 @@
+import { isWorkspaceDeletionPending } from 'src/engine/core-modules/workspace/utils/is-workspace-deletion-pending.util';
+
+describe('isWorkspaceDeletionPending', () => {
+ const workspaceDeletedAt = new Date('2026-08-18T10:00:00.000Z');
+
+ it('should return true when the workspace is soft deleted', () => {
+ expect(
+ isWorkspaceDeletionPending({
+ deletedAt: workspaceDeletedAt,
+ }),
+ ).toBe(true);
+ });
+
+ it('should return false when the workspace is not soft deleted', () => {
+ expect(
+ isWorkspaceDeletionPending({
+ deletedAt: undefined,
+ }),
+ ).toBe(false);
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/workspace/utils/__tests__/is-workspace-deletion-request-pending.util.spec.ts b/packages/twenty-server/src/engine/core-modules/workspace/utils/__tests__/is-workspace-deletion-request-pending.util.spec.ts
new file mode 100644
index 00000000000..57a75ca1bac
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workspace/utils/__tests__/is-workspace-deletion-request-pending.util.spec.ts
@@ -0,0 +1,20 @@
+import { isWorkspaceDeletionRequestPending } from 'src/engine/core-modules/workspace/utils/is-workspace-deletion-request-pending.util';
+
+describe('isWorkspaceDeletionRequestPending', () => {
+ it('should match only when the exact deletion request is pending', () => {
+ const workspaceDeletedAt = new Date('2026-08-18T10:00:00.000Z');
+ const workspace = {
+ deletedAt: workspaceDeletedAt,
+ };
+
+ expect(
+ isWorkspaceDeletionRequestPending(
+ workspace,
+ workspaceDeletedAt.toISOString(),
+ ),
+ ).toBe(true);
+ expect(
+ isWorkspaceDeletionRequestPending(workspace, '2026-08-17T10:00:00.000Z'),
+ ).toBe(false);
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/workspace/utils/__tests__/workspace-graphql-api-exception-handler.util.spec.ts b/packages/twenty-server/src/engine/core-modules/workspace/utils/__tests__/workspace-graphql-api-exception-handler.util.spec.ts
index 8f94adcc51f..c852bc860b7 100644
--- a/packages/twenty-server/src/engine/core-modules/workspace/utils/__tests__/workspace-graphql-api-exception-handler.util.spec.ts
+++ b/packages/twenty-server/src/engine/core-modules/workspace/utils/__tests__/workspace-graphql-api-exception-handler.util.spec.ts
@@ -42,6 +42,17 @@ describe('workspaceGraphqlApiExceptionHandler', () => {
);
});
+ it('should throw ConflictError when application uninstall blocks reactivation', () => {
+ const error = new WorkspaceException(
+ 'Application uninstall in progress',
+ WorkspaceExceptionCode.APPLICATION_UNINSTALL_IN_PROGRESS,
+ );
+
+ expect(() => workspaceGraphqlApiExceptionHandler(error)).toThrow(
+ ConflictError,
+ );
+ });
+
it('should throw the original error if it is not a WorkspaceException', () => {
const genericError = new Error('Generic error');
diff --git a/packages/twenty-server/src/engine/core-modules/workspace/utils/get-workspace-application-uninstall-lock-name.util.ts b/packages/twenty-server/src/engine/core-modules/workspace/utils/get-workspace-application-uninstall-lock-name.util.ts
new file mode 100644
index 00000000000..c4aff25ce9d
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workspace/utils/get-workspace-application-uninstall-lock-name.util.ts
@@ -0,0 +1,2 @@
+export const getWorkspaceApplicationUninstallLockName = (workspaceId: string) =>
+ `workspace-application-uninstall-${workspaceId}`;
diff --git a/packages/twenty-server/src/engine/core-modules/workspace/utils/is-workspace-deletion-pending.util.ts b/packages/twenty-server/src/engine/core-modules/workspace/utils/is-workspace-deletion-pending.util.ts
new file mode 100644
index 00000000000..d15a72aae62
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workspace/utils/is-workspace-deletion-pending.util.ts
@@ -0,0 +1,10 @@
+import { isDefined } from 'twenty-shared/utils';
+
+import { type WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
+
+export type WorkspaceDeletionState = Pick<WorkspaceEntity, 'deletedAt'>;
+
+export const isWorkspaceDeletionPending = (
+ workspace: WorkspaceDeletionState | null | undefined,
+): workspace is WorkspaceDeletionState & { deletedAt: Date } =>
+ isDefined(workspace) && isDefined(workspace.deletedAt);
diff --git a/packages/twenty-server/src/engine/core-modules/workspace/utils/is-workspace-deletion-request-pending.util.ts b/packages/twenty-server/src/engine/core-modules/workspace/utils/is-workspace-deletion-request-pending.util.ts
new file mode 100644
index 00000000000..8cf7eae8db1
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/workspace/utils/is-workspace-deletion-request-pending.util.ts
@@ -0,0 +1,11 @@
+import {
+ isWorkspaceDeletionPending,
+ type WorkspaceDeletionState,
+} from 'src/engine/core-modules/workspace/utils/is-workspace-deletion-pending.util';
+
+export const isWorkspaceDeletionRequestPending = (
+ workspace: WorkspaceDeletionState | null | undefined,
+ workspaceDeletionRequestTimestamp: string,
+): workspace is WorkspaceDeletionState & { deletedAt: Date } =>
+ isWorkspaceDeletionPending(workspace) &&
+ workspace.deletedAt.toISOString() === workspaceDeletionRequestTimestamp;
diff --git a/packages/twenty-server/src/engine/core-modules/workspace/utils/workspace-graphql-api-exception-handler.util.ts b/packages/twenty-server/src/engine/core-modules/workspace/utils/workspace-graphql-api-exception-handler.util.ts
index 546cb2e738b..730abc5b3b4 100644
--- a/packages/twenty-server/src/engine/core-modules/workspace/utils/workspace-graphql-api-exception-handler.util.ts
+++ b/packages/twenty-server/src/engine/core-modules/workspace/utils/workspace-graphql-api-exception-handler.util.ts
@@ -20,6 +20,7 @@ export const workspaceGraphqlApiExceptionHandler = (error: Error) => {
case WorkspaceExceptionCode.DOMAIN_ALREADY_TAKEN:
case WorkspaceExceptionCode.SUBDOMAIN_ALREADY_TAKEN:
case WorkspaceExceptionCode.SUBDOMAIN_NOT_VALID:
+ case WorkspaceExceptionCode.APPLICATION_UNINSTALL_IN_PROGRESS:
throw new ConflictError(error);
case WorkspaceExceptionCode.ENVIRONMENT_VAR_NOT_ENABLED:
case WorkspaceExceptionCode.WORKSPACE_CUSTOM_DOMAIN_DISABLED:
diff --git a/packages/twenty-server/src/engine/core-modules/workspace/workspace.exception.ts b/packages/twenty-server/src/engine/core-modules/workspace/workspace.exception.ts
index c6a28ac462e..cc96d4b1726 100644
--- a/packages/twenty-server/src/engine/core-modules/workspace/workspace.exception.ts
+++ b/packages/twenty-server/src/engine/core-modules/workspace/workspace.exception.ts
@@ -13,6 +13,7 @@ export enum WorkspaceExceptionCode {
WORKSPACE_CUSTOM_DOMAIN_DISABLED = 'WORKSPACE_CUSTOM_DOMAIN_DISABLED',
ENVIRONMENT_VAR_NOT_ENABLED = 'ENVIRONMENT_VAR_NOT_ENABLED',
CUSTOM_DOMAIN_NOT_FOUND = 'CUSTOM_DOMAIN_NOT_FOUND',
+ APPLICATION_UNINSTALL_IN_PROGRESS = 'APPLICATION_UNINSTALL_IN_PROGRESS',
}
const getWorkspaceExceptionUserFriendlyMessage = (
@@ -35,6 +36,8 @@ const getWorkspaceExceptionUserFriendlyMessage = (
return msg`This feature is not enabled.`;
case WorkspaceExceptionCode.CUSTOM_DOMAIN_NOT_FOUND:
return msg`Custom domain not found.`;
+ case WorkspaceExceptionCode.APPLICATION_UNINSTALL_IN_PROGRESS:
+ return msg`Application cleanup is still in progress. Please try again.`;
default:
assertUnreachable(code);
}
diff --git a/packages/twenty-server/src/engine/core-modules/workspace/workspace.module.ts b/packages/twenty-server/src/engine/core-modules/workspace/workspace.module.ts
index e5200e181dc..6cc2ad6fef5 100644
--- a/packages/twenty-server/src/engine/core-modules/workspace/workspace.module.ts
+++ b/packages/twenty-server/src/engine/core-modules/workspace/workspace.module.ts
@@ -3,6 +3,7 @@ import { TypeOrmModule } from '@nestjs/typeorm';
import { TypeORMModule } from 'src/database/typeorm/typeorm.module';
import { ApplicationModule } from 'src/engine/core-modules/application/application.module';
+import { ApplicationManifestModule } from 'src/engine/core-modules/application/application-manifest/application-manifest.module';
import { PreInstalledAppsModule } from 'src/engine/core-modules/application/pre-installed-apps/pre-installed-apps.module';
import { TokenModule } from 'src/engine/core-modules/auth/token/token.module';
import { BillingModule } from 'src/engine/core-modules/billing/billing.module';
@@ -74,6 +75,7 @@ import { StandardObjectsPrefillModule } from 'src/engine/workspace-manager/stand
ViewModule,
WorkspaceManyOrAllFlatEntityMapsCacheModule,
ApplicationModule,
+ ApplicationManifestModule,
PreInstalledAppsModule,
EnterpriseModule,
WorkspaceMigrationModule,
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/__tests__/morph-relation-from-create-field-input-to-flat-field-metadatas-to-create.spec.ts b/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/__tests__/morph-relation-from-create-field-input-to-flat-field-metadatas-to-create.spec.ts
index 1a735751fd5..da76efc2f58 100644
--- a/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/__tests__/morph-relation-from-create-field-input-to-flat-field-metadatas-to-create.spec.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/__tests__/morph-relation-from-create-field-input-to-flat-field-metadatas-to-create.spec.ts
@@ -41,6 +41,7 @@ const MOCK_FLAT_APPLICATION: FlatApplication = {
defaultRole: null,
settingsCustomTabFrontComponentId: null,
uninstallLogicFunctionId: null,
+ uninstallHookCompletedForRequestedAt: null,
canBeUninstalled: false,
autoUpgrade: false,
applicationRegistrationId: null,
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/utils/__tests__/generate-morph-or-relation-flat-field-metadata-pair.spec.ts b/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/utils/__tests__/generate-morph-or-relation-flat-field-metadata-pair.spec.ts
index 9fa4dc49f3f..ab593e2cb90 100644
--- a/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/utils/__tests__/generate-morph-or-relation-flat-field-metadata-pair.spec.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/utils/__tests__/generate-morph-or-relation-flat-field-metadata-pair.spec.ts
@@ -36,6 +36,7 @@ const MOCK_FLAT_APPLICATION: FlatApplication = {
defaultRole: null,
settingsCustomTabFrontComponentId: null,
uninstallLogicFunctionId: null,
+ uninstallHookCompletedForRequestedAt: null,
canBeUninstalled: false,
autoUpgrade: false,
applicationRegistrationId: null,
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-cleaner/crons/__tests__/clean-suspended-workspaces.job.spec.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-cleaner/crons/__tests__/clean-suspended-workspaces.job.spec.ts
index 43363cf1518..5be5f3e03d7 100644
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-cleaner/crons/__tests__/clean-suspended-workspaces.job.spec.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-cleaner/crons/__tests__/clean-suspended-workspaces.job.spec.ts
@@ -1,6 +1,8 @@
import { type Repository } from 'typeorm';
import { type PostgresAdvisoryLockService } from 'src/database/typeorm/postgres-advisory-lock.service';
+import { type ApplicationUninstallService } from 'src/engine/core-modules/application/application-manifest/services/application-uninstall.service';
+import { type WorkspaceService } from 'src/engine/core-modules/workspace/services/workspace.service';
import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
import { CleanSuspendedWorkspacesJob } from 'src/engine/workspace-manager/workspace-cleaner/crons/clean-suspended-workspaces.job';
import { type CleanerWorkspaceService } from 'src/engine/workspace-manager/workspace-cleaner/services/cleaner.workspace-service';
@@ -19,6 +21,12 @@ describe('CleanSuspendedWorkspacesJob', () => {
const cleanerWorkspaceService = {
batchWarnOrCleanSuspendedWorkspaces: jest.fn(),
};
+ const workspaceService = {
+ enqueueWorkspaceDeletionApplicationUninstall: jest.fn(),
+ };
+ const applicationUninstallService = {
+ findWorkspaceIdsWithPendingUninstallHooks: jest.fn(),
+ };
const postgresAdvisoryLockService = {
tryWithLock: jest.fn(),
};
@@ -27,15 +35,27 @@ describe('CleanSuspendedWorkspacesJob', () => {
new CleanSuspendedWorkspacesJob(
cleanerWorkspaceService as unknown as CleanerWorkspaceService,
workspaceRepository as unknown as Repository<WorkspaceEntity>,
+ workspaceService as unknown as WorkspaceService,
+ applicationUninstallService as unknown as ApplicationUninstallService,
postgresAdvisoryLockService as unknown as PostgresAdvisoryLockService,
);
beforeEach(() => {
jest.clearAllMocks();
- workspaceRepository.find.mockResolvedValue([{ id: 'workspace-id' }]);
+ applicationUninstallService.findWorkspaceIdsWithPendingUninstallHooks.mockImplementation(
+ async (workspaceUninstallRequests) =>
+ new Set(
+ workspaceUninstallRequests.map(
+ (request: { workspaceId: string }) => request.workspaceId,
+ ),
+ ),
+ );
+ workspaceRepository.find
+ .mockResolvedValueOnce([{ id: 'workspace-id' }])
+ .mockResolvedValueOnce([]);
});
- it('skips cleanup when another execution holds the lock', async () => {
+ it('should skip cleanup when another execution holds the lock', async () => {
postgresAdvisoryLockService.tryWithLock.mockResolvedValue({
acquired: false,
});
@@ -48,7 +68,7 @@ describe('CleanSuspendedWorkspacesJob', () => {
).not.toHaveBeenCalled();
});
- it('cleans suspended workspaces while holding the lock', async () => {
+ it('should clean suspended workspaces when the lock is acquired', async () => {
postgresAdvisoryLockService.tryWithLock.mockImplementation(
async (_lockName, callback) => ({
acquired: true,
@@ -58,7 +78,7 @@ describe('CleanSuspendedWorkspacesJob', () => {
await createJob().handle();
- expect(workspaceRepository.find).toHaveBeenCalledWith({
+ expect(workspaceRepository.find).toHaveBeenNthCalledWith(1, {
select: ['id'],
where: {
activationStatus: 'SUSPENDED',
@@ -71,4 +91,65 @@ describe('CleanSuspendedWorkspacesJob', () => {
workspaceIds: ['workspace-id'],
});
});
+
+ it('should re-enqueue deletion hooks when uninstall hooks are still pending', async () => {
+ const workspaceDeletedAt = new Date('2026-08-18T12:00:00.000Z');
+
+ workspaceRepository.find.mockReset();
+ workspaceRepository.find
+ .mockResolvedValueOnce([{ id: 'suspended-workspace-id' }])
+ .mockResolvedValueOnce([
+ { id: 'deleted-workspace-id', deletedAt: workspaceDeletedAt },
+ ]);
+ postgresAdvisoryLockService.tryWithLock.mockImplementation(
+ async (_lockName, callback) => ({
+ acquired: true,
+ value: await callback(),
+ }),
+ );
+
+ await createJob().handle();
+
+ expect(
+ applicationUninstallService.findWorkspaceIdsWithPendingUninstallHooks,
+ ).toHaveBeenCalledTimes(1);
+ expect(
+ applicationUninstallService.findWorkspaceIdsWithPendingUninstallHooks,
+ ).toHaveBeenCalledWith([
+ {
+ workspaceId: 'deleted-workspace-id',
+ uninstallRequestedAt: workspaceDeletedAt,
+ },
+ ]);
+ expect(
+ workspaceService.enqueueWorkspaceDeletionApplicationUninstall,
+ ).toHaveBeenCalledWith('deleted-workspace-id');
+ });
+
+ it('should not re-enqueue workspaces whose uninstall hooks already completed', async () => {
+ applicationUninstallService.findWorkspaceIdsWithPendingUninstallHooks.mockResolvedValue(
+ new Set(),
+ );
+ workspaceRepository.find.mockReset();
+ workspaceRepository.find
+ .mockResolvedValueOnce([{ id: 'suspended-workspace-id' }])
+ .mockResolvedValueOnce([
+ {
+ id: 'deleted-workspace-id',
+ deletedAt: new Date('2026-08-18T12:00:00.000Z'),
+ },
+ ]);
+ postgresAdvisoryLockService.tryWithLock.mockImplementation(
+ async (_lockName, callback) => ({
+ acquired: true,
+ value: await callback(),
+ }),
+ );
+
+ await createJob().handle();
+
+ expect(
+ workspaceService.enqueueWorkspaceDeletionApplicationUninstall,
+ ).not.toHaveBeenCalled();
+ });
});
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-cleaner/crons/clean-suspended-workspaces.job.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-cleaner/crons/clean-suspended-workspaces.job.ts
index ad5f3efcf69..1fadeb5595a 100644
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-cleaner/crons/clean-suspended-workspaces.job.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-cleaner/crons/clean-suspended-workspaces.job.ts
@@ -1,14 +1,17 @@
import { Logger } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
+import { IsNull, Not, Repository } from 'typeorm';
+import { isDefined } from 'twenty-shared/utils';
import { WorkspaceActivationStatus } from 'twenty-shared/workspace';
import { PostgresAdvisoryLockService } from 'src/database/typeorm/postgres-advisory-lock.service';
+import { ApplicationUninstallService } from 'src/engine/core-modules/application/application-manifest/services/application-uninstall.service';
import { SentryCronMonitor } from 'src/engine/core-modules/cron/sentry-cron-monitor.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 { WorkspaceService } from 'src/engine/core-modules/workspace/services/workspace.service';
import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
import { cleanSuspendedWorkspaceCronPattern } from 'src/engine/workspace-manager/workspace-cleaner/crons/clean-suspended-workspaces.cron.pattern';
import { CleanerWorkspaceService } from 'src/engine/workspace-manager/workspace-cleaner/services/cleaner.workspace-service';
@@ -23,6 +26,8 @@ export class CleanSuspendedWorkspacesJob {
private readonly cleanerWorkspaceService: CleanerWorkspaceService,
@InjectRepository(WorkspaceEntity)
private readonly workspaceRepository: Repository<WorkspaceEntity>,
+ private readonly workspaceService: WorkspaceService,
+ private readonly applicationUninstallService: ApplicationUninstallService,
private readonly postgresAdvisoryLockService: PostgresAdvisoryLockService,
) {}
@@ -32,24 +37,60 @@ export class CleanSuspendedWorkspacesJob {
cleanSuspendedWorkspaceCronPattern,
)
async handle(): Promise<void> {
- const result = await this.postgresAdvisoryLockService.tryWithLock(
- CLEAN_SUSPENDED_WORKSPACES_LOCK_NAME,
- async () => {
- const suspendedWorkspaceIds = await this.workspaceRepository.find({
- select: ['id'],
- where: {
- activationStatus: WorkspaceActivationStatus.SUSPENDED,
- },
- withDeleted: true,
- });
-
- await this.cleanerWorkspaceService.batchWarnOrCleanSuspendedWorkspaces({
- workspaceIds: suspendedWorkspaceIds.map((workspace) => workspace.id),
- });
- },
- );
-
- if (!result.acquired) {
+ const advisoryLockResult =
+ await this.postgresAdvisoryLockService.tryWithLock(
+ CLEAN_SUSPENDED_WORKSPACES_LOCK_NAME,
+ async () => {
+ const suspendedWorkspaces = await this.workspaceRepository.find({
+ select: ['id'],
+ where: {
+ activationStatus: WorkspaceActivationStatus.SUSPENDED,
+ },
+ withDeleted: true,
+ });
+ const softDeletedWorkspaces = await this.workspaceRepository.find({
+ select: ['id', 'deletedAt'],
+ where: { deletedAt: Not(IsNull()) },
+ withDeleted: true,
+ });
+
+ const workspaceDeletionUninstallRequests =
+ softDeletedWorkspaces.flatMap((workspace) =>
+ isDefined(workspace.deletedAt)
+ ? [
+ {
+ workspaceId: workspace.id,
+ uninstallRequestedAt: workspace.deletedAt,
+ },
+ ]
+ : [],
+ );
+ const workspaceIdsWithPendingUninstallHooks =
+ await this.applicationUninstallService.findWorkspaceIdsWithPendingUninstallHooks(
+ workspaceDeletionUninstallRequests,
+ );
+
+ for (const request of workspaceDeletionUninstallRequests) {
+ if (
+ workspaceIdsWithPendingUninstallHooks.has(request.workspaceId)
+ ) {
+ await this.workspaceService.enqueueWorkspaceDeletionApplicationUninstall(
+ request.workspaceId,
+ );
+ }
+ }
+
+ await this.cleanerWorkspaceService.batchWarnOrCleanSuspendedWorkspaces(
+ {
+ workspaceIds: suspendedWorkspaces.map(
+ (workspace) => workspace.id,
+ ),
+ },
+ );
+ },
+ );
+
+ if (!advisoryLockResult.acquired) {
this.logger.log(
'Skipping suspended workspace cleanup because another execution is running',
);
diff --git a/packages/twenty-server/test/integration/metadata/suites/application/application-uninstall-retry.integration-spec.ts b/packages/twenty-server/test/integration/metadata/suites/application/application-uninstall-retry.integration-spec.ts
new file mode 100644
index 00000000000..cb86deaa09e
--- /dev/null
+++ b/packages/twenty-server/test/integration/metadata/suites/application/application-uninstall-retry.integration-spec.ts
@@ -0,0 +1,313 @@
+import { randomUUID } from 'crypto';
+
+import { activateWorkspace } from 'test/integration/graphql/utils/activate-workspace.util';
+import { deleteUser } from 'test/integration/graphql/utils/delete-user.util';
+import { getAuthTokensFromLoginToken } from 'test/integration/graphql/utils/get-auth-tokens-from-login-token.util';
+import { signUpInNewWorkspace } from 'test/integration/graphql/utils/sign-up-in-new-workspace.util';
+import { signUp } from 'test/integration/graphql/utils/sign-up.util';
+import { buildBaseManifest } from 'test/integration/metadata/suites/application/utils/build-base-manifest.util';
+import { cleanupApplicationAndAppRegistration } from 'test/integration/metadata/suites/application/utils/cleanup-application-and-app-registration.util';
+import { setupApplicationForSync } from 'test/integration/metadata/suites/application/utils/setup-application-for-sync.util';
+import { syncApplication } from 'test/integration/metadata/suites/application/utils/sync-application.util';
+import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
+import { type Manifest } from 'twenty-shared/application';
+import { isDefined } from 'twenty-shared/utils';
+import { v4 as uuidv4 } from 'uuid';
+
+import { type ApplicationUninstallService } from 'src/engine/core-modules/application/application-manifest/services/application-uninstall.service';
+import { type LogicFunctionExecutorService } from 'src/engine/core-modules/logic-function/logic-function-executor/logic-function-executor.service';
+import { LogicFunctionExecutionStatus } from 'src/engine/metadata-modules/logic-function/dtos/logic-function-execution-result.dto';
+
+type InstalledApplication = {
+ universalIdentifier: string;
+ uninstallLogicFunctionId: string;
+ uninstallHookCompletedForRequestedAt: Date | null;
+ workspaceId: string;
+};
+
+const SUCCESSFUL_EXECUTION_RESULT = {
+ data: {},
+ duration: 1,
+ logs: '',
+ status: LogicFunctionExecutionStatus.SUCCESS,
+};
+
+const FAILED_EXECUTION_RESULT = {
+ data: null,
+ duration: 1,
+ logs: '',
+ status: LogicFunctionExecutionStatus.ERROR,
+ error: {
+ errorType: 'Error',
+ errorMessage: 'cleanup failed',
+ stackTrace: '',
+ },
+};
+
+const buildManifestWithUninstallHook = ({
+ applicationUniversalIdentifier,
+ roleUniversalIdentifier,
+ logicFunctionUniversalIdentifier,
+}: {
+ applicationUniversalIdentifier: string;
+ roleUniversalIdentifier: string;
+ logicFunctionUniversalIdentifier: string;
+}): Manifest => {
+ const baseManifest = buildBaseManifest({
+ appId: applicationUniversalIdentifier,
+ roleId: roleUniversalIdentifier,
+ });
+
+ return {
+ ...baseManifest,
+ application: {
+ ...baseManifest.application,
+ uninstallLogicFunction: {
+ universalIdentifier: logicFunctionUniversalIdentifier,
+ },
+ },
+ logicFunctions: [
+ {
+ universalIdentifier: logicFunctionUniversalIdentifier,
+ name: 'Cleanup',
+ description: 'Uninstall cleanup logic function',
+ handlerName: 'handler',
+ sourceHandlerPath: 'src/cleanup.ts',
+ builtHandlerPath: 'dist/cleanup.mjs',
+ builtHandlerChecksum: 'checksum-cleanup',
+ httpRouteTriggerSettings: {
+ path: '/cleanup',
+ httpMethod: 'POST',
+ isAuthRequired: true,
+ },
+ },
+ ],
+ roles: baseManifest.roles.map((role) => ({
+ ...role,
+ label: `Retry Test Role ${applicationUniversalIdentifier}`,
+ })),
+ };
+};
+
+describe('Application uninstall retry', () => {
+ const applicationUniversalIdentifiers = [uuidv4(), uuidv4()];
+ let executeSpy: jest.SpyInstance;
+ let userAccessToken: string;
+ let workspaceAccessToken: string;
+ let workspaceId: string;
+
+ const findInstalledApplications = (): Promise<InstalledApplication[]> =>
+ globalThis.testDataSource.query(
+ `SELECT
+ "universalIdentifier",
+ "uninstallLogicFunctionId",
+ "uninstallHookCompletedForRequestedAt",
+ "workspaceId"
+ FROM core."application"
+ WHERE "universalIdentifier" = ANY($1::uuid[])`,
+ [applicationUniversalIdentifiers],
+ );
+
+ beforeAll(async () => {
+ const logicFunctionExecutorService =
+ getAppProviderByClassName<LogicFunctionExecutorService>(
+ 'LogicFunctionExecutorService',
+ );
+
+ executeSpy = jest
+ .spyOn(logicFunctionExecutorService, 'execute')
+ .mockResolvedValue(SUCCESSFUL_EXECUTION_RESULT);
+
+ const uniqueEmail = `test-${randomUUID()}@example.com`;
+ const { data: signUpData } = await signUp({
+ input: { email: uniqueEmail, password: 'Test123!@#' },
+ expectToFail: false,
+ });
+
+ userAccessToken =
+ signUpData.signUp.tokens.accessOrWorkspaceAgnosticToken.token;
+
+ await globalThis.testDataSource.query(
+ 'UPDATE core."user" SET "isEmailVerified" = true WHERE email = $1',
+ [uniqueEmail],
+ );
+
+ const {
+ data: { signUpInNewWorkspace: newWorkspaceData },
+ } = await signUpInNewWorkspace({
+ accessToken: userAccessToken,
+ expectToFail: false,
+ });
+
+ workspaceId = newWorkspaceData.workspace.id;
+
+ const {
+ data: { getAuthTokensFromLoginToken: authTokensData },
+ } = await getAuthTokensFromLoginToken({
+ origin: newWorkspaceData.workspace.workspaceUrls.subdomainUrl,
+ loginToken: newWorkspaceData.loginToken.token,
+ expectToFail: false,
+ });
+
+ workspaceAccessToken =
+ authTokensData.tokens.accessOrWorkspaceAgnosticToken.token;
+
+ await activateWorkspace({
+ accessToken: workspaceAccessToken,
+ expectToFail: false,
+ });
+
+ for (const [
+ index,
+ applicationUniversalIdentifier,
+ ] of applicationUniversalIdentifiers.entries()) {
+ await setupApplicationForSync({
+ applicationUniversalIdentifier,
+ name: `Workspace Deletion Retry Test App ${index + 1}`,
+ description: 'App for testing workspace deletion uninstall retries',
+ sourcePath: `test-workspace-deletion-retry-${applicationUniversalIdentifier}`,
+ token: workspaceAccessToken,
+ });
+
+ await syncApplication({
+ manifest: buildManifestWithUninstallHook({
+ applicationUniversalIdentifier,
+ roleUniversalIdentifier: uuidv4(),
+ logicFunctionUniversalIdentifier: uuidv4(),
+ }),
+ expectToFail: false,
+ token: workspaceAccessToken,
+ });
+ }
+ }, 120000);
+
+ afterAll(async () => {
+ executeSpy.mockResolvedValue(SUCCESSFUL_EXECUTION_RESULT);
+
+ for (const applicationUniversalIdentifier of applicationUniversalIdentifiers) {
+ await cleanupApplicationAndAppRegistration({
+ applicationUniversalIdentifier,
+ });
+ }
+
+ executeSpy.mockRestore();
+ await deleteUser({ accessToken: userAccessToken });
+ });
+
+ it('records partial progress and retries only the failed hook', async () => {
+ const workspaceDeletedAt = new Date('2026-08-18T10:00:00.000Z');
+ const applicationUninstallService =
+ getAppProviderByClassName<ApplicationUninstallService>(
+ 'ApplicationUninstallService',
+ );
+ const installedApplications = await findInstalledApplications();
+
+ expect(installedApplications).toHaveLength(2);
+ expect(
+ new Set(
+ installedApplications.map((application) => application.workspaceId),
+ ).size,
+ ).toBe(1);
+
+ expect(installedApplications[0].workspaceId).toBe(workspaceId);
+
+ executeSpy.mockClear();
+ executeSpy
+ .mockResolvedValueOnce(FAILED_EXECUTION_RESULT)
+ .mockResolvedValueOnce(SUCCESSFUL_EXECUTION_RESULT);
+
+ await expect(
+ applicationUninstallService.runUninstallHooksForWorkspaceDeletion({
+ workspaceId,
+ workspaceDeletedAt,
+ }),
+ ).rejects.toThrow('cleanup failed');
+
+ expect(executeSpy).toHaveBeenCalledTimes(2);
+
+ const failedLogicFunctionId = executeSpy.mock.calls[0][0].logicFunctionId;
+ const successfulLogicFunctionId =
+ executeSpy.mock.calls[1][0].logicFunctionId;
+ const failedApplication = installedApplications.find(
+ (application) =>
+ application.uninstallLogicFunctionId === failedLogicFunctionId,
+ );
+ const successfulApplication = installedApplications.find(
+ (application) =>
+ application.uninstallLogicFunctionId === successfulLogicFunctionId,
+ );
+
+ expect(failedApplication).toBeDefined();
+ expect(successfulApplication).toBeDefined();
+
+ if (!isDefined(failedApplication) || !isDefined(successfulApplication)) {
+ throw new Error('Expected both uninstall applications to be installed');
+ }
+
+ const applicationsAfterFirstAttempt = await findInstalledApplications();
+ const failedApplicationAfterFirstAttempt =
+ applicationsAfterFirstAttempt.find(
+ (application) =>
+ application.universalIdentifier ===
+ failedApplication.universalIdentifier,
+ );
+ const successfulApplicationAfterFirstAttempt =
+ applicationsAfterFirstAttempt.find(
+ (application) =>
+ application.universalIdentifier ===
+ successfulApplication.universalIdentifier,
+ );
+
+ expect(
+ failedApplicationAfterFirstAttempt?.uninstallHookCompletedForRequestedAt,
+ ).toBeNull();
+ expect(
+ successfulApplicationAfterFirstAttempt?.uninstallHookCompletedForRequestedAt?.toISOString(),
+ ).toBe(workspaceDeletedAt.toISOString());
+
+ const workspaceIdsWithPendingUninstallHooks =
+ await applicationUninstallService.findWorkspaceIdsWithPendingUninstallHooks(
+ [{ workspaceId, uninstallRequestedAt: workspaceDeletedAt }],
+ );
+
+ expect(workspaceIdsWithPendingUninstallHooks.size).toBe(1);
+ expect(workspaceIdsWithPendingUninstallHooks.has(workspaceId)).toBe(true);
+
+ executeSpy.mockClear();
+ executeSpy.mockResolvedValue(SUCCESSFUL_EXECUTION_RESULT);
+
+ await applicationUninstallService.runUninstallHooksForWorkspaceDeletion({
+ workspaceId,
+ workspaceDeletedAt,
+ });
+
+ expect(executeSpy).toHaveBeenCalledTimes(1);
+ expect(executeSpy).toHaveBeenCalledWith(
+ expect.objectContaining({
+ logicFunctionId: failedApplication.uninstallLogicFunctionId,
+ workspaceDeletionRequestTimestamp: workspaceDeletedAt.toISOString(),
+ payload: expect.objectContaining({
+ idempotencyKey: `workspace-deletion:${workspaceId}:${workspaceDeletedAt.toISOString()}:${failedApplication.universalIdentifier}`,
+ }),
+ }),
+ );
+
+ const applicationsAfterRetry = await findInstalledApplications();
+
+ expect(
+ applicationsAfterRetry.map((application) =>
+ application.uninstallHookCompletedForRequestedAt?.toISOString(),
+ ),
+ ).toEqual([
+ workspaceDeletedAt.toISOString(),
+ workspaceDeletedAt.toISOString(),
+ ]);
+
+ const workspaceIdsWithPendingUninstallHooksAfterRetry =
+ await applicationUninstallService.findWorkspaceIdsWithPendingUninstallHooks(
+ [{ workspaceId, uninstallRequestedAt: workspaceDeletedAt }],
+ );
+
+ expect(workspaceIdsWithPendingUninstallHooksAfterRetry.size).toBe(0);
+ }, 120000);
+});
diff --git a/packages/twenty-server/test/integration/metadata/suites/application/utils/setup-application-for-sync.util.ts b/packages/twenty-server/test/integration/metadata/suites/application/utils/setup-application-for-sync.util.ts
index 7f3031967c2..908a7af0515 100644
--- a/packages/twenty-server/test/integration/metadata/suites/application/utils/setup-application-for-sync.util.ts
+++ b/packages/twenty-server/test/integration/metadata/suites/application/utils/setup-application-for-sync.util.ts
@@ -8,30 +8,35 @@ export const setupApplicationForSync = async ({
applicationUniversalIdentifier,
name,
sourcePath,
+ token,
}: {
applicationUniversalIdentifier: string;
name: string;
description: string;
sourcePath: string;
+ token?: string;
}) => {
jest.useRealTimers();
- const registrationResponse = await makeMetadataAPIRequest({
- query: gql`
- mutation CreateApplicationRegistration(
- $input: CreateApplicationRegistrationInput!
- ) {
- createApplicationRegistration(input: $input) {
- applicationRegistration {
- id
+ const registrationResponse = await makeMetadataAPIRequest(
+ {
+ query: gql`
+ mutation CreateApplicationRegistration(
+ $input: CreateApplicationRegistrationInput!
+ ) {
+ createApplicationRegistration(input: $input) {
+ applicationRegistration {
+ id
+ }
}
}
- }
- `,
- variables: {
- input: { name, universalIdentifier: applicationUniversalIdentifier },
+ `,
+ variables: {
+ input: { name, universalIdentifier: applicationUniversalIdentifier },
+ },
},
- });
+ token,
+ );
if (isDefined(registrationResponse.body.errors)) {
throw new Error(
@@ -41,22 +46,25 @@ export const setupApplicationForSync = async ({
);
}
- const developmentApplicationResponse = await makeMetadataAPIRequest({
- query: gql`
- mutation CreateDevelopmentApplication(
- $universalIdentifier: String!
- $name: String!
- ) {
- createDevelopmentApplication(
- universalIdentifier: $universalIdentifier
- name: $name
+ const developmentApplicationResponse = await makeMetadataAPIRequest(
+ {
+ query: gql`
+ mutation CreateDevelopmentApplication(
+ $universalIdentifier: String!
+ $name: String!
) {
- id
+ createDevelopmentApplication(
+ universalIdentifier: $universalIdentifier
+ name: $name
+ ) {
+ id
+ }
}
- }
- `,
- variables: { universalIdentifier: applicationUniversalIdentifier, name },
- });
+ `,
+ variables: { universalIdentifier: applicationUniversalIdentifier, name },
+ },
+ token,
+ );
if (isDefined(developmentApplicationResponse.body.errors)) {
throw new Error(
@@ -78,6 +86,7 @@ export const setupApplicationForSync = async ({
fileBuffer: Buffer.from(packageJson),
filename: 'package.json',
expectToFail: false,
+ token,
});
jest.useFakeTimers();
diff --git a/packages/twenty-server/test/integration/metadata/suites/application/workspace-deletion-application-token.integration-spec.ts b/packages/twenty-server/test/integration/metadata/suites/application/workspace-deletion-application-token.integration-spec.ts
new file mode 100644
index 00000000000..cc3163c7542
--- /dev/null
+++ b/packages/twenty-server/test/integration/metadata/suites/application/workspace-deletion-application-token.integration-spec.ts
@@ -0,0 +1,283 @@
+import { randomUUID } from 'crypto';
+
+import gql from 'graphql-tag';
+import { activateWorkspace } from 'test/integration/graphql/utils/activate-workspace.util';
+import { deleteUser } from 'test/integration/graphql/utils/delete-user.util';
+import { findManyApplications } from 'test/integration/graphql/utils/find-many-applications.util';
+import { getAuthTokensFromLoginToken } from 'test/integration/graphql/utils/get-auth-tokens-from-login-token.util';
+import { signUpInNewWorkspace } from 'test/integration/graphql/utils/sign-up-in-new-workspace.util';
+import { signUp } from 'test/integration/graphql/utils/sign-up.util';
+import { generateApplicationToken } from 'test/integration/metadata/suites/application/utils/generate-application-token.util';
+import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
+import { isDefined } from 'twenty-shared/utils';
+
+import { type ApplicationTokenService } from 'src/engine/core-modules/auth/token/services/application-token.service';
+import { type WorkspaceService } from 'src/engine/core-modules/workspace/services/workspace.service';
+import {
+ WorkspaceException,
+ WorkspaceExceptionCode,
+} from 'src/engine/core-modules/workspace/workspace.exception';
+import { TWENTY_STANDARD_APPLICATION } from 'src/engine/workspace-manager/twenty-standard-application/constants/twenty-standard-applications';
+
+const WORKSPACE_CLEANUP_RETRY_INTERVAL_MS = 25;
+const WORKSPACE_CLEANUP_RETRY_LIMIT = 200;
+
+const IS_APPLICATION_STOPPED = gql`
+ query IsApplicationStopped($applicationUniversalIdentifier: String!) {
+ isApplicationStopped(
+ applicationUniversalIdentifier: $applicationUniversalIdentifier
+ )
+ }
+`;
+
+describe('Workspace deletion application token', () => {
+ let applicationAccessToken: string;
+ let applicationId: string;
+ let applicationTokenService: ApplicationTokenService;
+ let userAccessToken: string | undefined;
+ let workspaceId: string | undefined;
+ let workspaceService: WorkspaceService;
+
+ const queryApplicationStoppedState = (token: string) =>
+ makeMetadataAPIRequest(
+ {
+ query: IS_APPLICATION_STOPPED,
+ variables: {
+ applicationUniversalIdentifier:
+ TWENTY_STANDARD_APPLICATION.universalIdentifier,
+ },
+ },
+ token,
+ );
+
+ const hardDeleteWorkspaceForCleanup = async (
+ workspaceIdToCleanup: string,
+ ) => {
+ for (let attempt = 1; attempt <= WORKSPACE_CLEANUP_RETRY_LIMIT; attempt++) {
+ try {
+ await workspaceService.deleteWorkspace(workspaceIdToCleanup);
+
+ return;
+ } catch (error) {
+ const shouldRetry =
+ error instanceof WorkspaceException &&
+ error.code ===
+ WorkspaceExceptionCode.APPLICATION_UNINSTALL_IN_PROGRESS &&
+ attempt < WORKSPACE_CLEANUP_RETRY_LIMIT;
+
+ if (!shouldRetry) {
+ throw error;
+ }
+
+ await new Promise((resolve) =>
+ setTimeout(resolve, WORKSPACE_CLEANUP_RETRY_INTERVAL_MS),
+ );
+ }
+ }
+ };
+
+ const softDeleteWorkspaceAndGenerateDeletionToken = async () => {
+ if (!isDefined(workspaceId)) {
+ throw new Error('Expected the test workspace to exist');
+ }
+
+ await workspaceService.deleteWorkspace(workspaceId, true);
+
+ const [softDeletedWorkspace] = await globalThis.testDataSource.query(
+ 'SELECT "deletedAt" FROM core."workspace" WHERE id = $1',
+ [workspaceId],
+ );
+ const workspaceDeletionRequestTimestamp = new Date(
+ softDeletedWorkspace.deletedAt,
+ ).toISOString();
+ const deletionToken =
+ await applicationTokenService.generateWorkspaceDeletionApplicationAccessToken(
+ {
+ applicationId,
+ workspaceId,
+ workspaceDeletionRequestTimestamp,
+ },
+ );
+
+ return { deletionToken, workspaceDeletionRequestTimestamp };
+ };
+
+ beforeEach(async () => {
+ jest.useRealTimers();
+
+ userAccessToken = undefined;
+ workspaceId = undefined;
+ applicationTokenService =
+ getAppProviderByClassName<ApplicationTokenService>(
+ 'ApplicationTokenService',
+ );
+ workspaceService =
+ getAppProviderByClassName<WorkspaceService>('WorkspaceService');
+
+ const uniqueEmail = `test-${randomUUID()}@example.com`;
+ const { data: signUpData } = await signUp({
+ input: { email: uniqueEmail, password: 'Test123!@#' },
+ expectToFail: false,
+ });
+
+ userAccessToken =
+ signUpData.signUp.tokens.accessOrWorkspaceAgnosticToken.token;
+
+ await globalThis.testDataSource.query(
+ 'UPDATE core."user" SET "isEmailVerified" = true WHERE email = $1',
+ [uniqueEmail],
+ );
+
+ const {
+ data: { signUpInNewWorkspace: newWorkspaceData },
+ } = await signUpInNewWorkspace({
+ accessToken: userAccessToken,
+ expectToFail: false,
+ });
+
+ workspaceId = newWorkspaceData.workspace.id;
+
+ const {
+ data: { getAuthTokensFromLoginToken: authTokensData },
+ } = await getAuthTokensFromLoginToken({
+ origin: newWorkspaceData.workspace.workspaceUrls.subdomainUrl,
+ loginToken: newWorkspaceData.loginToken.token,
+ expectToFail: false,
+ });
+ const workspaceAccessToken =
+ authTokensData.tokens.accessOrWorkspaceAgnosticToken.token;
+
+ await activateWorkspace({
+ accessToken: workspaceAccessToken,
+ expectToFail: false,
+ });
+
+ const { data: applicationsData } = await findManyApplications({
+ accessToken: workspaceAccessToken,
+ expectToFail: false,
+ });
+ const standardApplication = applicationsData.findManyApplications.find(
+ (application) =>
+ application.universalIdentifier ===
+ TWENTY_STANDARD_APPLICATION.universalIdentifier,
+ );
+
+ expect(standardApplication).toBeDefined();
+
+ if (!isDefined(standardApplication)) {
+ throw new Error('Expected the standard application to be installed');
+ }
+
+ applicationId = standardApplication.id;
+
+ const { data: applicationTokenData } = await generateApplicationToken({
+ applicationId,
+ expectToFail: false,
+ token: workspaceAccessToken,
+ });
+
+ applicationAccessToken =
+ applicationTokenData.generateApplicationToken.applicationAccessToken
+ .token;
+ }, 120000);
+
+ afterEach(async () => {
+ try {
+ if (isDefined(workspaceId)) {
+ const [workspaceToCleanup] = await globalThis.testDataSource.query(
+ 'SELECT id FROM core."workspace" WHERE id = $1',
+ [workspaceId],
+ );
+
+ if (isDefined(workspaceToCleanup)) {
+ await hardDeleteWorkspaceForCleanup(workspaceId);
+ }
+ }
+ } finally {
+ if (isDefined(userAccessToken)) {
+ await deleteUser({ accessToken: userAccessToken });
+ }
+ }
+ });
+
+ it('rejects a normal application token after soft deletion', async () => {
+ if (!isDefined(workspaceId)) {
+ throw new Error('Expected the test workspace to exist');
+ }
+
+ const activeWorkspaceResponse = await queryApplicationStoppedState(
+ applicationAccessToken,
+ );
+
+ expect(activeWorkspaceResponse.body.errors).toBeUndefined();
+ expect(activeWorkspaceResponse.body.data.isApplicationStopped).toBe(false);
+
+ await workspaceService.deleteWorkspace(workspaceId, true);
+
+ const normalTokenAfterDeletionResponse = await queryApplicationStoppedState(
+ applicationAccessToken,
+ );
+
+ expect(normalTokenAfterDeletionResponse.body.errors).toEqual(
+ expect.arrayContaining([
+ expect.objectContaining({
+ extensions: expect.objectContaining({ code: 'UNAUTHENTICATED' }),
+ message: 'Workspace not found',
+ }),
+ ]),
+ );
+ }, 120000);
+
+ it('accepts a token scoped to the current deletion request', async () => {
+ const { deletionToken } =
+ await softDeleteWorkspaceAndGenerateDeletionToken();
+
+ const currentDeletionTokenResponse = await queryApplicationStoppedState(
+ deletionToken.token,
+ );
+
+ expect(currentDeletionTokenResponse.body.errors).toBeUndefined();
+ expect(currentDeletionTokenResponse.body.data.isApplicationStopped).toBe(
+ false,
+ );
+ }, 120000);
+
+ it('rejects a deletion token after the deletion request changes', async () => {
+ if (!isDefined(workspaceId)) {
+ throw new Error('Expected the test workspace to exist');
+ }
+
+ const { deletionToken, workspaceDeletionRequestTimestamp } =
+ await softDeleteWorkspaceAndGenerateDeletionToken();
+
+ const nextWorkspaceDeletionRequestTimestamp = new Date(
+ new Date(workspaceDeletionRequestTimestamp).getTime() + 1000,
+ );
+
+ await globalThis.testDataSource.query(
+ 'UPDATE core."workspace" SET "deletedAt" = $2 WHERE id = $1',
+ [workspaceId, nextWorkspaceDeletionRequestTimestamp],
+ );
+
+ try {
+ const staleDeletionTokenResponse = await queryApplicationStoppedState(
+ deletionToken.token,
+ );
+
+ expect(staleDeletionTokenResponse.body.errors).toEqual(
+ expect.arrayContaining([
+ expect.objectContaining({
+ extensions: expect.objectContaining({ code: 'FORBIDDEN' }),
+ message: 'Workspace deletion request not found',
+ }),
+ ]),
+ );
+ } finally {
+ await globalThis.testDataSource.query(
+ 'UPDATE core."workspace" SET "deletedAt" = $2 WHERE id = $1',
+ [workspaceId, workspaceDeletionRequestTimestamp],
+ );
+ }
+ }, 120000);
+});
diff --git a/packages/twenty-server/test/integration/metadata/suites/application/workspace-deletion-runs-uninstall-hooks.integration-spec.ts b/packages/twenty-server/test/integration/metadata/suites/application/workspace-deletion-runs-uninstall-hooks.integration-spec.ts
new file mode 100644
index 00000000000..3d271f58278
--- /dev/null
+++ b/packages/twenty-server/test/integration/metadata/suites/application/workspace-deletion-runs-uninstall-hooks.integration-spec.ts
@@ -0,0 +1,307 @@
+import { randomUUID } from 'crypto';
+
+import { activateWorkspace } from 'test/integration/graphql/utils/activate-workspace.util';
+import { deleteUser } from 'test/integration/graphql/utils/delete-user.util';
+import { getAuthTokensFromLoginToken } from 'test/integration/graphql/utils/get-auth-tokens-from-login-token.util';
+import { signUpInNewWorkspace } from 'test/integration/graphql/utils/sign-up-in-new-workspace.util';
+import { signUp } from 'test/integration/graphql/utils/sign-up.util';
+import { buildBaseManifest } from 'test/integration/metadata/suites/application/utils/build-base-manifest.util';
+import { setupApplicationForSync } from 'test/integration/metadata/suites/application/utils/setup-application-for-sync.util';
+import { syncApplication } from 'test/integration/metadata/suites/application/utils/sync-application.util';
+import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
+import { waitForAllJobsToFinish } from 'test/integration/utils/wait-for-all-jobs-to-finish.util';
+import { type Manifest } from 'twenty-shared/application';
+import { isDefined } from 'twenty-shared/utils';
+import { v4 as uuidv4 } from 'uuid';
+
+import { type PostgresAdvisoryLockService } from 'src/database/typeorm/postgres-advisory-lock.service';
+import { type LogicFunctionExecutorService } from 'src/engine/core-modules/logic-function/logic-function-executor/logic-function-executor.service';
+import { type WorkspaceService } from 'src/engine/core-modules/workspace/services/workspace.service';
+import { getWorkspaceApplicationUninstallLockName } from 'src/engine/core-modules/workspace/utils/get-workspace-application-uninstall-lock-name.util';
+import { LogicFunctionExecutionStatus } from 'src/engine/metadata-modules/logic-function/dtos/logic-function-execution-result.dto';
+
+const buildManifestWithUninstallHook = ({
+ applicationUniversalIdentifier,
+ roleId,
+ logicFunctionId,
+}: {
+ applicationUniversalIdentifier: string;
+ roleId: string;
+ logicFunctionId: string;
+}): Manifest => {
+ const baseManifest = buildBaseManifest({
+ appId: applicationUniversalIdentifier,
+ roleId,
+ });
+
+ return {
+ ...baseManifest,
+ application: {
+ ...baseManifest.application,
+ uninstallLogicFunction: { universalIdentifier: logicFunctionId },
+ },
+ logicFunctions: [
+ {
+ universalIdentifier: logicFunctionId,
+ name: 'Cleanup',
+ description: 'Uninstall cleanup logic function',
+ handlerName: 'handler',
+ sourceHandlerPath: 'src/cleanup.ts',
+ builtHandlerPath: 'dist/cleanup.mjs',
+ builtHandlerChecksum: 'checksum-cleanup',
+ httpRouteTriggerSettings: {
+ path: '/cleanup',
+ httpMethod: 'POST',
+ isAuthRequired: true,
+ },
+ },
+ ],
+ };
+};
+
+describe('Workspace deletion runs application uninstall hooks', () => {
+ let applicationUniversalIdentifier: string;
+ let roleId: string;
+ let logicFunctionId: string;
+ let userAccessToken: string;
+ let workspaceIdToCleanup: string | undefined;
+ let executeSpy: jest.SpyInstance;
+
+ beforeEach(() => {
+ applicationUniversalIdentifier = uuidv4();
+ roleId = uuidv4();
+ logicFunctionId = uuidv4();
+ workspaceIdToCleanup = undefined;
+
+ const logicFunctionExecutorService =
+ getAppProviderByClassName<LogicFunctionExecutorService>(
+ 'LogicFunctionExecutorService',
+ );
+
+ executeSpy = jest
+ .spyOn(logicFunctionExecutorService, 'execute')
+ .mockResolvedValue({
+ data: {},
+ duration: 1,
+ logs: '',
+ status: LogicFunctionExecutionStatus.SUCCESS,
+ });
+ });
+
+ const createSoftDeletedWorkspaceWithApplication = async () => {
+ jest.useRealTimers();
+
+ const uniqueEmail = `test-${randomUUID()}@example.com`;
+ const { data: signUpData } = await signUp({
+ input: { email: uniqueEmail, password: 'Test123!@#' },
+ expectToFail: false,
+ });
+
+ userAccessToken =
+ signUpData.signUp.tokens.accessOrWorkspaceAgnosticToken.token;
+
+ await globalThis.testDataSource.query(
+ 'UPDATE core."user" SET "isEmailVerified" = true WHERE email = $1',
+ [uniqueEmail],
+ );
+
+ const {
+ data: { signUpInNewWorkspace: newWorkspaceData },
+ } = await signUpInNewWorkspace({
+ accessToken: userAccessToken,
+ expectToFail: false,
+ });
+ const workspaceId = newWorkspaceData.workspace.id;
+
+ workspaceIdToCleanup = workspaceId;
+
+ const {
+ data: { getAuthTokensFromLoginToken: authTokensData },
+ } = await getAuthTokensFromLoginToken({
+ origin: newWorkspaceData.workspace.workspaceUrls.subdomainUrl,
+ loginToken: newWorkspaceData.loginToken.token,
+ expectToFail: false,
+ });
+ const workspaceAccessToken =
+ authTokensData.tokens.accessOrWorkspaceAgnosticToken.token;
+
+ await activateWorkspace({
+ accessToken: workspaceAccessToken,
+ expectToFail: false,
+ });
+
+ await setupApplicationForSync({
+ applicationUniversalIdentifier,
+ name: 'Workspace Deletion Hook Test App',
+ description: 'App for testing uninstall hooks on workspace deletion',
+ sourcePath: `test-workspace-deletion-hook-${applicationUniversalIdentifier}`,
+ token: workspaceAccessToken,
+ });
+
+ jest.useRealTimers();
+
+ await syncApplication({
+ manifest: buildManifestWithUninstallHook({
+ applicationUniversalIdentifier,
+ roleId,
+ logicFunctionId,
+ }),
+ token: workspaceAccessToken,
+ expectToFail: false,
+ });
+
+ const workspaceService =
+ getAppProviderByClassName<WorkspaceService>('WorkspaceService');
+
+ await workspaceService.deleteWorkspace(workspaceId, true);
+
+ const [softDeletedWorkspace] = await globalThis.testDataSource.query(
+ 'SELECT "deletedAt" FROM core."workspace" WHERE id = $1',
+ [workspaceId],
+ );
+ const workspaceDeletedAtIso = new Date(
+ softDeletedWorkspace.deletedAt,
+ ).toISOString();
+
+ await waitForAllJobsToFinish();
+
+ return { workspaceDeletedAtIso, workspaceId, workspaceService };
+ };
+
+ afterEach(async () => {
+ try {
+ if (isDefined(workspaceIdToCleanup)) {
+ const [workspaceToCleanup] = await globalThis.testDataSource.query(
+ 'SELECT id FROM core."workspace" WHERE id = $1',
+ [workspaceIdToCleanup],
+ );
+
+ if (isDefined(workspaceToCleanup)) {
+ const workspaceService =
+ getAppProviderByClassName<WorkspaceService>('WorkspaceService');
+
+ await workspaceService.deleteWorkspace(workspaceIdToCleanup);
+ }
+ }
+
+ await globalThis.testDataSource.query(
+ `DELETE FROM core."applicationRegistration" WHERE "universalIdentifier" = $1`,
+ [applicationUniversalIdentifier],
+ );
+
+ await deleteUser({ accessToken: userAccessToken });
+ } finally {
+ executeSpy.mockRestore();
+ }
+ });
+
+ it('runs the uninstall hook through the enqueued deletion job and records completion', async () => {
+ const { workspaceDeletedAtIso, workspaceId } =
+ await createSoftDeletedWorkspaceWithApplication();
+
+ expect(executeSpy).toHaveBeenCalledTimes(1);
+ expect(executeSpy).toHaveBeenCalledWith(
+ expect.objectContaining({
+ workspaceId,
+ workspaceDeletionRequestTimestamp: workspaceDeletedAtIso,
+ logicFunctionId: expect.any(String),
+ payload: {
+ version: '1.0.0',
+ idempotencyKey: `workspace-deletion:${workspaceId}:${workspaceDeletedAtIso}:${applicationUniversalIdentifier}`,
+ },
+ }),
+ );
+
+ const [applicationAfterHook] = await globalThis.testDataSource.query(
+ `SELECT "uninstallHookCompletedForRequestedAt" FROM core."application"
+ WHERE "universalIdentifier" = $1 AND "workspaceId" = $2`,
+ [applicationUniversalIdentifier, workspaceId],
+ );
+
+ expect(
+ new Date(
+ applicationAfterHook.uninstallHookCompletedForRequestedAt,
+ ).toISOString(),
+ ).toBe(workspaceDeletedAtIso);
+ }, 120000);
+
+ it('defers hard deletion while the uninstall lock is held', async () => {
+ const { workspaceId, workspaceService } =
+ await createSoftDeletedWorkspaceWithApplication();
+
+ const [workspaceMembershipBeforeDeferredHardDeletion] =
+ await globalThis.testDataSource.query(
+ `SELECT
+ "userWorkspace".id AS "userWorkspaceId",
+ "userWorkspace"."deletedAt" AS "userWorkspaceDeletedAt",
+ "user".id AS "userId",
+ "user"."deletedAt" AS "userDeletedAt"
+ FROM core."userWorkspace" "userWorkspace"
+ JOIN core."user" "user" ON "user".id = "userWorkspace"."userId"
+ WHERE "userWorkspace"."workspaceId" = $1`,
+ [workspaceId],
+ );
+
+ const postgresAdvisoryLockService =
+ getAppProviderByClassName<PostgresAdvisoryLockService>(
+ 'PostgresAdvisoryLockService',
+ );
+ let releaseWorkspaceUninstallLock = () => {};
+ let notifyWorkspaceUninstallLockAcquired = () => {};
+ const workspaceUninstallLockAcquired = new Promise<void>((resolve) => {
+ notifyWorkspaceUninstallLockAcquired = resolve;
+ });
+ const workspaceUninstallLockReleased = new Promise<void>((resolve) => {
+ releaseWorkspaceUninstallLock = resolve;
+ });
+ const heldWorkspaceUninstallLock = postgresAdvisoryLockService.tryWithLock(
+ getWorkspaceApplicationUninstallLockName(workspaceId),
+ async () => {
+ notifyWorkspaceUninstallLockAcquired();
+ await workspaceUninstallLockReleased;
+ },
+ );
+
+ await workspaceUninstallLockAcquired;
+
+ try {
+ await expect(
+ workspaceService.deleteWorkspace(workspaceId),
+ ).rejects.toThrow(
+ `Cannot hard delete workspace ${workspaceId} while application uninstall is running`,
+ );
+ } finally {
+ releaseWorkspaceUninstallLock();
+ await heldWorkspaceUninstallLock;
+ }
+
+ const [workspaceAfterDeferredHardDeletion] =
+ await globalThis.testDataSource.query(
+ 'SELECT id FROM core."workspace" WHERE id = $1',
+ [workspaceId],
+ );
+
+ expect(workspaceAfterDeferredHardDeletion.id).toBe(workspaceId);
+
+ const [workspaceMembershipAfterDeferredHardDeletion] =
+ await globalThis.testDataSource.query(
+ `SELECT
+ "userWorkspace".id AS "userWorkspaceId",
+ "userWorkspace"."deletedAt" AS "userWorkspaceDeletedAt",
+ "user".id AS "userId",
+ "user"."deletedAt" AS "userDeletedAt"
+ FROM core."userWorkspace" "userWorkspace"
+ JOIN core."user" "user" ON "user".id = "userWorkspace"."userId"
+ WHERE "userWorkspace"."workspaceId" = $1`,
+ [workspaceId],
+ );
+
+ expect(workspaceMembershipAfterDeferredHardDeletion).toEqual(
+ workspaceMembershipBeforeDeferredHardDeletion,
+ );
+
+ await workspaceService.deleteWorkspace(workspaceId);
+
+ expect(executeSpy).toHaveBeenCalledTimes(1);
+ }, 120000);
+});