refactor use cases

core/identity/application/use-cases/achievement/CreateAchievementUseCase.test.ts

@@ -1,11 +1,8 @@
 import { describe, it, expect, vi, type Mock } from 'vitest';
 import { CreateAchievementUseCase, type IAchievementRepository } from './CreateAchievementUseCase';
+import type { Logger } from '@core/shared/application';
+import { Result } from '@core/shared/application/Result';
 import { Achievement } from '@core/identity/domain/entities/Achievement';
-import type { Logger, UseCaseOutputPort } from '@core/shared/application';
-
-type CreateAchievementOutput = {
-  achievement: Achievement;
-};
 
 describe('CreateAchievementUseCase', () => {
   let achievementRepository: {
@@ -13,7 +10,6 @@ describe('CreateAchievementUseCase', () => {
     findById: Mock;
   };
   let logger: Logger;
-  let output: UseCaseOutputPort<CreateAchievementOutput> & { present: Mock };
   let useCase: CreateAchievementUseCase;
 
   beforeEach(() => {
@@ -29,46 +25,50 @@ describe('CreateAchievementUseCase', () => {
       error: vi.fn(),
     } as unknown as Logger;
 
-    output = {
-      present: vi.fn(),
-    };
-
     useCase = new CreateAchievementUseCase(
       achievementRepository as unknown as IAchievementRepository,
       logger,
-      output,
     );
   });
 
   it('creates an achievement and persists it', async () => {
     const props = {
-      id: 'achv-1',
-      name: 'First Win',
-      description: 'Awarded for winning your first race',
+      id: 'achievement-1',
+      name: 'First Race',
+      description: 'Complete your first race',
       category: 'driver' as const,
       rarity: 'common' as const,
-      iconUrl: 'https://example.com/icon.png',
-      points: 50,
-      requirements: [
-        {
-          type: 'wins' as const,
-          value: 1,
-          operator: '>=' as const,
-        },
-      ],
+      points: 10,
+      requirements: [{ type: 'races_completed' as const, value: 1, operator: '>=' as const }],
       isSecret: false,
     };
 
-    achievementRepository.save.mockResolvedValue(undefined);
-
     const result = await useCase.execute(props);
 
     expect(result.isOk()).toBe(true);
-    expect(achievementRepository.save).toHaveBeenCalledTimes(1);
-    const savedAchievement = achievementRepository.save.mock.calls?.[0]?.[0];
-    expect(savedAchievement).toBeInstanceOf(Achievement);
-    expect(savedAchievement.id).toBe(props.id);
-    expect(savedAchievement.name).toBe(props.name);
-    expect(output.present).toHaveBeenCalledWith({ achievement: savedAchievement });
+    const createResult = result.unwrap();
+    expect(createResult.achievement).toBeDefined();
+    expect(createResult.achievement.id).toBe(props.id);
+    expect(createResult.achievement.name).toBe(props.name);
+    expect(achievementRepository.save).toHaveBeenCalled();
+  });
+
+  it('returns error when repository save fails', async () => {
+    achievementRepository.save.mockRejectedValue(new Error('Database error'));
+
+    const result = await useCase.execute({
+      id: 'achievement-1',
+      name: 'First Race',
+      description: 'Complete your first race',
+      category: 'driver' as const,
+      rarity: 'common' as const,
+      points: 10,
+      requirements: [{ type: 'races_completed' as const, value: 1, operator: '>=' as const }],
+      isSecret: false,
+    });
+
+    expect(result.isErr()).toBe(true);
+    expect(result.unwrapErr().code).toBe('REPOSITORY_ERROR');
+    expect(logger.error).toHaveBeenCalled();
   });
 });

core/identity/application/use-cases/achievement/CreateAchievementUseCase.ts

@@ -1,7 +1,7 @@
 import { Achievement, AchievementProps } from '@core/identity/domain/entities/Achievement';
 import { Result } from '@core/shared/application/Result';
 import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
-import type { UseCaseOutputPort, Logger } from '@core/shared/application';
+import type { Logger } from '@core/shared/application';
 
 export interface IAchievementRepository {
   save(achievement: Achievement): Promise<void>;
@@ -25,20 +25,18 @@ export class CreateAchievementUseCase {
   constructor(
     private readonly achievementRepository: IAchievementRepository,
     private readonly logger: Logger,
-    private readonly output: UseCaseOutputPort<CreateAchievementResult>,
   ) {}
 
   async execute(input: CreateAchievementInput): Promise<
-    Result<void, CreateAchievementApplicationError>
+    Result<CreateAchievementResult, CreateAchievementApplicationError>
   > {
     try {
       const achievement = Achievement.create(input);
       await this.achievementRepository.save(achievement);
 
       const result: CreateAchievementResult = { achievement };
-      this.output.present(result);
 
-      return Result.ok(undefined);
+      return Result.ok(result);
     } catch (error) {
       const message =
         error instanceof Error && error.message
@@ -57,4 +55,4 @@ export class CreateAchievementUseCase {
       } as CreateAchievementApplicationError);
     }
   }
-}
+}