refactor use cases

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

@@ -8,10 +8,11 @@ import { v4 as uuidv4 } from 'uuid';
 import type { IAvatarGenerationRepository } from '../../domain/repositories/IAvatarGenerationRepository';
 import type { FaceValidationPort } from '../ports/FaceValidationPort';
 import type { AvatarGenerationPort } from '../ports/AvatarGenerationPort';
-import type { Logger } from '@core/shared/application';
+import type { Logger, UseCaseOutputPort } from '@core/shared/application';
 import { AvatarGenerationRequest } from '../../domain/entities/AvatarGenerationRequest';
-import type { IRequestAvatarGenerationPresenter } from '../presenters/IRequestAvatarGenerationPresenter';
 import type { RacingSuitColor } from '../../domain/types/AvatarGenerationRequest';
+import { Result } from '@core/shared/application/Result';
+import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
 
 export interface RequestAvatarGenerationInput {
   userId: string;
@@ -20,63 +21,68 @@ export interface RequestAvatarGenerationInput {
   style?: 'realistic' | 'cartoon' | 'pixel-art';
 }
 
+export interface RequestAvatarGenerationResult {
+  requestId: string;
+  status: 'validating' | 'generating' | 'completed';
+  avatarUrls?: string[];
+}
+
+export type RequestAvatarGenerationErrorCode =
+  | 'FACE_VALIDATION_FAILED'
+  | 'GENERATION_FAILED'
+  | 'REPOSITORY_ERROR';
+
+export type RequestAvatarGenerationApplicationError = ApplicationErrorCode<
+  RequestAvatarGenerationErrorCode,
+  { message: string }
+>;
+
 export class RequestAvatarGenerationUseCase {
   constructor(
     private readonly avatarRepo: IAvatarGenerationRepository,
     private readonly faceValidation: FaceValidationPort,
     private readonly avatarGeneration: AvatarGenerationPort,
+    private readonly output: UseCaseOutputPort<RequestAvatarGenerationResult>,
     private readonly logger: Logger,
   ) {}
 
   async execute(
     input: RequestAvatarGenerationInput,
-    presenter: IRequestAvatarGenerationPresenter,
-  ): Promise<void> {
-    try {
-      this.logger.info('[RequestAvatarGenerationUseCase] Starting avatar generation request', {
-        userId: input.userId,
-        suitColor: input.suitColor,
-      });
+  ): Promise<Result<void, RequestAvatarGenerationApplicationError>> {
+    this.logger.info('[RequestAvatarGenerationUseCase] Starting avatar generation request', {
+      userId: input.userId,
+      suitColor: input.suitColor,
+    });
 
-      // Create the avatar generation request entity
+    try {
       const requestId = uuidv4();
       const request = AvatarGenerationRequest.create({
         id: requestId,
         userId: input.userId,
-        facePhotoUrl: input.facePhotoData, // Assuming facePhotoData is a URL or base64
+        facePhotoUrl: input.facePhotoData,
         suitColor: input.suitColor,
         style: input.style,
       });
 
-      // Save initial request
       await this.avatarRepo.save(request);
 
-      // Present initial status
-      presenter.present({
-        requestId,
-        status: 'validating',
-      });
-
-      // Validate face photo
       request.markAsValidating();
       await this.avatarRepo.save(request);
 
       const validationResult = await this.faceValidation.validateFacePhoto(input.facePhotoData);
 
       if (!validationResult.isValid || !validationResult.hasFace || validationResult.faceCount !== 1) {
-        const errorMessage = validationResult.errorMessage || 'Invalid face photo: must contain exactly one face';
+        const errorMessage =
+          validationResult.errorMessage || 'Invalid face photo: must contain exactly one face';
         request.fail(errorMessage);
         await this.avatarRepo.save(request);
 
-        presenter.present({
-          requestId,
-          status: 'failed',
-          errorMessage,
+        return Result.err({
+          code: 'FACE_VALIDATION_FAILED',
+          details: { message: errorMessage },
         });
-        return;
       }
 
-      // Generate avatars
       request.markAsGenerating();
       await this.avatarRepo.save(request);
 
@@ -85,7 +91,7 @@ export class RequestAvatarGenerationUseCase {
         prompt: request.buildPrompt(),
         suitColor: input.suitColor,
         style: input.style || 'realistic',
-        count: 3, // Generate 3 avatar options
+        count: 3,
       };
 
       const generationResult = await this.avatarGeneration.generateAvatars(generationOptions);
@@ -95,20 +101,17 @@ export class RequestAvatarGenerationUseCase {
         request.fail(errorMessage);
         await this.avatarRepo.save(request);
 
-        presenter.present({
-          requestId,
-          status: 'failed',
-          errorMessage,
+        return Result.err({
+          code: 'GENERATION_FAILED',
+          details: { message: errorMessage },
         });
-        return;
       }
 
-      // Complete the request
       const avatarUrls = generationResult.avatars.map(avatar => avatar.url);
       request.completeWithAvatars(avatarUrls);
       await this.avatarRepo.save(request);
 
-      presenter.present({
+      this.output.present({
         requestId,
         status: 'completed',
         avatarUrls,
@@ -120,16 +123,17 @@ export class RequestAvatarGenerationUseCase {
         avatarCount: avatarUrls.length,
       });
 
+      return Result.ok(undefined);
     } catch (error) {
-      this.logger.error('[RequestAvatarGenerationUseCase] Error during avatar generation', {
-        error: error instanceof Error ? error.message : 'Unknown error',
+      const err = error instanceof Error ? error : new Error(String(error));
+
+      this.logger.error('[RequestAvatarGenerationUseCase] Error during avatar generation', err, {
         userId: input.userId,
       });
 
-      presenter.present({
-        requestId: uuidv4(), // Fallback ID
-        status: 'failed',
-        errorMessage: 'Internal error occurred during avatar generation',
+      return Result.err({
+        code: 'REPOSITORY_ERROR',
+        details: { message: err.message ?? 'Internal error occurred during avatar generation' },
       });
     }
   }