refactor use cases

core/media/application/use-cases/UploadMediaUseCase.ts

@@ -6,9 +6,10 @@
 
 import type { IMediaRepository } from '../../domain/repositories/IMediaRepository';
 import type { MediaStoragePort } from '../ports/MediaStoragePort';
-import type { Logger } from '@core/shared/application';
+import type { Logger, UseCaseOutputPort } from '@core/shared/application';
+import { Result } from '@core/shared/application/Result';
+import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
 import { Media } from '../../domain/entities/Media';
-import type { IUploadMediaPresenter } from '../presenters/IUploadMediaPresenter';
 import { v4 as uuidv4 } from 'uuid';
 
 export interface UploadMediaInput {
@@ -18,34 +19,32 @@ export interface UploadMediaInput {
 }
 
 export interface UploadMediaResult {
-  success: boolean;
-  mediaId?: string;
-  url?: string;
-  errorMessage?: string;
+  mediaId: string;
+  url: string | undefined;
 }
 
-export interface IUploadMediaPresenter {
-  present(result: UploadMediaResult): void;
-}
+export type UploadMediaErrorCode =
+  | 'UPLOAD_FAILED'
+  | 'REPOSITORY_ERROR';
 
 export class UploadMediaUseCase {
   constructor(
     private readonly mediaRepo: IMediaRepository,
     private readonly mediaStorage: MediaStoragePort,
+    private readonly output: UseCaseOutputPort<UploadMediaResult>,
     private readonly logger: Logger,
   ) {}
 
   async execute(
     input: UploadMediaInput,
-    presenter: IUploadMediaPresenter,
-  ): Promise<void> {
-    try {
-      this.logger.info('[UploadMediaUseCase] Starting media upload', {
-        filename: input.file.originalname,
-        size: input.file.size,
-        uploadedBy: input.uploadedBy,
-      });
+  ): Promise<Result<void, ApplicationErrorCode<UploadMediaErrorCode, { message: string }>>> {
+    this.logger.info('[UploadMediaUseCase] Starting media upload', {
+      filename: input.file.originalname,
+      size: input.file.size,
+      uploadedBy: input.uploadedBy,
+    });
 
+    try {
       // Upload file to storage service
       const uploadResult = await this.mediaStorage.uploadMedia(input.file.buffer, {
         filename: input.file.originalname,
@@ -54,11 +53,13 @@ export class UploadMediaUseCase {
       });
 
       if (!uploadResult.success) {
-        presenter.present({
-          success: false,
-          errorMessage: uploadResult.errorMessage || 'Failed to upload media',
+        return Result.err({
+          code: 'UPLOAD_FAILED',
+          details: {
+            message:
+              uploadResult.errorMessage ?? 'Failed to upload media',
+          },
         });
-        return;
       }
 
       // Determine media type
@@ -85,8 +86,7 @@ export class UploadMediaUseCase {
       // Save to repository
       await this.mediaRepo.save(media);
 
-      presenter.present({
-        success: true,
+      this.output.present({
         mediaId,
         url: uploadResult.url,
       });
@@ -96,15 +96,17 @@ export class UploadMediaUseCase {
         url: uploadResult.url,
       });
 
+      return Result.ok(undefined);
     } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
       this.logger.error('[UploadMediaUseCase] Error uploading media', {
-        error: error instanceof Error ? error.message : 'Unknown error',
+        error: err.message,
         filename: input.file.originalname,
       });
 
-      presenter.present({
-        success: false,
-        errorMessage: 'Internal error occurred during media upload',
+      return Result.err({
+        code: 'REPOSITORY_ERROR',
+        details: { message: err.message },
       });
     }
   }