@solidxai/core 0.1.12-beta.0 → 0.1.12-beta.10

package/src/services/chatter-message.service.ts

@@ -11,6 +11,7 @@ import { PostChatterMessageDto } from 'src/dtos/post-chatter-message.dto';
 import { UpdateChatterNoteMessageDto } from 'src/dtos/update-chatter-note-message.dto';
 import { ModelMetadataHelperService } from 'src/helpers/model-metadata-helper.service';
 import { lowerFirst } from 'src/helpers/string.helper';
+import { ChatterMentionNotificationPayload } from 'src/interfaces/chatter-mention-notification.interface';
 import { ChatterMessageDetailsRepository } from 'src/repository/chatter-message-details.repository';
 import { ChatterMessageRepository } from 'src/repository/chatter-message.repository';
 import { FieldMetadataRepository } from 'src/repository/field-metadata.repository';
@@ -24,6 +25,14 @@ import { getMediaStorageProvider } from './mediaStorageProviders';
 import { RequestContextService } from './request-context.service';
 import { Logger } from '@nestjs/common';
 import { SolidIntrospectService } from './solid-introspect.service';
+import { PublisherFactory } from './queues/publisher-factory.service';
+
+interface ChatterMention {
+    username: string;
+    display_name?: string;
+    displayName?: string;
+    id?: string | number;
+}
 
 @Injectable()
 export class ChatterMessageService extends CRUDService<ChatterMessage> {
@@ -47,6 +56,7 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         private readonly modelMetadataRepo: ModelMetadataRepository,
         readonly requestContextService: RequestContextService,
         private readonly modelMetadataHelperService: ModelMetadataHelperService,
+        private readonly publisherFactory: PublisherFactory<ChatterMentionNotificationPayload>,
     ) {
         super(entityManager, repo, 'chatterMessage', 'solid-core', moduleRef);
     }
@@ -106,6 +116,78 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
             .filter(v => Number.isInteger(v) && v > 0);
     }
 
