@solidxai/core 0.1.12-beta.1 → 0.1.12-beta.3

package/src/dtos/create-media.dto.ts

@@ -1,5 +1,5 @@
-import { ApiProperty } from '@nestjs/swagger';
-import { IsInt } from 'class-validator';
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsBoolean, IsInt } from 'class-validator';
 import { IsNotEmpty, IsString, IsOptional } from 'class-validator';
 export class CreateMediaDto {
 @IsNotEmpty()
@@ -7,6 +7,11 @@ export class CreateMediaDto {
 @ApiProperty()
 entityId: number;
 
+@IsOptional()
+@IsBoolean()
+@ApiPropertyOptional({ default: true })
+isPublic?: boolean;
+
 @IsOptional()
 @IsString()
 @ApiProperty()
@@ -56,4 +61,4 @@ fieldMetadataId: number;
 @IsOptional()
 @ApiProperty()
 fieldMetadataUserKey: string;
-}
+}

package/src/dtos/post-chatter-message.dto.ts

@@ -13,6 +13,10 @@ export class PostChatterMessageDto {
     @IsNotEmpty()
     messageBody: string;
 
+    @IsString()
+    @IsOptional()
+    messageBodyMentions?: string;
+
     @IsString()
     @IsOptional()
     messageSubType?: string;

package/src/dtos/update-chatter-message.dto.ts

@@ -24,6 +24,12 @@ export class UpdateChatterMessageDto {
     @ApiProperty()
     messageBody: string;
 
+    @IsNotEmpty()
+    @IsOptional()
+    @IsString()
+    @ApiProperty()
+    messageBodyMentions: string;
+
     @IsNotEmpty()
     @IsOptional()
     @IsInt()

package/src/dtos/update-chatter-note-message.dto.ts

@@ -7,6 +7,11 @@ export class UpdateChatterNoteMessageDto {
     @ApiProperty()
     messageBody: string;
 
+    @IsString()
+    @IsOptional()
+    @ApiProperty()
+    messageBodyMentions?: string;
+
     @IsString()
     @IsOptional()
     @ApiProperty({ required: false, description: 'Comma-separated media IDs to remove from this note.' })

package/src/dtos/update-media.dto.ts

@@ -1,5 +1,5 @@
-import { IsInt,IsOptional, IsNotEmpty, IsString } from 'class-validator';
-import { ApiProperty } from '@nestjs/swagger';
+import { IsBoolean, IsInt,IsOptional, IsNotEmpty, IsString } from 'class-validator';
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 export class UpdateMediaDto {
     @IsOptional()
     @IsInt()
@@ -11,6 +11,11 @@ export class UpdateMediaDto {
 @ApiProperty()
 entityId: number;
 
+@IsOptional()
+@IsBoolean()
+@ApiPropertyOptional({ default: true })
+isPublic?: boolean;
+
 @IsOptional()
 @IsString()
 @ApiProperty()
@@ -60,4 +65,4 @@ fieldMetadataId: number;
 @IsOptional()
 @ApiProperty()
 fieldMetadataUserKey: string;
-}
+}

package/src/entities/chatter-message.entity.ts

@@ -18,6 +18,9 @@ export class ChatterMessage extends CommonEntity {
     @Column({ nullable: true, ...getColumnType('longText') })
     messageBody: string;
 
+    @Column({ nullable: true, ...getColumnType('longText') })
+    messageBodyMentions: string;
+
     @Index()
     @Column({ type: "integer" })
     coModelEntityId: number;

package/src/entities/media.entity.ts

@@ -9,6 +9,9 @@ export class Media extends CommonEntity {
     @Column({ type: "integer" })
     entityId: number;
 
+    @Column({ name: "is_public", default: true })
+    isPublic: boolean = true;
+
     @Column({ type: "varchar", nullable: true })
     relativeUri: string;
 
@@ -36,4 +39,4 @@ export class Media extends CommonEntity {
     @ManyToOne(() => FieldMetadata, { nullable: false })
     @JoinColumn()
     fieldMetadata: FieldMetadata;
-}
+}

package/src/enums/auth-type.enum.ts

@@ -2,4 +2,5 @@ export enum AuthType {
     Bearer,
     ApiKey,
     None,
+    MediaSignedUrl,
 }

package/src/guards/authentication.guard.ts

@@ -9,6 +9,7 @@ import { AUTH_TYPE_KEY } from '../decorators/auth.decorator';
 import { AuthType } from '../enums/auth-type.enum';
 import { AccessTokenGuard } from './access-token.guard';
 import { ApiKeyGuard } from './api-key.guard';
+import { MediaSignedUrlGuard } from './media-signed-url.guard';
 import { IS_PUBLIC_KEY } from '../decorators/public.decorator';
 import { PermissionMetadataService } from '../services/permission-metadata.service';
 import { ClsService } from 'nestjs-cls';
@@ -22,12 +23,14 @@ export class AuthenticationGuard implements CanActivate {
       [AuthType.Bearer]: this.accessTokenGuard,
       [AuthType.ApiKey]: this.apiKeyGuard,
       [AuthType.None]: { canActivate: () => true },
+      [AuthType.MediaSignedUrl]: this.mediaSignedUrlGuard,
     };
 
   constructor(
     private readonly reflector: Reflector,
     private readonly accessTokenGuard: AccessTokenGuard,
     private readonly apiKeyGuard: ApiKeyGuard,
+    private readonly mediaSignedUrlGuard: MediaSignedUrlGuard,
     private readonly permissionService: PermissionMetadataService,
     private readonly cls: ClsService,
   ) { }

package/src/guards/media-signed-url.guard.ts

@@ -0,0 +1,41 @@
+import { CanActivate, ExecutionContext, Injectable, UnauthorizedException } from '@nestjs/common';
+import { Request } from 'express';
+import { MediaDownloadUrlService } from 'src/services/media-download-url.service';
+
+@Injectable()
+export class MediaSignedUrlGuard implements CanActivate {
+  constructor(private readonly mediaDownloadUrlService: MediaDownloadUrlService) { }
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const request = context.switchToHttp().getRequest<Request>();
+    const token = this.extractTokenFromQuery(request);
+    if (!token) {
+      throw new UnauthorizedException();
+    }
+
+    let payload: { mediaId: number };
+    try {
+      payload = await this.mediaDownloadUrlService.verifyDownloadToken(token);
+    } catch {
+      throw new UnauthorizedException();
+    }
+
+    const routeMediaId = Number(request.params?.id);
+    if (!Number.isFinite(routeMediaId) || payload.mediaId !== routeMediaId) {
+      throw new UnauthorizedException();
+    }
+
+    // No REQUEST_USER_KEY is ever set for token auth (only Bearer/ApiKey guards set it), so
+    // the sibling global APP_GUARD PermissionsGuard would otherwise reject this request for
+    // lack of a per-user permission grant. Flag it the same way AuthenticationGuard flags
+    // Public-role-exempt requests - token possession IS the full authorization decision here.
+    request['isListedInPublicRole'] = true;
+
+    return true;
+  }
+
+  private extractTokenFromQuery(request: Request): string | undefined {
+    const token = request.query?.token;
+    return typeof token === 'string' ? token : undefined;
+  }
+}

package/src/helpers/field-crud-managers/MediaFieldCrudManager.ts

@@ -1,4 +1,5 @@
 import { FieldCrudManager, ValidationError } from "src/interfaces";
+import { DANGEROUS_EXTENSIONS, EXT_TO_MEDIA_TYPE, MediaCategory } from "src/constants/media-file-types";
 
 export enum SolidMediaType {
     mediaSingle = 'mediaSingle',
@@ -14,7 +15,7 @@ export interface MediaFieldOptions {
     isUpdate: boolean | undefined | null;
 }
 
-type MediaType = 'image' | 'audio' | 'video' | 'file' | 'pdf';
+type MediaType = MediaCategory;
 
 const MIME_TO_MEDIA_TYPE: Record<string, MediaType> = {
     // Images
@@ -25,7 +26,6 @@ const MIME_TO_MEDIA_TYPE: Record<string, MediaType> = {
     'image/gif': 'image',
     'image/bmp': 'image',
     'image/tiff': 'image',
-    'image/svg+xml': 'image',
     'image/heic': 'image',
     'image/heif': 'image',
 
@@ -72,35 +72,23 @@ const MIME_TO_MEDIA_TYPE: Record<string, MediaType> = {
     'application/x-zip-compressed': 'file',
     'application/x-rar-compressed': 'file',
     'application/x-7z-compressed': 'file',
-
-    // Common binary fallback category
-    'application/octet-stream': 'file',
 };
 
-const EXT_TO_MEDIA_TYPE: Record<string, MediaType> = {
-    // Images
-    png: 'image', jpg: 'image', jpeg: 'image', webp: 'image', gif: 'image', bmp: 'image', tiff: 'image', svg: 'image', heic: 'image', heif: 'image',
-
-    // Audio
-    mp3: 'audio', wav: 'audio', ogg: 'audio', aac: 'audio', m4a: 'audio', flac: 'audio',
-
-    // Video
-    mp4: 'video', mov: 'video', avi: 'video', mkv: 'video', mpeg: 'video', mpg: 'video', '3gp': 'video', '3g2': 'video',
-
-    // Files
-    pdf: 'file', txt: 'file', md: 'file', csv: 'file', json: 'file',
-    doc: 'file', docx: 'file', xls: 'file', xlsx: 'file', ppt: 'file', pptx: 'file',
-    zip: 'file', rar: 'file', '7z': 'file',
-};
-
-
 export class MediaFieldCrudManager implements FieldCrudManager {
 
     constructor(private readonly options: MediaFieldOptions) {
     }
 
     private resolveMediaType(mimetype?: string, filename?: string): MediaType | null {
+        const ext = (filename || '').split('.').pop()?.toLowerCase();
+        if (ext && DANGEROUS_EXTENSIONS.has(ext)) {
+            return null;
+        }
+
         const mt = (mimetype || '').toLowerCase().trim();
+        if (mt === 'image/svg+xml' || mt === 'text/html' || mt === 'application/xhtml+xml') {
+            return null;
+        }
         if (mt && MIME_TO_MEDIA_TYPE[mt]) {
             return MIME_TO_MEDIA_TYPE[mt];
         }
@@ -110,8 +98,8 @@ export class MediaFieldCrudManager implements FieldCrudManager {
         if (mt.startsWith('audio/')) return 'audio';
         if (mt.startsWith('video/')) return 'video';
 
-        // Fallback to extension if provided
-        const ext = (filename || '').split('.').pop()?.toLowerCase();
+        // Fallback to extension if provided (also covers generic/unrecognized
+        // mimetypes such as application/octet-stream).
         if (ext && EXT_TO_MEDIA_TYPE[ext]) {
             return EXT_TO_MEDIA_TYPE[ext];
         }

package/src/interfaces/chatter-mention-notification.interface.ts

@@ -0,0 +1,29 @@
+export interface ChatterMentionNotificationMention {
+    id?: number;
+    username: string;
+    displayName: string;
+}
+
+export interface ChatterMentionNotificationActor {
+    id?: number;
+    username?: string;
+    email?: string;
+}
+
+export interface ChatterMentionNotificationEntity {
+    id: number;
+    modelName: string;
+    moduleName?: string;
+    displayName: string;
+    userKey?: string;
+}
+
+export interface ChatterMentionNotificationPayload {
+    templateName: string;
+    mentions: ChatterMentionNotificationMention[];
+    actor: ChatterMentionNotificationActor;
+    noteBody: string;
+    entity: ChatterMentionNotificationEntity;
+    parentEntity: string;
+    parentEntityId: number;
+}

package/src/jobs/chatter-mention-notification-email-queue-handler.service.ts

@@ -0,0 +1,114 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { MailFactory } from 'src/factories/mail.factory';
+import { ChatterMentionNotificationPayload } from 'src/interfaces/chatter-mention-notification.interface';
+import { QueueMessage } from 'src/interfaces/mq';
+import { UserRepository } from 'src/repository/user.repository';
+import { SettingService } from 'src/services/setting.service';
+import type { SolidCoreSetting } from 'src/services/settings/default-settings-provider.service';
+import { In } from 'typeorm';
+
+@Injectable()
+export class ChatterMentionNotificationEmailQueueHandler {
+    private readonly logger = new Logger(ChatterMentionNotificationEmailQueueHandler.name);
+
+    constructor(
+        private readonly mailFactory: MailFactory,
+        private readonly userRepository: UserRepository,
+        private readonly settingService: SettingService,
+    ) {}
+
+    private buildAdminRecordFormUrl(frontendAdminBaseUrl: string, moduleName: string, modelName: string, recordId: number) {
+        if (!frontendAdminBaseUrl || !moduleName || !modelName || !recordId) return '';
+        const normalizedModelName = modelName
+            .trim()
+            .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+            .replace(/[_\s]+/g, '-')
+            .toLowerCase();
+        return `${frontendAdminBaseUrl.replace(/\/+$/, '')}/admin/core/${moduleName.trim()}/${normalizedModelName}/form/${recordId}`;
+    }
+
+    async handle(message: QueueMessage<ChatterMentionNotificationPayload>) {
+        const mailService = this.mailFactory.getMailService();
+        const payload = message.payload;
+
+        if (!payload?.mentions?.length) {
+            this.logger.debug('Skipping chatter mention notification because no mentions were provided.');
+            return { sent: 0 };
+        }
+
+        const mentionUserIds = payload.mentions
+            .map(mention => Number(mention.id))
+            .filter(id => Number.isInteger(id) && id > 0);
+        const userIdsToLoad = Array.from(new Set([
+            ...mentionUserIds,
+            ...(payload.actor?.id ? [Number(payload.actor.id)] : []),
+        ]));
+
+        if (userIdsToLoad.length === 0) {
+            this.logger.debug('Skipping chatter mention notification because mention user ids were not provided.');
+            return { sent: 0 };
+        }
+
+        const users = await this.userRepository.find({
+            where: { id: In(userIdsToLoad) },
+        });
+        const usersById = new Map(users.map(user => [Number(user.id), user]));
+        const actor = payload.actor?.id ? usersById.get(Number(payload.actor.id)) : null;
+        const recipients = Array.from(new Set(mentionUserIds))
+            .map(id => {
+                const user = usersById.get(id);
+                const mention = payload.mentions.find(item => Number(item.id) === id);
+                return {
+                    id,
+                    username: user?.username || mention?.username || '',
+                    displayName: user?.fullName || mention?.displayName || user?.username || mention?.username || '',
+                    email: user?.email || '',
+                };
+            })
+            .filter(recipient => Boolean(recipient.email));
+
+        if (recipients.length === 0) {
+            this.logger.debug('Skipping chatter mention notification because no mentioned users have email addresses.');
+            return { sent: 0 };
+        }
+
+        const frontendAdminBaseUrl = this.settingService.getConfigValue<SolidCoreSetting>('frontendAdminBaseUrl');
+        const commonTemplateParams = {
+            mentionedByDisplayName: actor?.fullName || payload.actor?.username || payload.actor?.email || 'Someone',
+            mentionedByEmail: actor?.email || payload.actor?.email,
+            noteBody: payload.noteBody,
+            entityDisplayName: payload.entity.displayName,
+            entityUserKey: payload.entity.userKey,
+            entityFormUrl: this.buildAdminRecordFormUrl(
+                frontendAdminBaseUrl,
+                payload.entity.moduleName,
+                payload.entity.modelName,
+                payload.entity.id,
+            ),
+            solidAppName: this.settingService.getConfigValue<SolidCoreSetting>('appTitle'),
+            solidAppWebsiteUrl: this.settingService.getConfigValue<SolidCoreSetting>('solidAppWebsiteUrl'),
+            companyLogoUrl: this.settingService.getConfigValue<SolidCoreSetting>('companylogo'),
+        };
+
+        let sent = 0;
+        for (const recipient of recipients) {
+            await mailService.sendEmailUsingTemplate(
+                recipient.email,
+                payload.templateName,
+                {
+                    ...commonTemplateParams,
+                    mentionedUserDisplayName: recipient.displayName || recipient.username,
+                    mentionedUserUsername: recipient.username,
+                },
+                false,
+                null,
+                null,
+                payload.parentEntity,
+                payload.parentEntityId,
+            );
+            sent += 1;
+        }
+
+        return { sent };
+    }
+}

package/src/jobs/database/chatter-mention-notification-email-publisher-database.service.ts

@@ -0,0 +1,23 @@
+import { Injectable } from '@nestjs/common';
+import { ChatterMentionNotificationPayload } from 'src/interfaces/chatter-mention-notification.interface';
+import { QueuesModuleOptions } from 'src/interfaces';
+import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
+import { MqMessageService } from 'src/services/mq-message.service';
+import { DatabasePublisher } from 'src/services/queues/database-publisher.service';
+import queueOptions from './chatter-mention-notification-email-queue-options-database';
+
+@Injectable()
+export class ChatterMentionNotificationEmailQueuePublisherDatabase extends DatabasePublisher<ChatterMentionNotificationPayload> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...queueOptions
+        };
+    }
+}

package/src/jobs/database/chatter-mention-notification-email-queue-options-database.ts

@@ -0,0 +1,9 @@
+import { BrokerType } from "src/interfaces";
+
+const QUEUE_NAME = 'solid_chatter_mention_notification_email_queue_database';
+
+export default {
+    name: QUEUE_NAME,
+    type: BrokerType.Database,
+    queueName: QUEUE_NAME,
+};

package/src/jobs/database/chatter-mention-notification-email-subscriber-database.service.ts

@@ -0,0 +1,32 @@
+import { Injectable } from '@nestjs/common';
+import { ChatterMentionNotificationEmailQueueHandler } from 'src/jobs/chatter-mention-notification-email-queue-handler.service';
+import { ChatterMentionNotificationPayload } from 'src/interfaces/chatter-mention-notification.interface';
+import { QueuesModuleOptions } from 'src/interfaces';
+import { QueueMessage } from 'src/interfaces/mq';
+import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
+import { MqMessageService } from 'src/services/mq-message.service';
+import { PollerService } from 'src/services/poller.service';
+import { DatabaseSubscriber } from 'src/services/queues/database-subscriber.service';
+import queueOptions from './chatter-mention-notification-email-queue-options-database';
+
+@Injectable()
+export class ChatterMentionNotificationEmailQueueSubscriberDatabase extends DatabaseSubscriber<ChatterMentionNotificationPayload> {
+    constructor(
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+        readonly poller: PollerService,
+        private readonly handler: ChatterMentionNotificationEmailQueueHandler,
+    ) {
+        super(mqMessageService, mqMessageQueueService, poller);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...queueOptions
+        };
+    }
+
+    subscribe(message: QueueMessage<ChatterMentionNotificationPayload>) {
+        return this.handler.handle(message);
+    }
+}

package/src/jobs/rabbitmq/chatter-mention-notification-email-publisher.service.ts

@@ -0,0 +1,23 @@
+import { Injectable } from '@nestjs/common';
+import { ChatterMentionNotificationPayload } from 'src/interfaces/chatter-mention-notification.interface';
+import { QueuesModuleOptions } from 'src/interfaces';
+import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
+import { MqMessageService } from 'src/services/mq-message.service';
+import { RabbitMqPublisher } from 'src/services/queues/rabbitmq-publisher.service';
+import queueOptions from './chatter-mention-notification-email-queue-options';
+
+@Injectable()
+export class ChatterMentionNotificationEmailQueuePublisherRabbitmq extends RabbitMqPublisher<ChatterMentionNotificationPayload> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...queueOptions
+        };
+    }
+}

package/src/jobs/rabbitmq/chatter-mention-notification-email-queue-options.ts

@@ -0,0 +1,9 @@
+import { BrokerType } from "src/interfaces";
+
+const QUEUE_NAME = 'solid_chatter_mention_notification_email_queue';
+
+export default {
+    name: QUEUE_NAME,
+    type: BrokerType.RabbitMQ,
+    queueName: QUEUE_NAME,
+};

package/src/jobs/rabbitmq/chatter-mention-notification-email-subscriber.service.ts

@@ -0,0 +1,30 @@
+import { Injectable } from '@nestjs/common';
+import { ChatterMentionNotificationEmailQueueHandler } from 'src/jobs/chatter-mention-notification-email-queue-handler.service';
+import { ChatterMentionNotificationPayload } from 'src/interfaces/chatter-mention-notification.interface';
+import { QueuesModuleOptions } from 'src/interfaces';
+import { QueueMessage } from 'src/interfaces/mq';
+import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
+import { MqMessageService } from 'src/services/mq-message.service';
+import { RabbitMqSubscriber } from 'src/services/queues/rabbitmq-subscriber.service';
+import queueOptions from './chatter-mention-notification-email-queue-options';
+
+@Injectable()
+export class ChatterMentionNotificationEmailQueueSubscriberRabbitmq extends RabbitMqSubscriber<ChatterMentionNotificationPayload> {
+    constructor(
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+        private readonly handler: ChatterMentionNotificationEmailQueueHandler,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...queueOptions
+        };
+    }
+
+    subscribe(message: QueueMessage<ChatterMentionNotificationPayload>) {
+        return this.handler.handle(message);
+    }
+}

package/src/jobs/redis/chatter-mention-notification-email-publisher-redis.service.ts

@@ -0,0 +1,23 @@
+import { Injectable } from '@nestjs/common';
+import { ChatterMentionNotificationPayload } from 'src/interfaces/chatter-mention-notification.interface';
+import { QueuesModuleOptions } from 'src/interfaces';
+import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
+import { MqMessageService } from 'src/services/mq-message.service';
+import { RedisPublisher } from 'src/services/queues/redis-publisher.service';
+import queueOptions from './chatter-mention-notification-email-queue-options-redis';
+
+@Injectable()
+export class ChatterMentionNotificationEmailQueuePublisherRedis extends RedisPublisher<ChatterMentionNotificationPayload> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...queueOptions
+        };
+    }
+}

