File - Migrate avatarUrl > avatarFile on person (data migration + logic) + Attachment data migration (#17752)

- Migration command
    - Check IS_FILES_FIELD_MIGRATED:false
    - Check or create avatarFile field
    - Fetch all people with avatarUrl
           - Move (Copy/move) file in storage
           - Create core.file record
           - Update person record
           
    - bonus : attachment migration  : fullPath > file (same logic)
   
- BE logic
    - Add avatarFile field on person

- FE logic 
   - Adapt logic to upload on/display avatarFile data

The whole imageIdentifier logic will be done later

packages/twenty-server/src/database/commands/upgrade-version-command/1-18/1-18-migrate-attachment-files.command.ts

@@ -0,0 +1,298 @@
+import { InjectDataSource, InjectRepository } from '@nestjs/typeorm';
+
+import { isNonEmptyString } from '@sniptt/guards';
+import { Command } from 'nest-commander';
+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
+import { FieldMetadataType, FileFolder } from 'twenty-shared/types';
+import {
+  extractFolderPathFilenameAndTypeOrThrow,
+  isDefined,
+} from 'twenty-shared/utils';
+import { DataSource, Equal, IsNull, Not, Or, Repository } from 'typeorm';
+import { v4 } from 'uuid';
+
+import { ActiveOrSuspendedWorkspacesMigrationCommandRunner } from 'src/database/commands/command-runners/active-or-suspended-workspaces-migration.command-runner';
+import { RunOnWorkspaceArgs } from 'src/database/commands/command-runners/workspaces-migration.command-runner';
+import { getFlatFieldsFromFlatObjectMetadata } from 'src/engine/api/graphql/workspace-schema-builder/utils/get-flat-fields-for-flat-object-metadata.util';
+import { ApplicationService } from 'src/engine/core-modules/application/services/application.service';
+import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
+import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
+import { FileStorageService } from 'src/engine/core-modules/file-storage/file-storage.service';
+import { FileEntity } from 'src/engine/core-modules/file/entities/file.entity';
+import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
+import { DataSourceService } from 'src/engine/metadata-modules/data-source/data-source.service';
+import { FieldMetadataService } from 'src/engine/metadata-modules/field-metadata/services/field-metadata.service';
+import { findFlatEntityByUniversalIdentifier } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-universal-identifier.util';
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+import { AttachmentWorkspaceEntity } from 'src/modules/attachment/standard-objects/attachment.workspace-entity';
+
+@Command({
+  name: 'upgrade:1-18:migrate-attachment-files',
+  description:
+    'Migrate attachment files to file field: copy files and create file records',
+})
+export class MigrateAttachmentFilesCommand extends ActiveOrSuspendedWorkspacesMigrationCommandRunner {
+  constructor(
+    @InjectRepository(WorkspaceEntity)
+    protected readonly workspaceRepository: Repository<WorkspaceEntity>,
+    protected readonly twentyORMGlobalManager: GlobalWorkspaceOrmManager,
+    protected readonly dataSourceService: DataSourceService,
+    private readonly featureFlagService: FeatureFlagService,
+    private readonly fileStorageService: FileStorageService,
+    private readonly workspaceCacheService: WorkspaceCacheService,
+    private readonly fieldMetadataService: FieldMetadataService,
+    private readonly applicationService: ApplicationService,
+    @InjectDataSource()
+    private readonly coreDataSource: DataSource,
+  ) {
+    super(workspaceRepository, twentyORMGlobalManager, dataSourceService);
+  }
+
+  override async runOnWorkspace({
+    workspaceId,
+    options,
+  }: RunOnWorkspaceArgs): Promise<void> {
+    const isDryRun = options.dryRun ?? false;
+
+    const isMigrated = await this.featureFlagService.isFeatureEnabled(
+      FeatureFlagKey.IS_FILES_FIELD_MIGRATED,
+      workspaceId,
+    );
+
+    if (isMigrated) {
+      this.logger.log(
+        `Attachment files migration already completed for workspace ${workspaceId}, skipping`,
+      );
+
+      return;
+    }
+
+    this.logger.log(
+      `${isDryRun ? '[DRY RUN] ' : ''}Starting attachment files migration for workspace ${workspaceId}`,
+    );
+
+    const { flatObjectMetadataMaps, flatFieldMetadataMaps } =
+      await this.workspaceCacheService.getOrRecompute(workspaceId, [
+        'flatObjectMetadataMaps',
+        'flatFieldMetadataMaps',
+      ]);
+
+    const attachmentObjectMetadata =
+      findFlatEntityByUniversalIdentifier<FlatObjectMetadata>({
+        flatEntityMaps: flatObjectMetadataMaps,
+        universalIdentifier: STANDARD_OBJECTS.attachment.universalIdentifier,
+      });
+
+    if (!isDefined(attachmentObjectMetadata)) {
+      this.logger.warn(
+        `Attachment object metadata not found for workspace ${workspaceId}, skipping`,
+      );
+
+      return;
+    }
+
+    const { twentyStandardFlatApplication } =
+      await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(
+        {
+          workspaceId,
+        },
+      );
+
+    let attachmentFileflatFieldMetadata = findFlatEntityByUniversalIdentifier({
+      flatEntityMaps: flatFieldMetadataMaps,
+      universalIdentifier:
+        STANDARD_OBJECTS.attachment.fields.file.universalIdentifier,
+    });
+
+    if (!isDefined(attachmentFileflatFieldMetadata)) {
+      this.logger.log(
+        `File field metadata not found for attachments in workspace ${workspaceId}, creating it`,
+      );
+
+      if (!isDryRun) {
+        const attachmentFieldMetadatas = getFlatFieldsFromFlatObjectMetadata(
+          attachmentObjectMetadata,
+          flatFieldMetadataMaps,
+        );
+
+        const existingFieldWithSameName = attachmentFieldMetadatas.find(
+          (fieldMetadata) => fieldMetadata.name === 'file',
+        );
+
+        if (isDefined(existingFieldWithSameName)) {
+          this.logger.log(
+            `Found existing field with name 'file' (id: ${existingFieldWithSameName.id}), renaming it to 'old-file'`,
+          );
+
+          try {
+            await this.fieldMetadataService.updateOneField({
+              updateFieldInput: {
+                id: existingFieldWithSameName.id,
+                name: 'oldFile',
+                label: 'Old File',
+              },
+              workspaceId,
+              ownerFlatApplication: twentyStandardFlatApplication,
+            });
+          } catch (error) {
+            this.logger.error(
+              `Failed to rename existing 'file' field to 'old-file' for workspace ${workspaceId}: ${error.message}`,
+            );
+            throw error;
+          }
+
+          this.logger.log(
+            `Renamed existing 'file' field to 'oldFile' for workspace ${workspaceId}`,
+          );
+        }
+
+        try {
+          attachmentFileflatFieldMetadata =
+            await this.fieldMetadataService.createOneField({
+              createFieldInput: {
+                objectMetadataId: attachmentObjectMetadata.id,
+                type: FieldMetadataType.FILES,
+                name: 'file',
+                label: 'File',
+                description: 'Attachment file',
+                icon: 'IconFileUpload',
+                isNullable: true,
+                isUIReadOnly: true,
+                isSystem: true,
+                settings: {
+                  maxNumberOfValues: 1,
+                },
+                universalIdentifier:
+                  STANDARD_OBJECTS.attachment.fields.file.universalIdentifier,
+              },
+              workspaceId,
+              ownerFlatApplication: twentyStandardFlatApplication,
+            });
+        } catch (error) {
+          this.logger.error(
+            `Failed to create file field metadata for attachments in workspace ${workspaceId}: ${error.message}`,
+          );
+          throw error;
+        }
+      }
+      this.logger.log(
+        `Created file field metadata for attachments in workspace ${workspaceId}`,
+      );
+    }
+
+    if (!isDefined(attachmentFileflatFieldMetadata)) {
+      this.logger.error(
+        `File field metadata not found for attachments in workspace ${workspaceId}`,
+      );
+
+      return;
+    }
+
+    const attachmentRepository =
+      await this.twentyORMGlobalManager.getRepository<AttachmentWorkspaceEntity>(
+        workspaceId,
+        'attachment',
+        { shouldBypassPermissionChecks: true },
+      );
+
+    const attachments = await attachmentRepository.find({
+      where: {
+        fullPath: Not(IsNull()),
+        file: Or(IsNull(), Equal([])),
+      },
+      select: ['id', 'name', 'fullPath'],
+    });
+
+    if (attachments.length === 0) {
+      this.logger.log(`No attachments to migrate for workspace ${workspaceId}`);
+
+      return;
+    }
+
+    this.logger.log(
+      `Found ${attachments.length} attachment(s) to migrate in workspace ${workspaceId}`,
+    );
+
+    const fileRepository = this.coreDataSource.getRepository(FileEntity);
+
+    for (const attachment of attachments) {
+      if (!isNonEmptyString(attachment.fullPath)) {
+        this.logger.warn(
+          `Skipping attachment ${attachment.id} - invalid fullPath`,
+        );
+
+        continue;
+      }
+
+      try {
+        const { type: fileExtension, filename } =
+          extractFolderPathFilenameAndTypeOrThrow(attachment.fullPath);
+
+        const fileId = v4();
+        const newFilename = `${fileId}${isNonEmptyString(fileExtension) ? `.${fileExtension}` : ''}`;
+        const newResourcePath = `${FileFolder.FilesField}/${attachmentFileflatFieldMetadata.universalIdentifier}/${newFilename}`;
+
+        if (!isDryRun) {
+          await this.fileStorageService.copyLegacy({
+            from: {
+              folderPath: `workspace-${workspaceId}`,
+              filename: attachment.fullPath,
+            },
+            to: {
+              folderPath: `${workspaceId}/${twentyStandardFlatApplication.universalIdentifier}`,
+              filename: newResourcePath,
+            },
+          });
+
+          const fileEntity = fileRepository.create({
+            id: fileId,
+            path: newResourcePath,
+            workspaceId,
+            applicationId: twentyStandardFlatApplication.id,
+            size: -1,
+            settings: {
+              isTemporaryFile: true,
+              toDelete: false,
+            },
+          });
+
+          await fileRepository.save(fileEntity);
+
+          await attachmentRepository.update(
+            { id: attachment.id },
+            {
+              file: [
+                {
+                  fileId: fileEntity.id,
+                  label: attachment.name || filename,
+                },
+              ],
+            },
+          );
+        }
+
+        this.logger.log(
+          `Migrated attachment ${attachment.id} (${attachment.name})`,
+        );
+      } catch (error) {
+        this.logger.error(
+          `Failed to migrate attachment ${attachment.id} in workspace ${workspaceId}: ${error.message}`,
+        );
+        throw error;
+      }
+    }
+
+    if (!isDryRun) {
+      await this.featureFlagService.enableFeatureFlags(
+        [FeatureFlagKey.IS_FILES_FIELD_MIGRATED],
+        workspaceId,
+      );
+    }
+
+    this.logger.log(
+      `${isDryRun ? '[DRY RUN] ' : ''}Completed attachment files migration for workspace ${workspaceId}`,
+    );
+  }
+}

packages/twenty-server/src/database/commands/upgrade-version-command/1-18/1-18-migrate-person-avatar-files.command.ts

@@ -0,0 +1,296 @@
+import { InjectDataSource, InjectRepository } from '@nestjs/typeorm';
+
+import { isNonEmptyString } from '@sniptt/guards';
+import { Command } from 'nest-commander';
+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
+import { FieldMetadataType, FileFolder } from 'twenty-shared/types';
+import {
+  assertIsDefinedOrThrow,
+  extractFolderPathFilenameAndTypeOrThrow,
+  isDefined,
+} from 'twenty-shared/utils';
+import { DataSource, Equal, ILike, IsNull, Or, Repository } from 'typeorm';
+import { v4 } from 'uuid';
+
+import { ActiveOrSuspendedWorkspacesMigrationCommandRunner } from 'src/database/commands/command-runners/active-or-suspended-workspaces-migration.command-runner';
+import { RunOnWorkspaceArgs } from 'src/database/commands/command-runners/workspaces-migration.command-runner';
+import { getFlatFieldsFromFlatObjectMetadata } from 'src/engine/api/graphql/workspace-schema-builder/utils/get-flat-fields-for-flat-object-metadata.util';
+import { ApplicationService } from 'src/engine/core-modules/application/services/application.service';
+import { FeatureFlagKey } from 'src/engine/core-modules/feature-flag/enums/feature-flag-key.enum';
+import { FeatureFlagService } from 'src/engine/core-modules/feature-flag/services/feature-flag.service';
+import { FileStorageService } from 'src/engine/core-modules/file-storage/file-storage.service';
+import { FileEntity } from 'src/engine/core-modules/file/entities/file.entity';
+import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
+import { DataSourceService } from 'src/engine/metadata-modules/data-source/data-source.service';
+import { FieldMetadataService } from 'src/engine/metadata-modules/field-metadata/services/field-metadata.service';
+import { findFlatEntityByUniversalIdentifier } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-universal-identifier.util';
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+import { PersonWorkspaceEntity } from 'src/modules/person/standard-objects/person.workspace-entity';
+
+@Command({
+  name: 'upgrade:1-18:migrate-person-avatar-files',
+  description:
+    'Migrate person avatarUrl files to file field: copy files and create file records',
+})
+export class MigratePersonAvatarFilesCommand extends ActiveOrSuspendedWorkspacesMigrationCommandRunner {
+  constructor(
+    @InjectRepository(WorkspaceEntity)
+    protected readonly workspaceRepository: Repository<WorkspaceEntity>,
+    protected readonly twentyORMGlobalManager: GlobalWorkspaceOrmManager,
+    protected readonly dataSourceService: DataSourceService,
+    private readonly featureFlagService: FeatureFlagService,
+    private readonly fileStorageService: FileStorageService,
+    private readonly workspaceCacheService: WorkspaceCacheService,
+    private readonly fieldMetadataService: FieldMetadataService,
+    private readonly applicationService: ApplicationService,
+    @InjectDataSource()
+    private readonly coreDataSource: DataSource,
+  ) {
+    super(workspaceRepository, twentyORMGlobalManager, dataSourceService);
+  }
+
+  override async runOnWorkspace({
+    workspaceId,
+    options,
+  }: RunOnWorkspaceArgs): Promise<void> {
+    const isDryRun = options.dryRun ?? false;
+
+    const isMigrated = await this.featureFlagService.isFeatureEnabled(
+      FeatureFlagKey.IS_FILES_FIELD_MIGRATED,
+      workspaceId,
+    );
+
+    if (isMigrated) {
+      this.logger.log(
+        `Person avatar files migration already completed for workspace ${workspaceId}, skipping`,
+      );
+
+      return;
+    }
+
+    this.logger.log(
+      `${
+        isDryRun ? '[DRY RUN] ' : ''
+      }Starting person avatar files migration for workspace ${workspaceId}`,
+    );
+
+    const { flatObjectMetadataMaps, flatFieldMetadataMaps } =
+      await this.workspaceCacheService.getOrRecompute(workspaceId, [
+        'flatObjectMetadataMaps',
+        'flatFieldMetadataMaps',
+      ]);
+
+    const personObjectMetadata =
+      findFlatEntityByUniversalIdentifier<FlatObjectMetadata>({
+        flatEntityMaps: flatObjectMetadataMaps,
+        universalIdentifier: STANDARD_OBJECTS.person.universalIdentifier,
+      });
+
+    if (!isDefined(personObjectMetadata)) {
+      this.logger.warn(
+        `Person object metadata not found for workspace ${workspaceId}, skipping`,
+      );
+
+      return;
+    }
+
+    const { twentyStandardFlatApplication } =
+      await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(
+        {
+          workspaceId,
+        },
+      );
+
+    if (!isDefined(twentyStandardFlatApplication)) {
+      this.logger.error(
+        `Twenty standard application not found for workspace ${workspaceId}`,
+      );
+
+      return;
+    }
+
+    let avatarFileFieldMetadata = findFlatEntityByUniversalIdentifier({
+      flatEntityMaps: flatFieldMetadataMaps,
+      universalIdentifier:
+        STANDARD_OBJECTS.person.fields.avatarFile.universalIdentifier,
+    });
+
+    if (!isDefined(avatarFileFieldMetadata)) {
+      this.logger.log(
+        `Avatar file field metadata not found for workspace ${workspaceId}, creating it`,
+      );
+
+      if (!isDryRun) {
+        const personFieldMetadatas = getFlatFieldsFromFlatObjectMetadata(
+          personObjectMetadata,
+          flatFieldMetadataMaps,
+        );
+
+        const existingFieldWithSameName = personFieldMetadatas.find(
+          (fieldMetadata) => fieldMetadata.name === 'avatarFile',
+        );
+
+        if (isDefined(existingFieldWithSameName)) {
+          this.logger.log(
+            `Found existing field with name 'avatarFile' (id: ${existingFieldWithSameName.id}), renaming it to 'old-avatarFile'`,
+          );
+
+          try {
+            await this.fieldMetadataService.updateOneField({
+              updateFieldInput: {
+                id: existingFieldWithSameName.id,
+                name: 'oldAvatarFile',
+                label: 'Old Avatar File',
+              },
+              workspaceId,
+              ownerFlatApplication: twentyStandardFlatApplication,
+            });
+          } catch (error) {
+            this.logger.error(
+              `Failed to rename existing 'avatarFile' field to 'old-avatarFile' for workspace ${workspaceId}: ${error.message}`,
+            );
+            throw error;
+          }
+
+          this.logger.log(
+            `Renamed existing 'avatarFile' field to 'oldAvatarFile' for workspace ${workspaceId}`,
+          );
+        }
+
+        try {
+          avatarFileFieldMetadata =
+            await this.fieldMetadataService.createOneField({
+              createFieldInput: {
+                objectMetadataId: personObjectMetadata.id,
+                type: FieldMetadataType.FILES,
+                name: 'avatarFile',
+                label: 'Avatar File',
+                description: "Contact's avatar file",
+                icon: 'IconFileUpload',
+                isSystem: true,
+                isNullable: true,
+                settings: {
+                  maxNumberOfValues: 1,
+                },
+                universalIdentifier:
+                  STANDARD_OBJECTS.person.fields.avatarFile.universalIdentifier,
+              },
+              workspaceId,
+              ownerFlatApplication: twentyStandardFlatApplication,
+            });
+        } catch (error) {
+          this.logger.error(
+            `Failed to create avatarFile field metadata for workspace ${workspaceId}: ${error.message}`,
+          );
+          throw error;
+        }
+      }
+      this.logger.log(
+        `Created avatarFile field metadata for workspace ${workspaceId}`,
+      );
+    }
+
+    if (!isDefined(avatarFileFieldMetadata)) {
+      this.logger.error(
+        `Avatar file field metadata not found for workspace ${workspaceId}`,
+      );
+
+      return;
+    }
+
+    const personRepository =
+      await this.twentyORMGlobalManager.getRepository<PersonWorkspaceEntity>(
+        workspaceId,
+        'person',
+        { shouldBypassPermissionChecks: true },
+      );
+
+    const personsWithAvatars = await personRepository.find({
+      where: {
+        avatarUrl: ILike(`%${FileFolder.PersonPicture}%`),
+        avatarFile: Or(IsNull(), Equal([])),
+      },
+      select: ['id', 'avatarUrl'],
+    });
+
+    if (personsWithAvatars.length === 0) {
+      this.logger.log(
+        `No persons with avatarUrl found in workspace ${workspaceId}`,
+      );
+
+      return;
+    }
+
+    this.logger.log(
+      `Found ${personsWithAvatars.length} person(s) with avatarUrl containing 'people' folder in workspace ${workspaceId}`,
+    );
+
+    const fileRepository = this.coreDataSource.getRepository(FileEntity);
+
+    for (const person of personsWithAvatars) {
+      assertIsDefinedOrThrow(person.avatarUrl);
+
+      try {
+        const { type: fileExtension } = extractFolderPathFilenameAndTypeOrThrow(
+          person.avatarUrl,
+        );
+
+        const fileId = v4();
+        const newFileName = `${fileId}${isNonEmptyString(fileExtension) ? `.${fileExtension}` : ''}`;
+        const newResourcePath = `${FileFolder.FilesField}/${avatarFileFieldMetadata.universalIdentifier}/${newFileName}`;
+
+        if (!isDryRun) {
+          await this.fileStorageService.copyLegacy({
+            from: {
+              folderPath: `workspace-${workspaceId}`,
+              filename: person.avatarUrl,
+            },
+            to: {
+              folderPath: `${workspaceId}/${twentyStandardFlatApplication.universalIdentifier}`,
+              filename: newResourcePath,
+            },
+          });
+
+          const fileEntity = fileRepository.create({
+            id: fileId,
+            path: newResourcePath,
+            workspaceId,
+            applicationId: twentyStandardFlatApplication.id,
+            size: -1,
+            settings: {
+              isTemporaryFile: true,
+              toDelete: false,
+            },
+          });
+
+          await fileRepository.save(fileEntity);
+
+          await personRepository.update(
+            { id: person.id },
+            {
+              avatarFile: [
+                {
+                  fileId: fileEntity.id,
+                  label: newFileName,
+                },
+              ],
+            },
+          );
+        }
+
+        this.logger.log(`Migrated avatar for person ${person.id}`);
+      } catch (error) {
+        this.logger.error(
+          `Failed to migrate avatar for person ${person.id} in workspace ${workspaceId}: ${error.message}`,
+        );
+        throw error;
+      }
+    }
+
+    this.logger.log(
+      `${isDryRun ? '[DRY RUN] ' : ''}Completed person avatar files migration for workspace ${workspaceId}`,
+    );
+  }
+}

packages/twenty-server/src/database/commands/upgrade-version-command/1-18/1-18-upgrade-version-command.module.ts

@@ -0,0 +1,37 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { MigrateAttachmentFilesCommand } from 'src/database/commands/upgrade-version-command/1-18/1-18-migrate-attachment-files.command';
+import { MigratePersonAvatarFilesCommand } from 'src/database/commands/upgrade-version-command/1-18/1-18-migrate-person-avatar-files.command';
+import { ApplicationModule } from 'src/engine/core-modules/application/application.module';
+import { FeatureFlagEntity } from 'src/engine/core-modules/feature-flag/feature-flag.entity';
+import { FeatureFlagModule } from 'src/engine/core-modules/feature-flag/feature-flag.module';
+import { FileStorageModule } from 'src/engine/core-modules/file-storage/file-storage.module';
+import { FileEntity } from 'src/engine/core-modules/file/entities/file.entity';
+import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
+import { DataSourceModule } from 'src/engine/metadata-modules/data-source/data-source.module';
+import { FieldMetadataModule } from 'src/engine/metadata-modules/field-metadata/field-metadata.module';
+import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';
+import { AttachmentWorkspaceEntity } from 'src/modules/attachment/standard-objects/attachment.workspace-entity';
+import { PersonWorkspaceEntity } from 'src/modules/person/standard-objects/person.workspace-entity';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([
+      WorkspaceEntity,
+      FeatureFlagEntity,
+      PersonWorkspaceEntity,
+      FileEntity,
+      AttachmentWorkspaceEntity,
+    ]),
+    DataSourceModule,
+    FeatureFlagModule,
+    FileStorageModule.forRoot(),
+    WorkspaceCacheModule,
+    FieldMetadataModule,
+    ApplicationModule,
+  ],
+  providers: [MigratePersonAvatarFilesCommand, MigrateAttachmentFilesCommand],
+  exports: [MigratePersonAvatarFilesCommand, MigrateAttachmentFilesCommand],
+})
+export class V1_18_UpgradeVersionCommandModule {}