+    private parseMessageBodyMentions(value?: string): ChatterMention[] {
+        if (!value || typeof value !== 'string') return [];
+        try {
+            const parsed = JSON.parse(value);
+            return Array.isArray(parsed) ? parsed : [];
+        } catch {
+            return [];
+        }
+    }
+
+    private renderMentionTokens(messageBody: string, mentions: ChatterMention[]) {
+        return mentions.reduce((nextMessage, mention, index) => {
+            const username = mention.username;
+            if (!username) return nextMessage;
+            return nextMessage.replace(new RegExp(`\\{\\{\\s*${index}\\s*\\}\\}`, 'g'), `@${username}`);
+        }, messageBody || '');
+    }
+
+    private async publishChatterMentionNotifications(message: ChatterMessage, model: any) {
+        if (message.messageType !== CHATTER_MESSAGE_TYPE.CUSTOM || message.messageSubType !== CHATTER_MESSAGE_SUBTYPE.NOTE) {
+            return;
+        }
+
+        const mentions = this.parseMessageBodyMentions(message.messageBodyMentions);
+        const mentionUserIds = mentions
+            .map(mention => Number(mention.id))
+            .filter(id => Number.isInteger(id) && id > 0);
+        const uniqueMentionUserIds = Array.from(new Set(mentionUserIds));
+        if (uniqueMentionUserIds.length === 0) return;
+
+        const activeUser = this.requestContextService.getActiveUser();
+
+        const payload: ChatterMentionNotificationPayload = {
+            templateName: 'chatter-mention-notification',
+            mentions: mentions.map(mention => ({
+                id: Number(mention.id) || undefined,
+                username: mention.username,
+                displayName: mention.display_name || mention.displayName || mention.username,
+            })),
+            actor: {
+                id: activeUser?.sub,
+                username: activeUser?.username,
+                email: activeUser?.email,
+            },
+            noteBody: this.renderMentionTokens(message.messageBody, mentions),
+            entity: {
+                id: message.coModelEntityId,
+                modelName: model?.singularName || message.coModelName,
+                moduleName: model?.module?.name,
+                displayName: model?.displayName || message.coModelName,
+                userKey: message.modelUserKey,
+            },
+            parentEntity: 'chatterMessage',
+            parentEntityId: message.id,
+        };
+
+        try {
+            await this.publisherFactory.publish(
+                {
+                    payload,
+                    parentEntity: 'chatterMessage',
+                    parentEntityId: message.id,
+                    retryCount: 3,
+                    retryInterval: 5000,
+                },
+                'ChatterMentionNotificationEmailQueuePublisher',
+            );
+        } catch (error: any) {
+            this._logger.error(`Failed to publish chatter mention notification email job: ${error.message}`, error.stack);
+        }
+    }
+
     async markCompleted(id: number) {
         const activeUser = this.requestContextService.getActiveUser();
         if (!activeUser) {
@@ -146,10 +228,11 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
 
         const removeAttachmentIds = this.parseAttachmentIds(updateDto?.removeAttachmentIds);
         const hasMessageBody = typeof updateDto?.messageBody === 'string';
+        const hasMessageBodyMentions = typeof updateDto?.messageBodyMentions === 'string';
         const trimmedMessageBody = (updateDto?.messageBody ?? '').trim();
         const hasNewFiles = Array.isArray(files) && files.length > 0;
 
-        if (!hasMessageBody && removeAttachmentIds.length === 0 && !hasNewFiles) {
+        if (!hasMessageBody && !hasMessageBodyMentions && removeAttachmentIds.length === 0 && !hasNewFiles) {
             throw new BadRequestException('No note changes submitted.');
         }
 
@@ -160,6 +243,13 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         if (hasMessageBody) {
             message.messageBody = trimmedMessageBody;
         }
+        if (hasMessageBodyMentions) {
+            message.messageBodyMentions = updateDto.messageBodyMentions;
+        }
+        const model = await this.modelMetadataRepo.findOne({
+            where: { singularName: message.coModelName },
+            relations: { module: true }
+        });
         message.updatedBy = activeUser.sub;
         // Ensure updatedAt changes even for attachment-only edits.
         message.updatedAt = new Date();
@@ -214,6 +304,8 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
             }
         }
 
+        await this.publishChatterMentionNotifications(savedMessage, model);
+
         return savedMessage;
     }
 
@@ -226,13 +318,14 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         chatterMessage.messageSubType = postDto.messageSubType || CHATTER_MESSAGE_SUBTYPE.CUSTOM;
         chatterMessage.status = postDto.status ?? CHATTER_MESSAGE_STATUS.PENDING;
         chatterMessage.messageBody = postDto.messageBody;
+        chatterMessage.messageBodyMentions = postDto.messageBodyMentions;
         chatterMessage.coModelEntityId = postDto.coModelEntityId;
         chatterMessage.coModelName = coModelName;
         chatterMessage.modelUserKey = postDto.modelUserKey ?? null;
 
         const model = await this.modelMetadataRepo.findOne({
             where: { singularName: coModelName },
-            relations: { userKeyField: true }
+            relations: { userKeyField: true, module: true }
         });
         chatterMessage.modelDisplayName = model?.displayName ?? null;
 
@@ -262,6 +355,8 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
             }
         }
 
+        await this.publishChatterMentionNotifications(savedMessage, model);
+
         return savedMessage;
     }
 

package/src/services/media-download-url.service.ts

