Skip to content

The open alternative to Salesforce, designed for AI.

Set application logo only once its file is stored (#27980)

martmull0b37a628943c
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-install/__tests__/application-install.service.spec.ts b/packages/twenty-server/src/engine/core-modules/application/application-install/__tests__/application-install.service.spec.ts
new file mode 100644
index 00000000000..2ee8c51baaa
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/application/application-install/__tests__/application-install.service.spec.ts
@@ -0,0 +1,194 @@
+import { promises as fs } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+import { type Manifest } from 'twenty-shared/application';
+import { FileFolder } from 'twenty-shared/types';
+import { type Repository } from 'typeorm';
+
+import { ApplicationInstallService } from 'src/engine/core-modules/application/application-install/application-install.service';
+import { type ApplicationManifestApplyService } from 'src/engine/core-modules/application/application-manifest/application-manifest-apply.service';
+import { type ApplicationSyncService } from 'src/engine/core-modules/application/application-manifest/application-sync.service';
+import {
+ type ApplicationPackageFetcherService,
+ type ResolvedPackage,
+} from 'src/engine/core-modules/application/application-package/application-package-fetcher.service';
+import { type ApplicationVersionValidationService } from 'src/engine/core-modules/application/application-package/application-version-validation.service';
+import { type 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 { type ApplicationLookupService } from 'src/engine/core-modules/application/application-lookup/application-lookup.service';
+import { type ApplicationService } from 'src/engine/core-modules/application/application.service';
+import { type CacheLockService } from 'src/engine/core-modules/cache-lock/cache-lock.service';
+import { type FileStorageService } from 'src/engine/core-modules/file-storage/services/file-storage.service';
+import { type LogicFunctionExecutorService } from 'src/engine/core-modules/logic-function/logic-function-executor/logic-function-executor.service';
+import { type MessageQueueService } from 'src/engine/core-modules/message-queue/services/message-queue.service';
+import { type MetricsService } from 'src/engine/core-modules/metrics/metrics.service';
+import { type WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+
+const WORKSPACE_ID = 'workspace-id';
+const APPLICATION_ID = 'application-id';
+const APPLICATION_REGISTRATION_ID = 'application-registration-id';
+const APPLICATION_UNIVERSAL_IDENTIFIER = 'application-universal-identifier';
+const LOGO_PATH = 'public/logo.png';
+const LOGO_FILE_ID = 'logo-file-id';
+
+const MANIFEST = {
+ application: {
+ universalIdentifier: APPLICATION_UNIVERSAL_IDENTIFIER,
+ displayName: 'Application',
+ logo: LOGO_PATH,
+ },
+ publicAssets: [{ filePath: LOGO_PATH }],
+} as unknown as Manifest;
+
+describe('ApplicationInstallService', () => {
+ let extractedDir: string;
+
+ const applicationService = {
+ create: jest.fn(),
+ update: jest.fn(),
+ };
+ const applicationLookupService = {
+ findByUniversalIdentifier: jest.fn(),
+ };
+ const applicationPackageFetcherService = {
+ resolvePackage: jest.fn(),
+ cleanupExtractedDir: jest.fn(),
+ };
+ const fileStorageService = {
+ writeFile: jest.fn(),
+ };
+
+ const service = new ApplicationInstallService(
+ {
+ findOne: jest.fn().mockResolvedValue({
+ id: APPLICATION_REGISTRATION_ID,
+ universalIdentifier: APPLICATION_UNIVERSAL_IDENTIFIER,
+ sourceType: ApplicationRegistrationSourceType.NPM,
+ manifest: null,
+ }),
+ } as unknown as Repository<ApplicationRegistrationEntity>,
+ applicationService as unknown as ApplicationService,
+ applicationLookupService as unknown as ApplicationLookupService,
+ applicationPackageFetcherService as unknown as ApplicationPackageFetcherService,
+ {
+ validateVersionProgression: jest.fn().mockReturnValue({ allowed: true }),
+ } as unknown as ApplicationVersionValidationService,
+ {} as ApplicationSyncService,
+ {
+ applyManifestToWorkspace: jest
+ .fn()
+ .mockResolvedValue({ workspaceMigration: { actions: [] } }),
+ refreshRegistrationFromManifest: jest.fn(),
+ } as unknown as ApplicationManifestApplyService,
+ fileStorageService as unknown as FileStorageService,
+ {} as LogicFunctionExecutorService,
+ {
+ withLock: jest.fn((callback: () => Promise<boolean>) => callback()),
+ } as unknown as CacheLockService,
+ {} as MessageQueueService,
+ {} as MessageQueueService,
+ {} as WorkspaceCacheService,
+ { incrementCounterBy: jest.fn() } as unknown as MetricsService,
+ );
+
+ const install = () =>
+ service.installApplication({
+ appRegistrationId: APPLICATION_REGISTRATION_ID,
+ workspaceId: WORKSPACE_ID,
+ skipWorkspaceCompatibilityCheck: true,
+ });
+
+ beforeEach(async () => {
+ jest.clearAllMocks();
+
+ extractedDir = await fs.mkdtemp(join(tmpdir(), 'application-install-'));
+
+ await fs.mkdir(join(extractedDir, 'public'));
+ await fs.writeFile(join(extractedDir, 'package.json'), '{}');
+ await fs.writeFile(join(extractedDir, 'manifest.json'), '{}');
+ await fs.writeFile(join(extractedDir, LOGO_PATH), 'logo');
+
+ const resolvedPackage: ResolvedPackage = {
+ extractedDir,
+ cleanupDir: extractedDir,
+ manifest: MANIFEST,
+ packageJson: { version: '1.1.0' },
+ };
+
+ applicationPackageFetcherService.resolvePackage.mockResolvedValue(
+ resolvedPackage,
+ );
+ fileStorageService.writeFile.mockResolvedValue({ id: LOGO_FILE_ID });
+ applicationService.update.mockResolvedValue(undefined);
+ });
+
+ afterEach(async () => {
+ await fs.rm(extractedDir, { recursive: true, force: true });
+ });
+
+ it('sets the logo on a new application only once its file is stored', async () => {
+ applicationLookupService.findByUniversalIdentifier.mockResolvedValue(null);
+ applicationService.create.mockResolvedValue({
+ id: APPLICATION_ID,
+ logo: null,
+ logoFileId: null,
+ version: null,
+ });
+
+ let isLogoFileStored = false;
+ const isLogoFileStoredWhenLogoIsSet: boolean[] = [];
+
+ fileStorageService.writeFile.mockImplementation(
+ async ({ fileFolder, resourcePath }) => {
+ await Promise.resolve();
+
+ if (
+ fileFolder === FileFolder.PublicAsset &&
+ resourcePath === LOGO_PATH
+ ) {
+ isLogoFileStored = true;
+ }
+
+ return { id: LOGO_FILE_ID };
+ },
+ );
+ applicationService.update.mockImplementation(
+ async (_applicationId, data) => {
+ if ('logo' in data) {
+ isLogoFileStoredWhenLogoIsSet.push(isLogoFileStored);
+ }
+ },
+ );
+
+ await install();
+
+ expect(applicationService.create).toHaveBeenCalledTimes(1);
+ expect(applicationService.create).toHaveBeenCalledWith(
+ expect.not.objectContaining({ logo: expect.anything() }),
+ );
+ expect(applicationService.update).toHaveBeenCalledWith(APPLICATION_ID, {
+ logo: LOGO_PATH,
+ logoFileId: LOGO_FILE_ID,
+ workspaceId: WORKSPACE_ID,
+ });
+ expect(isLogoFileStoredWhenLogoIsSet).toEqual([true]);
+ });
+
+ it('does not update an upgraded application whose logo is unchanged', async () => {
+ applicationLookupService.findByUniversalIdentifier.mockResolvedValue({
+ id: APPLICATION_ID,
+ logo: LOGO_PATH,
+ logoFileId: LOGO_FILE_ID,
+ version: '1.0.0',
+ });
+
+ await install();
+
+ expect(applicationService.create).not.toHaveBeenCalled();
+ expect(applicationService.update).not.toHaveBeenCalledWith(
+ APPLICATION_ID,
+ expect.objectContaining({ logo: LOGO_PATH }),
+ );
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-install/application-install.service.ts b/packages/twenty-server/src/engine/core-modules/application/application-install/application-install.service.ts
index fea3b05bd1f..dfd9375c2f8 100644
--- a/packages/twenty-server/src/engine/core-modules/application/application-install/application-install.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/application/application-install/application-install.service.ts
@@ -345,10 +345,6 @@ export class ApplicationInstallService {
universalIdentifier,
name: resolvedPackage.manifest.application.displayName,
grantedCapabilities,
- logo:
- resolvedPackage.manifest.application.logo ??
- resolvedPackage.manifest.application.logoUrl ??
- null,
workspaceId: params.workspaceId,
applicationRegistrationId: appRegistration.id,
sourceType: appRegistration.sourceType,
@@ -399,16 +395,22 @@ export class ApplicationInstallService {
params.workspaceId,
);
+ const logo =
+ resolvedPackage.manifest.application.logo ??
+ resolvedPackage.manifest.application.logoUrl ??
+ null;
+
const logoFileId = await this.importLogoFile({
extractedDir: resolvedPackage.extractedDir,
- manifest: resolvedPackage.manifest,
+ logo,
applicationUniversalIdentifier: universalIdentifier,
workspaceId: params.workspaceId,
});
- if (application.logoFileId !== logoFileId) {
+ if (application.logo !== logo || application.logoFileId !== logoFileId) {
await this.applicationService.update(application.id, {
- logoFileId: logoFileId ?? null,
+ logo,
+ logoFileId,
workspaceId: params.workspaceId,
});
}
@@ -798,17 +800,15 @@ export class ApplicationInstallService {
private async importLogoFile({
extractedDir,
- manifest,
+ logo,
applicationUniversalIdentifier,
workspaceId,
}: {
extractedDir: string;
- manifest: Manifest;
+ logo: string | null;
applicationUniversalIdentifier: string;
workspaceId: string;
}): Promise<string | null> {
- const logo = manifest.application.logo ?? manifest.application.logoUrl;
-
if (
!isDefined(logo) ||
logo.startsWith('http://') ||
@@ -856,7 +856,6 @@ export class ApplicationInstallService {
universalIdentifier,
name,
grantedCapabilities,
- logo,
workspaceId,
applicationRegistrationId,
sourceType,
@@ -865,7 +864,6 @@ export class ApplicationInstallService {
universalIdentifier: string;
name: string;
grantedCapabilities: ApplicationCapability[];
- logo: string | null;
workspaceId: string;
applicationRegistrationId: string;
sourceType: ApplicationRegistrationSourceType;
@@ -878,7 +876,6 @@ export class ApplicationInstallService {
universalIdentifier,
name,
grantedCapabilities,
- logo,
sourcePath: universalIdentifier,
sourceType,
applicationRegistrationId,