packages/twenty-server/src/database/commands/upgrade-version-command/upgrade-version-command.module.ts

@@ -2,6 +2,7 @@ import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 
 import { V1_17_UpgradeVersionCommandModule } from 'src/database/commands/upgrade-version-command/1-17/1-17-upgrade-version-command.module';
+import { V1_18_UpgradeVersionCommandModule } from 'src/database/commands/upgrade-version-command/1-18/1-18-upgrade-version-command.module';
 import { UpgradeCommand } from 'src/database/commands/upgrade-version-command/upgrade.command';
 import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
 import { DataSourceModule } from 'src/engine/metadata-modules/data-source/data-source.module';
@@ -10,6 +11,7 @@ import { DataSourceModule } from 'src/engine/metadata-modules/data-source/data-s
   imports: [
     TypeOrmModule.forFeature([WorkspaceEntity]),
     V1_17_UpgradeVersionCommandModule,
+    V1_18_UpgradeVersionCommandModule,
     DataSourceModule,
   ],
   providers: [UpgradeCommand],

packages/twenty-server/src/database/commands/upgrade-version-command/upgrade.command.ts

@@ -19,6 +19,7 @@ import { MigrateFavoritesToNavigationMenuItemsCommand } from 'src/database/comma
 import { MigrateNoteTargetToMorphRelationsCommand } from 'src/database/commands/upgrade-version-command/1-17/1-17-migrate-note-target-to-morph-relations.command';
 import { MigrateTaskTargetToMorphRelationsCommand } from 'src/database/commands/upgrade-version-command/1-17/1-17-migrate-task-target-to-morph-relations.command';
 import { MigrateWorkflowCodeStepsCommand } from 'src/database/commands/upgrade-version-command/1-17/1-17-migrate-workflow-code-steps.command';
