@solidxai/core 0.1.12-beta.2 → 0.1.12-beta.4

package/src/services/media.service.ts

@@ -1,33 +1,37 @@
-import { forwardRef, Inject, Injectable, NotFoundException } from '@nestjs/common';
+import { forwardRef, Inject, Injectable, Logger, NotFoundException } from '@nestjs/common';
 import { ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
 import { EntityManager, In } from 'typeorm';
 import * as path from 'path';
-import { DEFAULT_MEDIA_FILE_STORAGE_DIR } from "src/services/settings/default-settings-provider.service";
-import type { SolidCoreSetting } from "src/services/settings/default-settings-provider.service";
+import { Readable } from 'stream';
 
 import { ConfigService } from '@nestjs/config';
 import { CRUDService } from 'src/services/crud.service';
 import { DiskFileService, S3FileService } from 'src/services/file';
+import { MediaDownloadUrlService } from 'src/services/media-download-url.service';
 
 
 import { ERROR_MESSAGES } from 'src/constants/error-messages';
 import { BasicFilterDto } from 'src/dtos/basic-filters.dto';
 import { MediaStorageProviderType } from 'src/dtos/create-media-storage-provider-metadata.dto';
 import { Media } from 'src/entities/media.entity';
+import { MediaStorageProviderMetadata } from 'src/entities/media-storage-provider-metadata.entity';
 import { FieldMetadataRepository } from 'src/repository/field-metadata.repository';
 import { MediaStorageProviderMetadataRepository } from 'src/repository/media-storage-provider-metadata.repository';
 import { MediaRepository } from 'src/repository/media.repository';
 import { ModelMetadataRepository } from 'src/repository/model-metadata.repository';
+import { buildDiskMediaPath, buildStoredMediaFileName, getEffectiveS3Region, resolveStoredMediaIsPublic, } from 'src/services/media-storage.utils';
 import { getMediaStorageProvider } from "./mediaStorageProviders";
 
-
 @Injectable()
 export class MediaService extends CRUDService<Media> {
+  private readonly logger = new Logger(MediaService.name);
+
   constructor(
     readonly configService: ConfigService,
     readonly diskFileService: DiskFileService,
     readonly s3FileService: S3FileService,
+    private readonly mediaDownloadUrlService: MediaDownloadUrlService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
     // @InjectRepository(Media, 'default')
@@ -51,75 +55,73 @@ export class MediaService extends CRUDService<Media> {
   async find(basicFilterDto: BasicFilterDto, solidRequestContext: any = {}) {
     const data = await super.find(basicFilterDto, solidRequestContext);
     if (data.records) {
-
-      for (const media of data.records) {
-        const mediaStorageProvider = media.mediaStorageProviderMetadata;
-
-        if (mediaStorageProvider?.type === MediaStorageProviderType.Filesystem) {
-          media.relativeUri = await this.diskFileService.getUrl(this.getFullFilePathForDisk(media.relativeUri));
-        } else if (mediaStorageProvider?.type === MediaStorageProviderType.AwsS3) {
-          media.relativeUri = await this.s3FileService.getUrl(`${mediaStorageProvider.bucketName}:${media.relativeUri}`, { region: mediaStorageProvider.region });
-        }
-      }
+      await this.decorateMediaRecords(data.records);
     }
     if (data.groupRecords) {
-
       for (const group of data.groupRecords) {
-        for (const media of group.groupData.records) {
-          const mediaStorageProvider = media.mediaStorageProviderMetadata;
-
-          if (mediaStorageProvider?.type === MediaStorageProviderType.Filesystem) {
-            media.relativeUri = await this.diskFileService.getUrl(this.getFullFilePathForDisk(media.relativeUri));
-          }
-          else if (mediaStorageProvider?.type === MediaStorageProviderType.AwsS3) {
-            media.relativeUri = await this.s3FileService.getUrl(`${mediaStorageProvider.bucketName}:${media.relativeUri}`, { region: mediaStorageProvider.region });
-          }
-        }
+        await this.decorateMediaRecords(group.groupData.records);
       }
     }
     return data
   }
 
-  async upload(createDto: any, files: Array<Express.Multer.File>) {
+  async findOne(id: number, query: any = {}, solidRequestContext: any = {}) {
+    const media = await super.findOne(id, query, solidRequestContext);
+    if (media) {
+      await this.decorateMediaRecord(media);
+    }
+    return media;
+  }
 
-    if (!files) {
+  async upload(createDto: any, files: Array<Express.Multer.File>, _solidRequestContext: any = {}) {
+
+    if (!files || files.length === 0) {
       throw new NotFoundException(ERROR_MESSAGES.FILE_NOT_FOUND);
 
     }
-    const savedMedias = [];
-    for (let i = 0; i < files.length; i++) {
 
-      createDto['fieldMetadata'] = await this.fieldMetadataRepo.findOne({
-        where: {
-          id: createDto['fieldMetadataId']
-        },
-      });
-      createDto['modelMetadata'] = await this.modelMetadataRepo.findOne({
-        where: {
-          id: createDto['modelMetadataId']
-        },
-      });
-      createDto['mediaStorageProviderMetadata'] = await this.mediaStorageProviderMetadataRepo.findOne({
-        where: {
-          id: createDto['mediaStorageProviderMetadataId']
-        },
-      });
+    createDto['fieldMetadata'] = await this.fieldMetadataRepo.findOne({
+      where: {
+        id: createDto['fieldMetadataId']
+      },
+      relations: ['mediaStorageProvider', 'model'],
+    });
+    createDto['modelMetadata'] = await this.modelMetadataRepo.findOne({
+      where: {
+        id: createDto['modelMetadataId']
+      },
+    });
+    createDto['mediaStorageProviderMetadata'] = await this.mediaStorageProviderMetadataRepo.findOne({
+      where: {
+        id: createDto['mediaStorageProviderMetadataId']
+      },
+    });
+    createDto['mediaStorageProviderMetadata'] = createDto['mediaStorageProviderMetadata'] || createDto['fieldMetadata']?.mediaStorageProvider;
+    createDto['modelMetadata'] = createDto['modelMetadata'] || createDto['fieldMetadata']?.model;
 
+    if (!createDto['mediaStorageProviderMetadata']) {
+      throw new NotFoundException('Media storage provider metadata not found');
+    }
+
+    const savedMedias = [];
+    for (let i = 0; i < files.length; i++) {
       const file = files[i];
+      const storageProvider = createDto.mediaStorageProviderMetadata as MediaStorageProviderMetadata;
+      const fileName = buildStoredMediaFileName(file);
 
-      switch (createDto.mediaStorageProviderMetadata.type) {
+      switch (storageProvider.type) {
         case MediaStorageProviderType.Filesystem:
-          const fileStoragePath = this.getFullFilePathForDisk(this.getFileName(file));
+          const fileStoragePath = buildDiskMediaPath(fileName, this.settingService, storageProvider);
           await this.diskFileService.copy(file.path, fileStoragePath);
-          createDto['relativeUri'] = this.getFileName(file);
+          createDto['relativeUri'] = fileName;
           break;
         case MediaStorageProviderType.AwsS3:
-          const fileName = this.getFileName(file);
-          const bucketName = createDto.mediaStorageProviderMetadata.bucketName;
+          const bucketName = storageProvider.bucketName;
+          const region = getEffectiveS3Region(this.configService, storageProvider.region);
 
           // Read file from disk and upload to S3
           const fileData = await this.diskFileService.read(file.path);
-          await this.s3FileService.write(`${bucketName}:${fileName}`, fileData, { contentType: file.mimetype });
+          await this.s3FileService.write(`${bucketName}:${fileName}`, fileData, { contentType: file.mimetype, region });
 
           createDto['relativeUri'] = fileName;
           break;
@@ -129,8 +131,10 @@ export class MediaService extends CRUDService<Media> {
       // Delete temp file from disk
       await this.diskFileService.delete(file.path);
 
-      const media = this.repo.create(createDto);
+      createDto['isPublic'] = resolveStoredMediaIsPublic(createDto['isPublic'], storageProvider);
+      const media = this.repo.create(createDto as Partial<Media>) as Media;
       const savedMedia = await this.repo.save(media);
+      savedMedia.isPublic = resolveStoredMediaIsPublic(savedMedia.isPublic, storageProvider);
       savedMedias.push(savedMedia)
     }
     return savedMedias
@@ -157,17 +161,143 @@ export class MediaService extends CRUDService<Media> {
     return this.repo.remove(media);
   }
 
-  private getFullFilePathForDisk(fileName: string): string {
-    const base = this.settingService.getConfigValue<SolidCoreSetting>("fileStorageDir")
-      || DEFAULT_MEDIA_FILE_STORAGE_DIR;
-    if (path.isAbsolute(fileName) || fileName.startsWith(`${base}/`)) {
-      return fileName;
+  async fileDownloadStream(media: Media): Promise<{ stream: Readable | null, fileName: string, mimeType: string, redirectUrl?: string }> {
+    const loadedMedia = await this.repo.findOne({
+      where: { id: media.id },
+      relations: ['mediaStorageProviderMetadata'],
+    });
+
+    if (!loadedMedia || !loadedMedia.mediaStorageProviderMetadata) {
+      throw new NotFoundException(`Media with id ${media.id} not found`);
+    }
+
+    const fileName = loadedMedia.originalFileName || path.basename(loadedMedia.relativeUri || `${loadedMedia.id}`);
+    const mimeType = loadedMedia.mimeType || 'application/octet-stream';
+
+    switch (loadedMedia.mediaStorageProviderMetadata.type as MediaStorageProviderType) {
+      case MediaStorageProviderType.Filesystem:
+        return {
+          stream: await this.diskFileService.readStream(
+            buildDiskMediaPath(loadedMedia.relativeUri, this.settingService, loadedMedia.mediaStorageProviderMetadata),
+          ),
+          fileName,
+          mimeType,
+        };
+      default:
+        throw new Error(`Unsupported media storage provider type ${loadedMedia.mediaStorageProviderMetadata.type}`);
     }
-    return `${base}/${fileName}`;
   }
 
-  private getFileName(file: Express.Multer.File): string {
-    return `${file.filename}-${file.originalname}`;
+  async delete(id: number, solidRequestContext: any = {}) {
+    const media = await this.repo.findOne({
+      where: { id },
+      relations: ['mediaStorageProviderMetadata'],
+    });
+
+    const result = await super.delete(id, solidRequestContext);
+
+    if (media) {
+      await this.deletePhysicalFile(media);
+    }
+
+    return result;
   }
 
+  async deleteMany(ids: number[], solidRequestContext: any = {}) {
+    const mediaRecords = await this.repo.find({
+      where: {
+        id: In(ids),
+      },
+      relations: ['mediaStorageProviderMetadata'],
+    });
+
+    const result = await super.deleteMany(ids, solidRequestContext);
+
+    for (const media of mediaRecords) {
+      await this.deletePhysicalFile(media);
+    }
+
+    return result;
+  }
+
+  private async decorateMediaRecords(medias: Media[]): Promise<void> {
+    for (const media of medias) {
+      await this.decorateMediaRecord(media);
+    }
+  }
+
+  private async decorateMediaRecord(media: Media): Promise<void> {
+    const mediaStorageProvider = await this.resolveMediaStorageProvider(media);
+    media.isPublic = resolveStoredMediaIsPublic(media.isPublic, mediaStorageProvider);
+    media.relativeUri = await this.resolveMediaUrl(media, mediaStorageProvider);
+  }
+
+  private async resolveMediaUrl(media: Media, mediaStorageProvider?: MediaStorageProviderMetadata): Promise<string> {
+    const resolvedMediaStorageProvider = mediaStorageProvider || await this.resolveMediaStorageProvider(media);
+    const isPublic = resolveStoredMediaIsPublic(media.isPublic, resolvedMediaStorageProvider);
+
+    if (isPublic === false) {
+      return this.mediaDownloadUrlService.resolveDownloadUrl(media.id, media.relativeUri, resolvedMediaStorageProvider);
+    }
+
+    if (resolvedMediaStorageProvider?.type === MediaStorageProviderType.Filesystem) {
+      return this.diskFileService.getUrl(buildDiskMediaPath(media.relativeUri, this.settingService, resolvedMediaStorageProvider));
+    }
+
+    if (resolvedMediaStorageProvider?.type === MediaStorageProviderType.AwsS3) {
+      return this.s3FileService.getUrl(
+        `${resolvedMediaStorageProvider.bucketName}:${media.relativeUri}`,
+        { region: getEffectiveS3Region(this.configService, resolvedMediaStorageProvider.region), expiresIn: 0 },
+      );
+    }
+
+    return media.relativeUri;
+  }
+
+  private async deletePhysicalFile(media: Media): Promise<void> {
+    if (!media?.relativeUri) {
+      return;
+    }
+
+    try {
+      const mediaStorageProvider = await this.resolveMediaStorageProvider(media);
+      if (!mediaStorageProvider) {
+        return;
+      }
+
+      switch (mediaStorageProvider.type as MediaStorageProviderType) {
+        case MediaStorageProviderType.Filesystem:
+          await this.diskFileService.delete(buildDiskMediaPath(media.relativeUri, this.settingService, mediaStorageProvider));
+          return;
+        case MediaStorageProviderType.AwsS3:
+          await this.s3FileService.delete(
+            `${mediaStorageProvider.bucketName}:${media.relativeUri}`,
+            { region: getEffectiveS3Region(this.configService, mediaStorageProvider.region) },
+          );
+          return;
+        default:
+          this.logger.warn(`Skipping physical delete for unsupported media storage provider type ${mediaStorageProvider.type}`);
+      }
+    } catch (error: any) {
+      const message = error?.message ?? String(error);
+      this.logger.warn(`Failed to delete physical media file for media id ${media.id}: ${message}`);
+    }
+  }
+
+  private async resolveMediaStorageProvider(media: Media): Promise<MediaStorageProviderMetadata | undefined> {
+    if (media.mediaStorageProviderMetadata) {
+      return media.mediaStorageProviderMetadata;
+    }
+
+    if (!media.id) {
+      return undefined;
+    }
+
+    const loadedMedia = await this.repo.findOne({
+      where: { id: media.id },
+      relations: ['mediaStorageProviderMetadata'],
+    });
+
+    return loadedMedia?.mediaStorageProviderMetadata;
+  }
 }

package/src/services/mediaStorageProviders/file-s3-storage-provider.ts

@@ -9,6 +9,13 @@ import { MediaStorageProvider } from "src/interfaces";
 import { DiskFileService, S3FileService } from "src/services/file";
 import { Readable } from "stream";
 import { MediaRepository } from "src/repository/media.repository";
+import { MediaDownloadUrlService } from "src/services/media-download-url.service";
+import {
+    buildMediaRecordCreateInput,
+    buildStoredMediaFileName,
+    getEffectiveS3Region,
+    resolveStoredMediaIsPublic,
+} from "src/services/media-storage.utils";
 
 @Injectable()
 export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
@@ -19,18 +26,14 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
         readonly diskFileService: DiskFileService,
         readonly s3FileService: S3FileService,
         readonly mediaRepository: MediaRepository,
+        private readonly mediaDownloadUrlService: MediaDownloadUrlService,
     ) { }
 
     async storeStreams(streamPairs: [Readable, string][], entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]> {
-        const isSupportedEntity = entity instanceof CommonEntity
-            || entity instanceof LegacyCommonEntityWithExistingId
-            || entity instanceof LegacyCommonEntityWithGeneratedId;
-        if (!isSupportedEntity) {
-            throw new Error("Entity must be an instance of CommonEntity, LegacyCommonEntityWithExistingId or LegacyCommonEntityWithGeneratedId");
-        }
+        const entityId = this.getSupportedEntityId(entity);
         const result: Media[] = [];
         const storageProvider = mediaFieldMetadata.mediaStorageProvider;
-        const region = this.getEffectiveRegion(storageProvider.region);
+        const region = getEffectiveS3Region(this.configService, storageProvider.region);
 
         for (const [stream, fileName] of streamPairs) {
             const bucketName = storageProvider.bucketName;
@@ -45,15 +48,13 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
 
             await this.s3FileService.write(`${bucketName}:${fileName}`, fileData, { region });
 
-            const mediaEntity = await this.mediaRepository.createMedia({
-                // @ts-ignore
-                entityId: entity.id,
-                modelMetadataId: mediaFieldMetadata.model.id,
-                relativeUri: fileName,
-                fileSize,
-                mediaStorageProviderMetadataId: mediaFieldMetadata.mediaStorageProvider.id,
-                fieldMetadataId: mediaFieldMetadata.id
-            }) as unknown as Media;
+            const mediaEntity = await this.mediaRepository.createMedia(
+                buildMediaRecordCreateInput(entityId, mediaFieldMetadata, storageProvider, {
+                    relativeUri: fileName,
+                    fileSize,
+                })
+            ) as unknown as Media;
+            mediaEntity.isPublic = resolveStoredMediaIsPublic(mediaEntity.isPublic, storageProvider);
             result.push(mediaEntity);
             this.logger.debug(`Stored media with`, mediaEntity);
         }
@@ -61,29 +62,23 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
     }
 
     async retrieve(entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]> {
-        const isSupportedEntity = entity instanceof CommonEntity
-            || entity instanceof LegacyCommonEntityWithExistingId
-            || entity instanceof LegacyCommonEntityWithGeneratedId;
-        if (!isSupportedEntity) {
-            throw new Error("Entity must be an instance of CommonEntity, LegacyCommonEntityWithExistingId or LegacyCommonEntityWithGeneratedId"); // FIXME This needs to be handled through generics. e.g T extends CommonEntity
-        }
+        const entityId = this.getSupportedEntityId(entity);
         // @ts-ignore
-        const media = await this.mediaRepository.findByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id, ['mediaStorageProviderMetadata']);
+        const media = await this.mediaRepository.findByEntityIdAndFieldIdAndModelMetadataId(entityId, mediaFieldMetadata.id, mediaFieldMetadata.model.id, ['mediaStorageProviderMetadata']);
 
         // TODO: Check if the mediaStorageProvider (s3 in this case) is configured with a public bucket or not.
         // If private bucket then we need to return a "signed-url", the timeout for the signed url can be configured in the media storage provider entity and modified using the CRUD interface.
         // Add the full URL to the media
         for (const m of media) {
             const storageMeta = m.mediaStorageProviderMetadata;
-            const region = this.getEffectiveRegion(storageMeta.region);
-            if (storageMeta.isPublic === false) {
-                // Generate signed URL
-                const expiryInSeconds = (storageMeta.signedUrlExpiry ?? 60) * 60;
-                m['_full_url'] = await this.s3FileService.getUrl(`${storageMeta?.bucketName}:${m.relativeUri}`, { expiresIn: expiryInSeconds, region });
-            } else {
-                // Public S3 or local filesystem: use normal URL
-                m['_full_url'] = this.getFullFilePath(m);
-            }
+            const isPublic = resolveStoredMediaIsPublic(m.isPublic, storageMeta);
+            m.isPublic = isPublic;
+            m['_full_url'] = isPublic === false
+                ? await this.mediaDownloadUrlService.resolveDownloadUrl(m.id, m.relativeUri, storageMeta)
+                : await this.s3FileService.getUrl(
+                    `${storageMeta.bucketName}:${m.relativeUri}`,
+                    { region: getEffectiveS3Region(this.configService, storageMeta.region), expiresIn: 0 },
+                );
         }
 
         return media;
@@ -94,18 +89,13 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
     }
 
     async store(files: Express.Multer.File[], entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]> {
-        const isSupportedEntity = entity instanceof CommonEntity
-            || entity instanceof LegacyCommonEntityWithExistingId
-            || entity instanceof LegacyCommonEntityWithGeneratedId;
-        if (!isSupportedEntity) {
-            throw new Error("Entity must be an instance of CommonEntity, LegacyCommonEntityWithExistingId or LegacyCommonEntityWithGeneratedId"); // FIXME This needs to be handled through generics. e.g T extends CommonEntity
-        }
+        const entityId = this.getSupportedEntityId(entity);
         const result: Media[] = [];
         const storageProvider = mediaFieldMetadata.mediaStorageProvider;
-        const region = this.getEffectiveRegion(storageProvider.region);
+        const region = getEffectiveS3Region(this.configService, storageProvider.region);
 
         for (const file of files) {
-            const fileName = this.getFileName(file);
+            const fileName = buildStoredMediaFileName(file);
             const bucketName = storageProvider.bucketName;
 
             // Read file from disk and upload to S3
@@ -118,17 +108,15 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
             const awsFileUrl = fileName;
 
             // Create an entry in the media table
-            const mediaEntity = await this.mediaRepository.createMedia({
-                // @ts-ignore
-                entityId: entity.id,
-                modelMetadataId: mediaFieldMetadata.model.id,
-                relativeUri: awsFileUrl,
-                mimeType: file.mimetype,
-                fileSize: file.size,
-                originalFileName: file.originalname,
-                mediaStorageProviderMetadataId: mediaFieldMetadata.mediaStorageProvider.id,
-                fieldMetadataId: mediaFieldMetadata.id
-            }) as unknown as Media;
+            const mediaEntity = await this.mediaRepository.createMedia(
+                buildMediaRecordCreateInput(entityId, mediaFieldMetadata, storageProvider, {
+                    relativeUri: awsFileUrl,
+                    mimeType: file.mimetype,
+                    fileSize: file.size,
+                    originalFileName: file.originalname,
+                })
+            ) as unknown as Media;
+            mediaEntity.isPublic = resolveStoredMediaIsPublic(mediaEntity.isPublic, storageProvider);
             result.push(mediaEntity);
             this.logger.debug(`Stored media with`, mediaEntity);
         };
@@ -136,19 +124,14 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
     }
 
     async delete(entity: T, mediaFieldMetadata: FieldMetadata): Promise<void> {
-        const isSupportedEntity = entity instanceof CommonEntity
-            || entity instanceof LegacyCommonEntityWithExistingId
-            || entity instanceof LegacyCommonEntityWithGeneratedId;
-        if (!isSupportedEntity) {
-            throw new Error("Entity must be an instance of CommonEntity, LegacyCommonEntityWithExistingId or LegacyCommonEntityWithGeneratedId"); // FIXME This needs to be handled through generics. e.g T extends CommonEntity
-        }
+        const entityId = this.getSupportedEntityId(entity);
         const storageProvider = mediaFieldMetadata.mediaStorageProvider;
-        const region = this.getEffectiveRegion(storageProvider.region);
+        const region = getEffectiveS3Region(this.configService, storageProvider.region);
 
         // @ts-ignore
-        const existingMedia = await this.mediaRepository.findByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id, ['mediaStorageProviderMetadata']);
+        const existingMedia = await this.mediaRepository.findByEntityIdAndFieldIdAndModelMetadataId(entityId, mediaFieldMetadata.id, mediaFieldMetadata.model.id, ['mediaStorageProviderMetadata']);
         // @ts-ignore
-        this.mediaRepository.deleteByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id);
+        this.mediaRepository.deleteByEntityIdAndFieldIdAndModelMetadataId(entityId, mediaFieldMetadata.id, mediaFieldMetadata.model.id);
         for (const media of existingMedia) {
             const bucketName = storageProvider.bucketName;
             await this.s3FileService.delete(`${bucketName}:${media.relativeUri}`, { region });
@@ -163,26 +146,19 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
         if (!storageProvider?.bucketName || !media?.relativeUri) {
             return;
         }
-        const region = this.getEffectiveRegion(storageProvider.region);
+        const region = getEffectiveS3Region(this.configService, storageProvider.region);
         await this.s3FileService.delete(`${storageProvider.bucketName}:${media.relativeUri}`, { region });
     }
 
-    /**
-     * Get the effective region to use for S3 operations.
-     * Uses the provider-specific region if configured, otherwise falls back to env variable.
-     */
-    private getEffectiveRegion(providerRegion?: string): string | undefined {
-        return providerRegion || this.configService.get('S3_AWS_REGION_NAME');
-    }
+    private getSupportedEntityId(entity: T): number {
+        const isSupportedEntity = entity instanceof CommonEntity
+            || entity instanceof LegacyCommonEntityWithExistingId
+            || entity instanceof LegacyCommonEntityWithGeneratedId;
 
-    private getFullFilePath(media: Media): string {
-        // Use provider region if available, fallback to env variable
-        const region = this.getEffectiveRegion(media.mediaStorageProviderMetadata.region);
-        // https://lunarismedia.s3.ap-south-1.amazonaws.com/LUNARIS_CP_REGISTRATION_CREATIVE.jpg
-        return `https://${media.mediaStorageProviderMetadata.bucketName}.s3.${region}.amazonaws.com/${media.relativeUri}`;
-    }
+        if (!isSupportedEntity) {
+            throw new Error("Entity must be an instance of CommonEntity, LegacyCommonEntityWithExistingId or LegacyCommonEntityWithGeneratedId");
+        }
 
-    private getFileName(file: Express.Multer.File): string {
-        return `${file.filename}-${file.originalname}`;
+        return (entity as any).id;
     }
 }