package/src/jobs/redis/chatter-mention-notification-email-queue-options-redis.ts

@@ -0,0 +1,9 @@
+import { BrokerType } from "src/interfaces";
+
+const QUEUE_NAME = 'solid_chatter_mention_notification_email_queue_redis';
+
+export default {
+    name: QUEUE_NAME,
+    type: BrokerType.Redis,
+    queueName: QUEUE_NAME,
+};

package/src/jobs/redis/chatter-mention-notification-email-subscriber-redis.service.ts

@@ -0,0 +1,30 @@
+import { Injectable } from '@nestjs/common';
+import { ChatterMentionNotificationEmailQueueHandler } from 'src/jobs/chatter-mention-notification-email-queue-handler.service';
+import { ChatterMentionNotificationPayload } from 'src/interfaces/chatter-mention-notification.interface';
+import { QueuesModuleOptions } from 'src/interfaces';
+import { QueueMessage } from 'src/interfaces/mq';
+import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
+import { MqMessageService } from 'src/services/mq-message.service';
+import { RedisSubscriber } from 'src/services/queues/redis-subscriber.service';
+import queueOptions from './chatter-mention-notification-email-queue-options-redis';
+
+@Injectable()
+export class ChatterMentionNotificationEmailQueueSubscriberRedis extends RedisSubscriber<ChatterMentionNotificationPayload> {
+    constructor(
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+        private readonly handler: ChatterMentionNotificationEmailQueueHandler,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...queueOptions
+        };
+    }
+
+    subscribe(message: QueueMessage<ChatterMentionNotificationPayload>) {
+        return this.handler.handle(message);
+    }
+}

package/src/repository/media.repository.ts

@@ -7,6 +7,7 @@ import { MediaStorageProviderMetadataRepository } from './media-storage-provider
 import { ModelMetadataRepository } from './model-metadata.repository';
 import { SecurityRuleRepository } from './security-rule.repository';
 import { SolidBaseRepository } from './solid-base.repository';
+import { resolveStoredMediaIsPublic } from 'src/services/media-storage.utils';
 
 @Injectable()
 export class MediaRepository extends SolidBaseRepository<Media> {
@@ -44,6 +45,7 @@ export class MediaRepository extends SolidBaseRepository<Media> {
                 id: createDto['mediaStorageProviderMetadataId']
             },
         });
+        createDto['isPublic'] = resolveStoredMediaIsPublic(createDto['isPublic'], createDto['mediaStorageProviderMetadata']);
         const media = this.create(createDto);
         return this.save(media);
     }