presenter refactoring

apps/api/src/domain/media/MediaService.ts

@@ -1,24 +1,12 @@
 import { Injectable, Inject } from '@nestjs/common';
 import type { RequestAvatarGenerationInputDTO } from './dtos/RequestAvatarGenerationInputDTO';
-import type { RequestAvatarGenerationOutputDTO } from './dtos/RequestAvatarGenerationOutputDTO';
 import type { UploadMediaInputDTO } from './dtos/UploadMediaInputDTO';
-import type { UploadMediaOutputDTO } from './dtos/UploadMediaOutputDTO';
-import type { GetMediaOutputDTO } from './dtos/GetMediaOutputDTO';
-import type { DeleteMediaOutputDTO } from './dtos/DeleteMediaOutputDTO';
-import type { GetAvatarOutputDTO } from './dtos/GetAvatarOutputDTO';
 import type { UpdateAvatarInputDTO } from './dtos/UpdateAvatarInputDTO';
-import type { UpdateAvatarOutputDTO } from './dtos/UpdateAvatarOutputDTO';
 import type { RacingSuitColor } from '@core/media/domain/types/AvatarGenerationRequest';
 
 type RequestAvatarGenerationInput = RequestAvatarGenerationInputDTO;
-type RequestAvatarGenerationOutput = RequestAvatarGenerationOutputDTO;
 type UploadMediaInput = UploadMediaInputDTO;
-type UploadMediaOutput = UploadMediaOutputDTO;
-type GetMediaOutput = GetMediaOutputDTO;
-type DeleteMediaOutput = DeleteMediaOutputDTO;
-type GetAvatarOutput = GetAvatarOutputDTO;
 type UpdateAvatarInput = UpdateAvatarInputDTO;
-type UpdateAvatarOutput = UpdateAvatarOutputDTO;
 
 // Use cases
 import { RequestAvatarGenerationUseCase } from '@core/media/application/use-cases/RequestAvatarGenerationUseCase';
@@ -60,7 +48,7 @@ export class MediaService {
     @Inject(LOGGER_TOKEN) private readonly logger: Logger,
   ) {}
 
-  async requestAvatarGeneration(input: RequestAvatarGenerationInput): Promise<RequestAvatarGenerationOutput> {
+  async requestAvatarGeneration(input: RequestAvatarGenerationInput): Promise<RequestAvatarGenerationPresenter> {
     this.logger.debug('[MediaService] Requesting avatar generation.');
 
     const presenter = new RequestAvatarGenerationPresenter();
@@ -69,10 +57,11 @@ export class MediaService {
       facePhotoData: input.facePhotoData,
       suitColor: input.suitColor as RacingSuitColor,
     }, presenter);
-    return presenter.viewModel;
+
+    return presenter;
   }
 
-  async uploadMedia(input: UploadMediaInput & { file: Express.Multer.File }): Promise<UploadMediaOutput> {
+  async uploadMedia(input: UploadMediaInput & { file: Express.Multer.File }): Promise<UploadMediaPresenter> {
     this.logger.debug('[MediaService] Uploading media.');
 
     const presenter = new UploadMediaPresenter();
@@ -83,102 +72,49 @@ export class MediaService {
       metadata: input.metadata,
     }, presenter);
 
-    const result = presenter.viewModel;
-
-    if (result.success) {
-      return {
-        success: true,
-        mediaId: result.mediaId!,
-        url: result.url!,
-      };
-    } else {
-      return {
-        success: false,
-        errorMessage: result.errorMessage || 'Upload failed',
-      };
-    }
+    return presenter;
   }
 
-  async getMedia(mediaId: string): Promise<GetMediaOutput | null> {
+  async getMedia(mediaId: string): Promise<GetMediaPresenter> {
     this.logger.debug(`[MediaService] Getting media: ${mediaId}`);
 
     const presenter = new GetMediaPresenter();
 
     await this.getMediaUseCase.execute({ mediaId }, presenter);
 
-    const result = presenter.viewModel;
-
-    if (result.success && result.media) {
-      return {
-        success: true,
-        mediaId: result.media.id,
-        filename: result.media.filename,
-        originalName: result.media.originalName,
-        mimeType: result.media.mimeType,
-        size: result.media.size,
-        url: result.media.url,
-        type: result.media.type,
-        uploadedBy: result.media.uploadedBy,
-        uploadedAt: result.media.uploadedAt,
-        metadata: result.media.metadata,
-      };
-    }
-
-    return null;
+    return presenter;
   }
 
-  async deleteMedia(mediaId: string): Promise<DeleteMediaOutput> {
+  async deleteMedia(mediaId: string): Promise<DeleteMediaPresenter> {
     this.logger.debug(`[MediaService] Deleting media: ${mediaId}`);
 
     const presenter = new DeleteMediaPresenter();
 
     await this.deleteMediaUseCase.execute({ mediaId }, presenter);
 
-    const result = presenter.viewModel;
-
-    return {
-      success: result.success,
-      errorMessage: result.errorMessage,
-    };
+    return presenter;
   }
 
-  async getAvatar(driverId: string): Promise<GetAvatarOutput | null> {
+  async getAvatar(driverId: string): Promise<GetAvatarPresenter> {
     this.logger.debug(`[MediaService] Getting avatar for driver: ${driverId}`);
 
     const presenter = new GetAvatarPresenter();
 
     await this.getAvatarUseCase.execute({ driverId }, presenter);
 
-    const result = presenter.viewModel;
-
-    if (result.success && result.avatar) {
-      return {
-        success: true,
-        avatarId: result.avatar.id,
-        driverId: result.avatar.driverId,
-        mediaUrl: result.avatar.mediaUrl,
-        selectedAt: result.avatar.selectedAt,
-      };
-    }
-
-    return null;
+    return presenter;
   }
 
-  async updateAvatar(driverId: string, input: UpdateAvatarInput): Promise<UpdateAvatarOutput> {
+  async updateAvatar(driverId: string, input: UpdateAvatarInput): Promise<UpdateAvatarPresenter> {
     this.logger.debug(`[MediaService] Updating avatar for driver: ${driverId}`);
-
+ 
     const presenter = new UpdateAvatarPresenter();
-
+ 
     await this.updateAvatarUseCase.execute({
       driverId,
       mediaUrl: input.mediaUrl,
     }, presenter);
-
-    const result = presenter.viewModel;
-
-    return {
-      success: result.success,
-      errorMessage: result.errorMessage,
-    };
+ 
+    return presenter;
   }
 }