+import { MigratePersonAvatarFilesCommand } from 'src/database/commands/upgrade-version-command/1-18/1-18-migrate-person-avatar-files.command';
 import { TwentyConfigService } from 'src/engine/core-modules/twenty-config/twenty-config.service';
 import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
 import { DataSourceService } from 'src/engine/metadata-modules/data-source/data-source.service';
@@ -49,6 +50,9 @@ export class UpgradeCommand extends UpgradeCommandRunner {
     protected readonly makeWebhookUniversalIdentifierAndApplicationIdNotNullableMigrationCommand: MakeWebhookUniversalIdentifierAndApplicationIdNotNullableMigrationCommand,
     protected readonly migrateWorkflowCodeStepsCommand: MigrateWorkflowCodeStepsCommand,
     protected readonly fixMorphRelationFieldNamesCommand: FixMorphRelationFieldNamesCommand,
+
+    // 1.18 Commands
+    protected readonly migratePersonAvatarFilesCommand: MigratePersonAvatarFilesCommand,
   ) {
     super(
       workspaceRepository,
@@ -74,9 +78,14 @@ export class UpgradeCommand extends UpgradeCommandRunner {
       this.fixMorphRelationFieldNamesCommand,
     ];
 
+    const commands_1180: VersionCommands = [
+      this.migratePersonAvatarFilesCommand,
+    ];
+
     this.allCommands = {
       '1.16.0': commands_1160,
       '1.17.0': commands_1170,
+      '1.18.0': commands_1180,
     };
   }
 

packages/twenty-server/src/database/typeorm/core/migrations/common/1770814914548-addMimeTypeToFileTable.ts

@@ -0,0 +1,15 @@
+import { type MigrationInterface, type QueryRunner } from 'typeorm';
+
+export class AddMimeTypeToFileTable1770814914548 implements MigrationInterface {
+  name = 'AddMimeTypeToFileTable1770814914548';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "core"."file" ADD "mimeType" character varying NOT NULL DEFAULT 'application/octet-stream'`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "core"."file" DROP COLUMN "mimeType"`);
+  }
+}