refactor use cases

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

@@ -5,16 +5,16 @@
  */
 
 import type { IMediaRepository } from '../../domain/repositories/IMediaRepository';
-import type { Logger } from '@core/shared/application';
-import type { IGetMediaPresenter } from '../presenters/IGetMediaPresenter';
+import type { Logger, UseCaseOutputPort } from '@core/shared/application';
+import { Result } from '@core/shared/application/Result';
+import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
 
 export interface GetMediaInput {
   mediaId: string;
 }
 
 export interface GetMediaResult {
-  success: boolean;
-  media?: {
+  media: {
     id: string;
     filename: string;
     originalName: string;
@@ -26,40 +26,35 @@ export interface GetMediaResult {
     uploadedAt: Date;
     metadata?: Record<string, any>;
   };
-  errorMessage?: string;
 }
 
-export interface IGetMediaPresenter {
-  present(result: GetMediaResult): void;
-}
+export type GetMediaErrorCode = 'MEDIA_NOT_FOUND' | 'REPOSITORY_ERROR';
 
 export class GetMediaUseCase {
   constructor(
     private readonly mediaRepo: IMediaRepository,
+    private readonly output: UseCaseOutputPort<GetMediaResult>,
     private readonly logger: Logger,
   ) {}
 
   async execute(
     input: GetMediaInput,
-    presenter: IGetMediaPresenter,
-  ): Promise<void> {
-    try {
-      this.logger.info('[GetMediaUseCase] Getting media', {
-        mediaId: input.mediaId,
-      });
+  ): Promise<Result<void, ApplicationErrorCode<GetMediaErrorCode, { message: string }>>> {
+    this.logger.info('[GetMediaUseCase] Getting media', {
+      mediaId: input.mediaId,
+    });
 
+   try {
       const media = await this.mediaRepo.findById(input.mediaId);
 
       if (!media) {
-        presenter.present({
-          success: false,
-          errorMessage: 'Media not found',
+        return Result.err({
+          code: 'MEDIA_NOT_FOUND',
+          details: { message: 'Media not found' },
         });
-        return;
       }
 
-      presenter.present({
-        success: true,
+      this.output.present({
         media: {
           id: media.id,
           filename: media.filename,
@@ -74,15 +69,16 @@ export class GetMediaUseCase {
         },
       });
 
+      return Result.ok(undefined);
     } catch (error) {
-      this.logger.error('[GetMediaUseCase] Error getting media', {
-        error: error instanceof Error ? error.message : 'Unknown error',
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.logger.error('[GetMediaUseCase] Error getting media', err, {
         mediaId: input.mediaId,
       });
 
-      presenter.present({
-        success: false,
-        errorMessage: 'Internal error occurred while retrieving media',
+      return Result.err({
+        code: 'REPOSITORY_ERROR',
+        details: { message: err.message },
       });
     }
   }