@@ -0,0 +1,74 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+import { MediaStorageProviderType } from 'src/dtos/create-media-storage-provider-metadata.dto';
+import { MediaStorageProviderMetadata } from 'src/entities/media-storage-provider-metadata.entity';
+import { SettingService } from 'src/services/setting.service';
+import type { SolidCoreSetting } from 'src/services/settings/default-settings-provider.service';
+import { getEffectiveS3Region } from './media-storage.utils';
+import { ConfigService } from '@nestjs/config';
+import { S3FileService } from './file';
+
+export const MEDIA_DOWNLOAD_TOKEN_AUDIENCE = 'media-download';
+const DEFAULT_SIGNED_URL_EXPIRY_MINUTES = 60;
+
+export interface MediaDownloadTokenPayload {
+  mediaId: number;
+}
+
+@Injectable()
+export class MediaDownloadUrlService {
+  private readonly logger = new Logger(MediaDownloadUrlService.name);
+
+  constructor(
+    private readonly jwtService: JwtService,
+    private readonly s3FileService: S3FileService,
+    private readonly settingService: SettingService,
+    private readonly configService: ConfigService,
+  ) { }
+
+  async resolveDownloadUrl(
+    mediaId: number,
+    relativeUri: string,
+    storageProvider?: MediaStorageProviderMetadata,
+  ): Promise<string> {
+    const expiryMinutes = storageProvider?.signedUrlExpiry ?? DEFAULT_SIGNED_URL_EXPIRY_MINUTES;
+
+      if ((storageProvider?.type as MediaStorageProviderType) === MediaStorageProviderType.AwsS3) {
+      if (storageProvider?.bucketName) {
+        return this.s3FileService.getUrl(
+          `${storageProvider.bucketName}:${relativeUri}`,
+          { region: getEffectiveS3Region(this.configService, storageProvider.region), expiresIn: expiryMinutes * 60 },
+        );
+      }
+      this.logger.warn(`Media id ${mediaId}: AwsS3 provider missing bucketName; falling back to app-hosted token URL`);
+    }
+    // Filesystem (or misconfigured S3) has no native presigned-URL mechanism, so mint our
+    // own short-lived token and embed it in the download URL - the token alone authorizes
+    // the request (see MediaSignedUrlGuard), so it works in a plain <img src> with no
+    // Authorization header needed.
+    const token = await this.mintDownloadToken(mediaId, expiryMinutes);
+    const downloadPath = `/api/media/${mediaId}/download?token=${token}`;
+    const baseUrl = this.settingService.getConfigValue<SolidCoreSetting>('baseUrl');
+    return `${String(baseUrl).replace(/\/+$/, '')}${downloadPath}`;
+  }
+
+  async getPrivateUrl(mediaId: number, relativeUri: string, storageProvider?: MediaStorageProviderMetadata): Promise<string> {
+    return this.resolveDownloadUrl(mediaId, relativeUri, storageProvider);
+  }
+
+  async verifyDownloadToken(token: string): Promise<MediaDownloadTokenPayload> {
+    return this.jwtService.verifyAsync<MediaDownloadTokenPayload>(token, {
+      secret: this.settingService.getConfigValue<SolidCoreSetting>('secret'),
+      audience: MEDIA_DOWNLOAD_TOKEN_AUDIENCE,
+    });
+  }
+
+  private mintDownloadToken(mediaId: number, expiryMinutes: number): Promise<string> {
+    const payload: MediaDownloadTokenPayload = { mediaId };
+    return this.jwtService.signAsync(payload, {
+      secret: this.settingService.getConfigValue<SolidCoreSetting>('secret'),
+      audience: MEDIA_DOWNLOAD_TOKEN_AUDIENCE,
+      expiresIn: expiryMinutes * 60,
+    });
+  }
+}

package/src/services/media-storage.utils.ts

