Skip to content

The open alternative to Salesforce, designed for AI.

Run application upgrades as per-workspace jobs on a dedicated queue (#26341)

martmull286e97376f77
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-registration/__tests__/application-registration-upsert-from-catalog.spec.ts b/packages/twenty-server/src/engine/core-modules/application/application-registration/__tests__/application-registration-upsert-from-catalog.spec.ts
index 83adf7c67b5..9c950b735d3 100644
--- a/packages/twenty-server/src/engine/core-modules/application/application-registration/__tests__/application-registration-upsert-from-catalog.spec.ts
+++ b/packages/twenty-server/src/engine/core-modules/application/application-registration/__tests__/application-registration-upsert-from-catalog.spec.ts
@@ -97,7 +97,7 @@ describe('ApplicationRegistrationService - upsertFromCatalog', () => {
useValue: { incrementCounterBy: jest.fn() },
},
{
- provide: getQueueToken(MessageQueue.workspaceQueue),
+ provide: getQueueToken(MessageQueue.applicationUpgradeQueue),
useValue: { add: jest.fn() },
},
{
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-registration/application-registration.service.ts b/packages/twenty-server/src/engine/core-modules/application/application-registration/application-registration.service.ts
index 46667151a53..0d9f52e64d6 100644
--- a/packages/twenty-server/src/engine/core-modules/application/application-registration/application-registration.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/application/application-registration/application-registration.service.ts
@@ -146,8 +146,8 @@ export class ApplicationRegistrationService {
private readonly cacheLockService: CacheLockService,
private readonly coreEntityCacheService: CoreEntityCacheService,
private readonly metricsService: MetricsService,
- @InjectMessageQueue(MessageQueue.workspaceQueue)
- private readonly workspaceQueueService: MessageQueueService,
+ @InjectMessageQueue(MessageQueue.applicationUpgradeQueue)
+ private readonly applicationUpgradeQueueService: MessageQueueService,
private readonly workspaceEventBroadcaster: WorkspaceEventBroadcaster,
) {}
@@ -238,7 +238,7 @@ export class ApplicationRegistrationService {
applicationRegistrationId: string,
): Promise<void> {
try {
- await this.workspaceQueueService.add<UpgradeApplicationsJobData>(
+ await this.applicationUpgradeQueueService.add<UpgradeApplicationsJobData>(
UPGRADE_APPLICATIONS_JOB_NAME,
{ applicationRegistrationId, onlyAutoUpgrade: true },
);
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-upgrade/__tests__/application-upgrade.service.spec.ts b/packages/twenty-server/src/engine/core-modules/application/application-upgrade/__tests__/application-upgrade.service.spec.ts
new file mode 100644
index 00000000000..702e9d9af27
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/application/application-upgrade/__tests__/application-upgrade.service.spec.ts
@@ -0,0 +1,350 @@
+import { Test, type TestingModule } from '@nestjs/testing';
+import { getRepositoryToken } from '@nestjs/typeorm';
+
+import { ApplicationInstallService } from 'src/engine/core-modules/application/application-install/application-install.service';
+import { ApplicationRegistrationEntity } from 'src/engine/core-modules/application/application-registration/application-registration.entity';
+import { ApplicationRegistrationSourceType } from 'src/engine/core-modules/application/application-registration/enums/application-registration-source-type.enum';
+import { ApplicationUpgradeService } from 'src/engine/core-modules/application/application-upgrade/application-upgrade.service';
+import { ApplicationEntity } from 'src/engine/core-modules/application/application.entity';
+import {
+ UPGRADE_WORKSPACE_APPLICATION_JOB_ENQUEUE_BATCH_SIZE,
+ UPGRADE_WORKSPACE_APPLICATION_JOB_NAME,
+ UPGRADE_WORKSPACE_APPLICATION_JOB_OPTIONS,
+} from 'src/engine/core-modules/application/jobs/upgrade-workspace-application.job-constants';
+import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
+import { getQueueToken } from 'src/engine/core-modules/message-queue/utils/get-queue-token.util';
+import { WorkspaceVersionService } from 'src/engine/workspace-manager/workspace-version/services/workspace-version.service';
+
+const APPLICATION_REGISTRATION_ID = '20202020-0000-0000-0000-000000000001';
+const OUTDATED_WORKSPACE_ID = '20202020-0000-0000-0000-000000000002';
+const UP_TO_DATE_WORKSPACE_ID = '20202020-0000-0000-0000-000000000003';
+const NON_PROVISIONED_WORKSPACE_ID = '20202020-0000-0000-0000-000000000004';
+const TARGET_VERSION = '2.0.0';
+
+const appRegistration = {
+ id: APPLICATION_REGISTRATION_ID,
+ universalIdentifier: 'test-app',
+ sourceType: ApplicationRegistrationSourceType.NPM,
+ latestAvailableVersion: TARGET_VERSION,
+} as ApplicationRegistrationEntity;
+
+const buildApplication = ({
+ workspaceId,
+ version,
+ autoUpgrade = true,
+}: {
+ workspaceId: string;
+ version: string | null;
+ autoUpgrade?: boolean;
+}) =>
+ ({
+ applicationRegistrationId: APPLICATION_REGISTRATION_ID,
+ workspaceId,
+ version,
+ autoUpgrade,
+ }) as ApplicationEntity;
+
+describe('ApplicationUpgradeService', () => {
+ let service: ApplicationUpgradeService;
+
+ const appRegistrationRepository = {
+ findOne: jest.fn(),
+ findOneOrFail: jest.fn(),
+ };
+ const applicationRepository = { find: jest.fn(), findOne: jest.fn() };
+ const applicationInstallService = { installApplication: jest.fn() };
+ const workspaceVersionService = { getProvisionedWorkspaceIds: jest.fn() };
+ const applicationUpgradeQueueService = { bulkAdd: jest.fn() };
+
+ beforeEach(async () => {
+ jest.clearAllMocks();
+
+ appRegistrationRepository.findOne.mockResolvedValue(appRegistration);
+ appRegistrationRepository.findOneOrFail.mockResolvedValue(appRegistration);
+ workspaceVersionService.getProvisionedWorkspaceIds.mockResolvedValue([
+ OUTDATED_WORKSPACE_ID,
+ UP_TO_DATE_WORKSPACE_ID,
+ ]);
+ applicationUpgradeQueueService.bulkAdd.mockImplementation(
+ (_jobName: string, jobs: unknown[]) =>
+ jobs.map((_job, index) => `job-${index}`),
+ );
+ applicationInstallService.installApplication.mockResolvedValue(true);
+
+ const module: TestingModule = await Test.createTestingModule({
+ providers: [
+ ApplicationUpgradeService,
+ {
+ provide: getRepositoryToken(ApplicationRegistrationEntity),
+ useValue: appRegistrationRepository,
+ },
+ {
+ provide: getRepositoryToken(ApplicationEntity),
+ useValue: applicationRepository,
+ },
+ {
+ provide: ApplicationInstallService,
+ useValue: applicationInstallService,
+ },
+ {
+ provide: WorkspaceVersionService,
+ useValue: workspaceVersionService,
+ },
+ {
+ provide: getQueueToken(MessageQueue.applicationUpgradeQueue),
+ useValue: applicationUpgradeQueueService,
+ },
+ ],
+ }).compile();
+
+ service = module.get(ApplicationUpgradeService);
+ });
+
+ describe('enqueueApplicationUpgrades', () => {
+ it('enqueues one job per outdated installation on a provisioned workspace', async () => {
+ applicationRepository.find.mockResolvedValue([
+ buildApplication({
+ workspaceId: OUTDATED_WORKSPACE_ID,
+ version: '1.0.0',
+ }),
+ buildApplication({
+ workspaceId: UP_TO_DATE_WORKSPACE_ID,
+ version: TARGET_VERSION,
+ }),
+ buildApplication({
+ workspaceId: NON_PROVISIONED_WORKSPACE_ID,
+ version: '1.0.0',
+ }),
+ ]);
+
+ const jobIds = await service.enqueueApplicationUpgrades({
+ applicationRegistrationId: APPLICATION_REGISTRATION_ID,
+ onlyAutoUpgrade: true,
+ });
+
+ expect(jobIds).toEqual(['job-0']);
+ expect(applicationUpgradeQueueService.bulkAdd).toHaveBeenCalledTimes(1);
+ expect(applicationUpgradeQueueService.bulkAdd).toHaveBeenCalledWith(
+ UPGRADE_WORKSPACE_APPLICATION_JOB_NAME,
+ [
+ {
+ data: {
+ applicationRegistrationId: APPLICATION_REGISTRATION_ID,
+ workspaceId: OUTDATED_WORKSPACE_ID,
+ onlyAutoUpgrade: true,
+ },
+ },
+ ],
+ UPGRADE_WORKSPACE_APPLICATION_JOB_OPTIONS,
+ );
+ });
+
+ it('splits a large fan-out into several bulk adds', async () => {
+ const workspaceIds = Array.from(
+ { length: UPGRADE_WORKSPACE_APPLICATION_JOB_ENQUEUE_BATCH_SIZE + 1 },
+ (_, index) =>
+ `20202020-0000-0000-0000-${String(index).padStart(12, '0')}`,
+ );
+
+ workspaceVersionService.getProvisionedWorkspaceIds.mockResolvedValue(
+ workspaceIds,
+ );
+ applicationRepository.find.mockResolvedValue(
+ workspaceIds.map((workspaceId) =>
+ buildApplication({ workspaceId, version: '1.0.0' }),
+ ),
+ );
+
+ const jobIds = await service.enqueueApplicationUpgrades({
+ applicationRegistrationId: APPLICATION_REGISTRATION_ID,
+ });
+
+ expect(jobIds).toHaveLength(workspaceIds.length);
+ expect(applicationUpgradeQueueService.bulkAdd).toHaveBeenCalledTimes(2);
+ expect(
+ applicationUpgradeQueueService.bulkAdd.mock.calls[0][1],
+ ).toHaveLength(UPGRADE_WORKSPACE_APPLICATION_JOB_ENQUEUE_BATCH_SIZE);
+ expect(
+ applicationUpgradeQueueService.bulkAdd.mock.calls[1][1],
+ ).toHaveLength(1);
+ });
+
+ it('enqueues nothing when every installation already runs the latest version', async () => {
+ applicationRepository.find.mockResolvedValue([
+ buildApplication({
+ workspaceId: UP_TO_DATE_WORKSPACE_ID,
+ version: TARGET_VERSION,
+ }),
+ ]);
+
+ const jobIds = await service.enqueueApplicationUpgrades({
+ applicationRegistrationId: APPLICATION_REGISTRATION_ID,
+ });
+
+ expect(jobIds).toEqual([]);
+ expect(applicationUpgradeQueueService.bulkAdd).not.toHaveBeenCalled();
+ });
+
+ it('enqueues nothing when the registration has no latest available version', async () => {
+ appRegistrationRepository.findOneOrFail.mockResolvedValue({
+ ...appRegistration,
+ latestAvailableVersion: null,
+ });
+
+ const jobIds = await service.enqueueApplicationUpgrades({
+ applicationRegistrationId: APPLICATION_REGISTRATION_ID,
+ });
+
+ expect(jobIds).toEqual([]);
+ expect(applicationRepository.find).not.toHaveBeenCalled();
+ expect(applicationUpgradeQueueService.bulkAdd).not.toHaveBeenCalled();
+ });
+ });
+
+ describe('upgradeWorkspaceApplicationToLatestVersion', () => {
+ it('installs the latest available version on an outdated workspace', async () => {
+ applicationRepository.findOne.mockResolvedValue(
+ buildApplication({
+ workspaceId: OUTDATED_WORKSPACE_ID,
+ version: '1.0.0',
+ }),
+ );
+
+ await service.upgradeWorkspaceApplicationToLatestVersion({
+ applicationRegistrationId: APPLICATION_REGISTRATION_ID,
+ workspaceId: OUTDATED_WORKSPACE_ID,
+ onlyAutoUpgrade: false,
+ });
+
+ expect(applicationInstallService.installApplication).toHaveBeenCalledWith(
+ {
+ appRegistrationId: APPLICATION_REGISTRATION_ID,
+ version: TARGET_VERSION,
+ workspaceId: OUTDATED_WORKSPACE_ID,
+ },
+ );
+ });
+
+ it('installs the latest available version on a workspace whose install never completed', async () => {
+ applicationRepository.findOne.mockResolvedValue(
+ buildApplication({ workspaceId: OUTDATED_WORKSPACE_ID, version: null }),
+ );
+
+ await service.upgradeWorkspaceApplicationToLatestVersion({
+ applicationRegistrationId: APPLICATION_REGISTRATION_ID,
+ workspaceId: OUTDATED_WORKSPACE_ID,
+ onlyAutoUpgrade: false,
+ });
+
+ expect(
+ applicationInstallService.installApplication,
+ ).toHaveBeenCalledTimes(1);
+ });
+
+ it('skips an automatic upgrade on a workspace that disabled auto upgrade after the fan-out', async () => {
+ applicationRepository.findOne.mockResolvedValue(
+ buildApplication({
+ workspaceId: OUTDATED_WORKSPACE_ID,
+ version: '1.0.0',
+ autoUpgrade: false,
+ }),
+ );
+
+ await service.upgradeWorkspaceApplicationToLatestVersion({
+ applicationRegistrationId: APPLICATION_REGISTRATION_ID,
+ workspaceId: OUTDATED_WORKSPACE_ID,
+ onlyAutoUpgrade: true,
+ });
+
+ expect(
+ applicationInstallService.installApplication,
+ ).not.toHaveBeenCalled();
+ });
+
+ it('still upgrades a workspace that disabled auto upgrade when the upgrade is manual', async () => {
+ applicationRepository.findOne.mockResolvedValue(
+ buildApplication({
+ workspaceId: OUTDATED_WORKSPACE_ID,
+ version: '1.0.0',
+ autoUpgrade: false,
+ }),
+ );
+
+ await service.upgradeWorkspaceApplicationToLatestVersion({
+ applicationRegistrationId: APPLICATION_REGISTRATION_ID,
+ workspaceId: OUTDATED_WORKSPACE_ID,
+ onlyAutoUpgrade: false,
+ });
+
+ expect(
+ applicationInstallService.installApplication,
+ ).toHaveBeenCalledTimes(1);
+ });
+
+ it('skips a workspace that already runs the latest available version', async () => {
+ applicationRepository.findOne.mockResolvedValue(
+ buildApplication({
+ workspaceId: UP_TO_DATE_WORKSPACE_ID,
+ version: TARGET_VERSION,
+ }),
+ );
+
+ await service.upgradeWorkspaceApplicationToLatestVersion({
+ applicationRegistrationId: APPLICATION_REGISTRATION_ID,
+ workspaceId: UP_TO_DATE_WORKSPACE_ID,
+ onlyAutoUpgrade: false,
+ });
+
+ expect(
+ applicationInstallService.installApplication,
+ ).not.toHaveBeenCalled();
+ });
+
+ it('skips a workspace where the application is no longer installed', async () => {
+ applicationRepository.findOne.mockResolvedValue(null);
+
+ await service.upgradeWorkspaceApplicationToLatestVersion({
+ applicationRegistrationId: APPLICATION_REGISTRATION_ID,
+ workspaceId: OUTDATED_WORKSPACE_ID,
+ onlyAutoUpgrade: false,
+ });
+
+ expect(
+ applicationInstallService.installApplication,
+ ).not.toHaveBeenCalled();
+ });
+
+ it('skips when the registration no longer exists', async () => {
+ appRegistrationRepository.findOne.mockResolvedValue(null);
+
+ await service.upgradeWorkspaceApplicationToLatestVersion({
+ applicationRegistrationId: APPLICATION_REGISTRATION_ID,
+ workspaceId: OUTDATED_WORKSPACE_ID,
+ onlyAutoUpgrade: false,
+ });
+
+ expect(applicationRepository.findOne).not.toHaveBeenCalled();
+ expect(
+ applicationInstallService.installApplication,
+ ).not.toHaveBeenCalled();
+ });
+
+ it('skips when the registration has no latest available version', async () => {
+ appRegistrationRepository.findOne.mockResolvedValue({
+ ...appRegistration,
+ latestAvailableVersion: null,
+ });
+
+ await service.upgradeWorkspaceApplicationToLatestVersion({
+ applicationRegistrationId: APPLICATION_REGISTRATION_ID,
+ workspaceId: OUTDATED_WORKSPACE_ID,
+ onlyAutoUpgrade: false,
+ });
+
+ expect(applicationRepository.findOne).not.toHaveBeenCalled();
+ expect(
+ applicationInstallService.installApplication,
+ ).not.toHaveBeenCalled();
+ });
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-upgrade/application-upgrade.module.ts b/packages/twenty-server/src/engine/core-modules/application/application-upgrade/application-upgrade.module.ts
index 288471c5484..3d4874a4b6b 100644
--- a/packages/twenty-server/src/engine/core-modules/application/application-upgrade/application-upgrade.module.ts
+++ b/packages/twenty-server/src/engine/core-modules/application/application-upgrade/application-upgrade.module.ts
@@ -1,7 +1,6 @@
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
-import { WorkspaceIteratorModule } from 'src/database/commands/command-runners/workspace-iterator.module';
import { ApplicationInstallModule } from 'src/engine/core-modules/application/application-install/application-install.module';
import { ApplicationEntity } from 'src/engine/core-modules/application/application.entity';
import { ApplicationRegistrationEntity } from 'src/engine/core-modules/application/application-registration/application-registration.entity';
@@ -28,7 +27,6 @@ import { PermissionsModule } from 'src/engine/metadata-modules/permissions/permi
FeatureFlagModule,
PermissionsModule,
TwentyConfigModule,
- WorkspaceIteratorModule,
WorkspaceVersionModule,
],
providers: [
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-upgrade/application-upgrade.service.ts b/packages/twenty-server/src/engine/core-modules/application/application-upgrade/application-upgrade.service.ts
index 2947bd8f8d1..ecb8d788d68 100644
--- a/packages/twenty-server/src/engine/core-modules/application/application-upgrade/application-upgrade.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/application/application-upgrade/application-upgrade.service.ts
@@ -1,13 +1,10 @@
import { Injectable, Logger } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
+import chunk from 'lodash.chunk';
import { isDefined, isNonEmptyArray } from 'twenty-shared/utils';
import { In, Repository } from 'typeorm';
-import {
- WorkspaceIteratorService,
- type WorkspaceIteratorReport,
-} from 'src/database/commands/command-runners/workspace-iterator.service';
import { ApplicationInstallService } from 'src/engine/core-modules/application/application-install/application-install.service';
import { ApplicationRegistrationEntity } from 'src/engine/core-modules/application/application-registration/application-registration.entity';
import { ApplicationRegistrationSourceType } from 'src/engine/core-modules/application/application-registration/enums/application-registration-source-type.enum';
@@ -16,6 +13,15 @@ import {
ApplicationException,
ApplicationExceptionCode,
} from 'src/engine/core-modules/application/application.exception';
+import {
+ UPGRADE_WORKSPACE_APPLICATION_JOB_ENQUEUE_BATCH_SIZE,
+ UPGRADE_WORKSPACE_APPLICATION_JOB_NAME,
+ UPGRADE_WORKSPACE_APPLICATION_JOB_OPTIONS,
+ type UpgradeWorkspaceApplicationJobData,
+} from 'src/engine/core-modules/application/jobs/upgrade-workspace-application.job-constants';
+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';
import { WorkspaceVersionService } from 'src/engine/workspace-manager/workspace-version/services/workspace-version.service';
@Injectable()
@@ -28,8 +34,9 @@ export class ApplicationUpgradeService {
@InjectRepository(ApplicationEntity)
private readonly applicationRepository: Repository<ApplicationEntity>,
private readonly applicationInstallService: ApplicationInstallService,
- private readonly workspaceIteratorService: WorkspaceIteratorService,
private readonly workspaceVersionService: WorkspaceVersionService,
+ @InjectMessageQueue(MessageQueue.applicationUpgradeQueue)
+ private readonly applicationUpgradeQueueService: MessageQueueService,
) {}
async findApplicationsToUpgrade({
@@ -103,61 +110,137 @@ export class ApplicationUpgradeService {
};
}
- async upgradeApplications({
- appRegistration,
- targetVersion,
+ async enqueueWorkspaceApplicationUpgrades({
+ applicationRegistrationId,
applications,
+ onlyAutoUpgrade,
}: {
- appRegistration: ApplicationRegistrationEntity;
- targetVersion: string;
+ applicationRegistrationId: string;
applications: ApplicationEntity[];
- }): Promise<WorkspaceIteratorReport> {
- // An empty workspace id list makes the iterator fall back to every
- // provisioned workspace, which would upgrade workspaces that were
- // filtered out.
+ onlyAutoUpgrade: boolean;
+ }): Promise<string[]> {
if (!isNonEmptyArray(applications)) {
- return { success: [], fail: [], interrupted: false };
+ return [];
}
- return this.workspaceIteratorService.iterate({
- workspaceIds: applications.map((application) => application.workspaceId),
- callback: async ({ workspaceId }) => {
- await this.upgradeApplicationToVersion({
- appRegistration,
- targetVersion,
- workspaceId,
- });
- },
- });
+ const jobIds: string[] = [];
+
+ for (const applicationsBatch of chunk(
+ applications,
+ UPGRADE_WORKSPACE_APPLICATION_JOB_ENQUEUE_BATCH_SIZE,
+ )) {
+ const batchJobIds =
+ await this.applicationUpgradeQueueService.bulkAdd<UpgradeWorkspaceApplicationJobData>(
+ UPGRADE_WORKSPACE_APPLICATION_JOB_NAME,
+ applicationsBatch.map((application) => ({
+ data: {
+ applicationRegistrationId,
+ workspaceId: application.workspaceId,
+ onlyAutoUpgrade,
+ },
+ })),
+ UPGRADE_WORKSPACE_APPLICATION_JOB_OPTIONS,
+ );
+
+ jobIds.push(...batchJobIds);
+ }
+
+ return jobIds;
}
- async upgradeAllApplications({
+ async enqueueApplicationUpgrades({
applicationRegistrationId,
onlyAutoUpgrade = false,
- workspaceIds,
- workspaceCountLimit,
}: {
applicationRegistrationId: string;
onlyAutoUpgrade?: boolean;
- workspaceIds?: string[];
- workspaceCountLimit?: number;
- }): Promise<void> {
+ }): Promise<string[]> {
const { appRegistration, targetVersion, applicationsToUpgrade } =
await this.findApplicationsToUpgrade({
applicationRegistrationId,
onlyAutoUpgrade,
- workspaceIds,
- workspaceCountLimit,
});
if (!isDefined(targetVersion)) {
+ return [];
+ }
+
+ const jobIds = await this.enqueueWorkspaceApplicationUpgrades({
+ applicationRegistrationId,
+ applications: applicationsToUpgrade,
+ onlyAutoUpgrade,
+ });
+
+ this.logger.log(
+ `Enqueued ${jobIds.length} upgrade job(s) for ${appRegistration.universalIdentifier}, latest available version is ${targetVersion}`,
+ );
+
+ return jobIds;
+ }
+
+ async upgradeWorkspaceApplicationToLatestVersion({
+ applicationRegistrationId,
+ workspaceId,
+ onlyAutoUpgrade,
+ }: {
+ applicationRegistrationId: string;
+ workspaceId: string;
+ onlyAutoUpgrade: boolean;
+ }): Promise<void> {
+ const appRegistration = await this.appRegistrationRepository.findOne({
+ where: { id: applicationRegistrationId },
+ });
+
+ if (!isDefined(appRegistration)) {
+ this.logger.log(
+ `Skipping upgrade for application registration ${applicationRegistrationId} on workspace ${workspaceId}: registration no longer exists`,
+ );
+
+ return;
+ }
+
+ const targetVersion = appRegistration.latestAvailableVersion;
+
+ if (!isDefined(targetVersion)) {
+ this.logger.log(
+ `Skipping upgrade of ${appRegistration.universalIdentifier} on workspace ${workspaceId}: no latest available version`,
+ );
+
return;
}
- await this.upgradeApplications({
+ const application = await this.applicationRepository.findOne({
+ where: { applicationRegistrationId, workspaceId },
+ });
+
+ if (!isDefined(application)) {
+ this.logger.log(
+ `Skipping upgrade of ${appRegistration.universalIdentifier} on workspace ${workspaceId}: application is not installed anymore`,
+ );
+
+ return;
+ }
+
+ if (onlyAutoUpgrade && !application.autoUpgrade) {
+ this.logger.log(
+ `Skipping upgrade of ${appRegistration.universalIdentifier} on workspace ${workspaceId}: auto upgrade is disabled`,
+ );
+
+ return;
+ }
+
+ if (application.version === targetVersion) {
+ this.logger.log(
+ `Skipping upgrade of ${appRegistration.universalIdentifier} on workspace ${workspaceId}: already on version ${targetVersion}`,
+ );
+
+ return;
+ }
+
+ await this.upgradeApplicationToVersion({
appRegistration,
targetVersion,
- applications: applicationsToUpgrade,
+ workspaceId,
});
}
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-upgrade/commands/upgrade-application.command.ts b/packages/twenty-server/src/engine/core-modules/application/application-upgrade/commands/upgrade-application.command.ts
index e45e921455f..0565a18e66d 100644
--- a/packages/twenty-server/src/engine/core-modules/application/application-upgrade/commands/upgrade-application.command.ts
+++ b/packages/twenty-server/src/engine/core-modules/application/application-upgrade/commands/upgrade-application.command.ts
@@ -10,6 +10,7 @@ import { askCommandConfirmation } from 'src/database/commands/utils/ask-command-
import { parseBoundedPositiveInteger } from 'src/database/commands/utils/parse-bounded-positive-integer.util';
import { ApplicationRegistrationEntity } from 'src/engine/core-modules/application/application-registration/application-registration.entity';
import { ApplicationUpgradeService } from 'src/engine/core-modules/application/application-upgrade/application-upgrade.service';
+import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
type UpgradeApplicationCommandOptions = {
applicationRegistrationUniversalIdentifier: string;
@@ -24,7 +25,7 @@ const MAX_WORKSPACE_COUNT_LIMIT = 50;
@Command({
name: 'application:upgrade',
description:
- 'Upgrade an application to its latest available version on every workspace that already has it installed',
+ 'Enqueue one upgrade job per workspace to bring an application to its latest available version everywhere it is installed',
})
export class UpgradeApplicationCommand extends CommandRunner {
protected logger: CommandLogger;
@@ -117,7 +118,6 @@ export class UpgradeApplicationCommand extends CommandRunner {
: undefined;
const {
- appRegistration,
targetVersion,
applicationsToUpgrade,
skippedNonProvisionedWorkspaceIds,
@@ -148,11 +148,11 @@ export class UpgradeApplicationCommand extends CommandRunner {
if (options.dryRun ?? false) {
this.logger.log(
- `[DRY RUN] Would upgrade "${registration.name}" (${registration.universalIdentifier}) to version ${targetVersion} on ${impactedWorkspaceIds.length} workspace(s)${
+ `[DRY RUN] Would enqueue an upgrade job for "${registration.name}" (${registration.universalIdentifier}) on ${impactedWorkspaceIds.length} workspace(s)${
impactedWorkspaceIds.length > 0
? `: ${impactedWorkspaceIds.join(', ')}`
: ''
- }`,
+ }. Jobs install the latest available version when they run, currently ${targetVersion}`,
);
return;
@@ -172,30 +172,25 @@ export class UpgradeApplicationCommand extends CommandRunner {
: `${impactedWorkspaceIds.length} workspace(s)`;
const isConfirmed = await askCommandConfirmation(
- `Confirm upgrading application ${registration.universalIdentifier} to version ${targetVersion} on ${confirmationTarget}`,
+ `Confirm enqueuing upgrade jobs for application ${registration.universalIdentifier} on ${confirmationTarget}. Jobs install the latest available version when they run, currently ${targetVersion}`,
);
if (!isConfirmed) {
- this.logger.log('Aborted, no upgrade performed');
+ this.logger.log('Aborted, no upgrade enqueued');
return;
}
}
- this.logger.log(
- `Upgrading "${registration.name}" (${registration.universalIdentifier}) to version ${targetVersion} on ${impactedWorkspaceIds.length} workspace(s)...`,
- );
-
- // Runs on the exact set shown at confirmation time, so installations
- // created or versions published while the operator answered are excluded.
- const report = await this.applicationUpgradeService.upgradeApplications({
- appRegistration,
- targetVersion,
- applications: applicationsToUpgrade,
- });
+ const enqueuedJobIds =
+ await this.applicationUpgradeService.enqueueWorkspaceApplicationUpgrades({
+ applicationRegistrationId: registration.id,
+ applications: applicationsToUpgrade,
+ onlyAutoUpgrade: false,
+ });
this.logger.log(
- `Upgraded ${report.success.length} workspace(s), ${report.fail.length} failed`,
+ `Enqueued ${enqueuedJobIds.length} upgrade job(s) on ${MessageQueue.applicationUpgradeQueue} for "${registration.name}" (${registration.universalIdentifier}) on ${impactedWorkspaceIds.length} workspace(s). Jobs install the latest available version when they run, currently ${targetVersion}`,
);
this.logger.log(chalk.blue('Command completed!'));
diff --git a/packages/twenty-server/src/engine/core-modules/application/jobs/upgrade-applications.job.ts b/packages/twenty-server/src/engine/core-modules/application/jobs/upgrade-applications.job.ts
index 0e208071d74..bc2361fc14f 100644
--- a/packages/twenty-server/src/engine/core-modules/application/jobs/upgrade-applications.job.ts
+++ b/packages/twenty-server/src/engine/core-modules/application/jobs/upgrade-applications.job.ts
@@ -7,7 +7,7 @@ import { Process } from 'src/engine/core-modules/message-queue/decorators/proces
import { Processor } from 'src/engine/core-modules/message-queue/decorators/processor.decorator';
import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
-@Processor(MessageQueue.workspaceQueue)
+@Processor(MessageQueue.applicationUpgradeQueue)
export class UpgradeApplicationsJob {
constructor(
private readonly applicationUpgradeService: ApplicationUpgradeService,
@@ -15,7 +15,7 @@ export class UpgradeApplicationsJob {
@Process(UPGRADE_APPLICATIONS_JOB_NAME)
async handle(data: UpgradeApplicationsJobData): Promise<void> {
- await this.applicationUpgradeService.upgradeAllApplications({
+ await this.applicationUpgradeService.enqueueApplicationUpgrades({
applicationRegistrationId: data.applicationRegistrationId,
onlyAutoUpgrade: data.onlyAutoUpgrade,
});
diff --git a/packages/twenty-server/src/engine/core-modules/application/jobs/upgrade-workspace-application.job-constants.ts b/packages/twenty-server/src/engine/core-modules/application/jobs/upgrade-workspace-application.job-constants.ts
new file mode 100644
index 00000000000..fcebc30a42d
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/application/jobs/upgrade-workspace-application.job-constants.ts
@@ -0,0 +1,21 @@
+import { type QueueJobOptions } from 'src/engine/core-modules/message-queue/drivers/interfaces/job-options.interface';
+
+export const UPGRADE_WORKSPACE_APPLICATION_JOB_NAME =
+ 'UpgradeWorkspaceApplicationJob';
+
+export const UPGRADE_WORKSPACE_APPLICATION_JOB_ENQUEUE_BATCH_SIZE = 500;
+
+export const UPGRADE_WORKSPACE_APPLICATION_JOB_OPTIONS: QueueJobOptions = {
+ retryLimit: 2,
+ backoff: {
+ strategy: 'exponential',
+ initialDelayMilliseconds: 5_000,
+ jitter: 0.5,
+ },
+};
+
+export type UpgradeWorkspaceApplicationJobData = {
+ applicationRegistrationId: string;
+ workspaceId: string;
+ onlyAutoUpgrade: boolean;
+};
diff --git a/packages/twenty-server/src/engine/core-modules/application/jobs/upgrade-workspace-application.job.ts b/packages/twenty-server/src/engine/core-modules/application/jobs/upgrade-workspace-application.job.ts
new file mode 100644
index 00000000000..cd746facdb4
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/application/jobs/upgrade-workspace-application.job.ts
@@ -0,0 +1,26 @@
+import { ApplicationUpgradeService } from 'src/engine/core-modules/application/application-upgrade/application-upgrade.service';
+import {
+ UPGRADE_WORKSPACE_APPLICATION_JOB_NAME,
+ type UpgradeWorkspaceApplicationJobData,
+} from 'src/engine/core-modules/application/jobs/upgrade-workspace-application.job-constants';
+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';
+
+@Processor(MessageQueue.applicationUpgradeQueue)
+export class UpgradeWorkspaceApplicationJob {
+ constructor(
+ private readonly applicationUpgradeService: ApplicationUpgradeService,
+ ) {}
+
+ @Process(UPGRADE_WORKSPACE_APPLICATION_JOB_NAME)
+ async handle(data: UpgradeWorkspaceApplicationJobData): Promise<void> {
+ await this.applicationUpgradeService.upgradeWorkspaceApplicationToLatestVersion(
+ {
+ applicationRegistrationId: data.applicationRegistrationId,
+ workspaceId: data.workspaceId,
+ onlyAutoUpgrade: data.onlyAutoUpgrade,
+ },
+ );
+ }
+}
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 9f94bf453d9..110f62dabd3 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
@@ -21,6 +21,7 @@ import { ApplicationManifestModule } from 'src/engine/core-modules/application/a
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';
+import { UpgradeWorkspaceApplicationJob } from 'src/engine/core-modules/application/jobs/upgrade-workspace-application.job';
import { InstallPreInstalledAppsJob } from 'src/engine/core-modules/application/pre-installed-apps/jobs/install-pre-installed-apps.job';
import { PreInstalledAppsModule } from 'src/engine/core-modules/application/pre-installed-apps/pre-installed-apps.module';
import { InstallOnboardingAppsJob } from 'src/engine/core-modules/onboarding/jobs/install-onboarding-apps.job';
@@ -141,6 +142,7 @@ import { WorkflowModule } from 'src/modules/workflow/workflow.module';
UpdateWorkspaceMemberEmailJob,
GenerateSdkClientJob,
UpgradeApplicationsJob,
+ UpgradeWorkspaceApplicationJob,
InstallOnboardingAppsJob,
InstallPreInstalledAppsJob,
TriggerInstallApplicationJob,
diff --git a/packages/twenty-server/src/engine/core-modules/message-queue/message-queue-worker-config.constant.ts b/packages/twenty-server/src/engine/core-modules/message-queue/message-queue-worker-config.constant.ts
index 663530130bd..2096129b37f 100644
--- a/packages/twenty-server/src/engine/core-modules/message-queue/message-queue-worker-config.constant.ts
+++ b/packages/twenty-server/src/engine/core-modules/message-queue/message-queue-worker-config.constant.ts
@@ -202,6 +202,15 @@ export const MESSAGE_QUEUE_WORKER_CONFIG: Record<
boundedShutdownDrain: false,
},
},
+ [MessageQueue.applicationUpgradeQueue]: {
+ priority: 6,
+ workerOptions: {
+ concurrency: 2,
+ lockDuration: 60_000,
+ maxStalledCount: 1,
+ boundedShutdownDrain: false,
+ },
+ },
[MessageQueue.triggerQueue]: {
priority: 5,
workerOptions: {
diff --git a/packages/twenty-server/src/engine/core-modules/message-queue/message-queue.constants.ts b/packages/twenty-server/src/engine/core-modules/message-queue/message-queue.constants.ts
index c69434ab4f5..458091e58a1 100644
--- a/packages/twenty-server/src/engine/core-modules/message-queue/message-queue.constants.ts
+++ b/packages/twenty-server/src/engine/core-modules/message-queue/message-queue.constants.ts
@@ -23,6 +23,7 @@ export enum MessageQueue {
deleteCascadeQueue = 'delete-cascade-queue',
logicFunctionQueue = 'logic-function-queue',
applicationLifecycleHookQueue = 'application-lifecycle-hook-queue',
+ applicationUpgradeQueue = 'application-upgrade-queue',
triggerQueue = 'trigger-queue',
aiQueue = 'ai-queue',
aiStreamQueue = 'ai-stream-queue',