@@ -0,0 +1,70 @@
+import { ConfigService } from '@nestjs/config';
+import * as path from 'path';
+import { FieldMetadata } from 'src/entities/field-metadata.entity';
+import { MediaStorageProviderMetadata } from 'src/entities/media-storage-provider-metadata.entity';
+import { SettingService } from 'src/services/setting.service';
+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';
+
+
+export interface MediaRecordCreateInput {
+  entityId: number;
+  modelMetadataId: number;
+  mediaStorageProviderMetadataId: number;
+  fieldMetadataId: number;
+  relativeUri: string;
+  mimeType?: string;
+  fileSize?: number;
+  originalFileName?: string;
+}
+
+// Builds the stored file name format shared by media storage implementations.
+export function buildStoredMediaFileName(file: Pick<Express.Multer.File, 'filename' | 'originalname'>): string {
+  return `${file.filename}-${file.originalname}`;
+}
+
+// Resolves the on-disk path for a media file based on settings and provider visibility.
+export function buildDiskMediaPath(fileName: string,settingService: Pick<SettingService, 'getConfigValue'>,storageProvider?: Pick<MediaStorageProviderMetadata, 'localPath' | 'isPublic'>,): string {
+  const publicBase = settingService.getConfigValue<SolidCoreSetting>('fileStorageDir') || DEFAULT_MEDIA_FILE_STORAGE_DIR;
+  const privateBase = `${publicBase}-private`;
+  // const localPath = storageProvider?.localPath;
+  // const isUsingLegacyDefaultPath = localPath === publicBase || localPath === privateBase || localPath === privateBase;
+  const providerBase = storageProvider?.isPublic === false ? privateBase : publicBase
+
+  if ( path.isAbsolute(fileName) || fileName.startsWith(`${publicBase}/`) || fileName.startsWith(`${privateBase}/`) ) {
+    return fileName;
+  }
+
+  return `${providerBase}/${fileName}`;
+}
+
+// Returns the S3 region from the provider when present, otherwise falls back to app config.
+export function getEffectiveS3Region(configService: Pick<ConfigService, 'get'>, providerRegion?: string): string | undefined {
+  return providerRegion || configService.get<string>('S3_AWS_REGION_NAME');
+}
+
+// Resolves the effective public/private flag for a media storage provider.
+export function resolveMediaIsPublic(storageProvider?: Pick<MediaStorageProviderMetadata, 'isPublic'>): boolean | undefined {
+  if (!storageProvider) {
+    return undefined;
+  }
+
+  return storageProvider.isPublic !== false;
+}
+
+// Builds the shared media record payload used before saving media metadata to the database.
+export function buildMediaRecordCreateInput(
+  entityId: number,
+  mediaFieldMetadata: Pick<FieldMetadata, 'id' | 'model'> & { model: { id: number } },
+  storageProvider: Pick<MediaStorageProviderMetadata, 'id'>,
+  overrides: Pick<MediaRecordCreateInput, 'relativeUri'>
+    & Partial<Omit<MediaRecordCreateInput, 'entityId' | 'modelMetadataId' | 'mediaStorageProviderMetadataId' | 'fieldMetadataId' | 'relativeUri'>>,
+): MediaRecordCreateInput {
+  return {
+    entityId,
+    modelMetadataId: mediaFieldMetadata.model.id,
+    mediaStorageProviderMetadataId: storageProvider.id,
+    fieldMetadataId: mediaFieldMetadata.id,
+    ...overrides,
+  };
+}

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, resolveMediaIsPublic, } 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,7 +131,8 @@ export class MediaService extends CRUDService<Media> {
       // Delete temp file from disk
       await this.diskFileService.delete(file.path);
 
-      const media = this.repo.create(createDto);
+      delete createDto['isPublic'];
+      const media = this.repo.create(createDto as Partial<Media>) as Media;
       const savedMedia = await this.repo.save(media);
       savedMedias.push(savedMedia)
     }
@@ -157,17 +160,142 @@ 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.relativeUri = await this.resolveMediaUrl(media, mediaStorageProvider);
+  }
+
+  private async resolveMediaUrl(media: Media, mediaStorageProvider?: MediaStorageProviderMetadata): Promise<string> {
+    const resolvedMediaStorageProvider = mediaStorageProvider || await this.resolveMediaStorageProvider(media);
+    const isPublic = resolveMediaIsPublic(resolvedMediaStorageProvider);
+
+    if (isPublic === false) {
+      return this.mediaDownloadUrlService.getPrivateUrl(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;
+  }
 }