Couche Application

@Singleton
@RequiredArgsConstructor
@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
public class GetTrendsUseCase {
 
    TrendRepository trendRepository;
    Logger logger;
 
    /**
     * Récupère les tendances pour un mot-clé et une région.
     *
     * @param keyword Le mot-clé recherché
     * @param region Le code région (ex: "US", "FR")
     * @return Le résultat des tendances
     * @throws TrendNotFoundException Si aucune tendance n'est trouvée
     */
    public TrendResult execute(String keyword, String region) {
        logger.info("Getting trends for keyword={}, region={}", keyword, region);
 
        // Créer l'objet domain (validation incluse)
        TrendQuery query = new TrendQuery(keyword, region);
 
        // Appeler le port de sortie
        TrendResult result = trendRepository.getTrends(query)
            .orElseThrow(() -> new TrendNotFoundException(keyword, region));
 
        logger.info("Found trend with score={}", result.getInterestScore());
 
        return result;
    }
}

@Controller("/api/trends")
@RequiredArgsConstructor
@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
public class TrendController {
 
    GetTrendsUseCase getTrendsUseCase;
    Logger logger;
 
    @Get
    public TrendResponseDto getTrends(
        @QueryValue @NotBlank String keyword,
        @QueryValue(defaultValue = "US") String region
    ) {
        logger.info("GET /api/trends?keyword={}&region={}", keyword, region);
 
        // Appeler le use case (objets domain)
        TrendResult result = getTrendsUseCase.execute(keyword, region);
 
        // Convertir Domain → DTO
        return TrendResponseDto.fromDomain(result);
    }
 
    @Get("/popular")
    public List<TrendResponseDto> getPopularTrends() {
        // Logique pour récupérer les tendances populaires
        List<TrendResult> results = // ... use case
 
        return results.stream()
            .map(TrendResponseDto::fromDomain)
            .collect(Collectors.toList());
    }
}

@Controller("/api/users")
public class UserController {
 
    private final GetUserUseCase getUserUseCase;
 
    @Get("/{id}")
    public UserResponseDto getUser(Long id) {
        try {
            User user = getUserUseCase.execute(id);
            return UserResponseDto.fromDomain(user);
        } catch (UserNotFoundException e) {
            throw new HttpStatusException(
                HttpStatus.NOT_FOUND,
                "User not found: " + id
            );
        }
    }
}

@Data
public class CreateUserRequestDto {
    @NotBlank
    private String name;
 
    @Email
    private String email;
 
    @NotNull
    private Integer age;
}

@Data
public class TrendResponseDto {
    private String keyword;
    private String region;
    private Integer interestScore;
    private String popularityLevel;
    private LocalDateTime queriedAt;
 
    /**
     * Convertit une entité domain en DTO.
     */
    public static TrendResponseDto fromDomain(TrendResult result) {
        TrendResponseDto dto = new TrendResponseDto();
        dto.setKeyword(result.getKeyword());
        dto.setRegion(result.getRegion());
        dto.setInterestScore(result.getInterestScore());
        dto.setPopularityLevel(result.getPopularityLevel());  // Règle métier
        dto.setQueriedAt(result.getQueriedAt());
        return dto;
    }
}

@Singleton
@RequiredArgsConstructor
public class CreateOrderUseCase {
 
    private final UserRepository userRepository;
    private final ProductRepository productRepository;
    private final OrderRepository orderRepository;
    private final EmailService emailService;
    private final PaymentService paymentService;
 
    @Transactional
    public Order execute(CreateOrderCommand command) {
        // 1. Récupérer l'utilisateur
        User user = userRepository.findById(command.getUserId())
            .orElseThrow(() -> new UserNotFoundException(command.getUserId()));
 
        // 2. Vérifier les produits
        List<Product> products = command.getProductIds().stream()
            .map(id -> productRepository.findById(id)
                .orElseThrow(() -> new ProductNotFoundException(id)))
            .collect(Collectors.toList());
 
        // 3. Créer la commande (logique métier dans le domain)
        Order order = Order.create(user, products);
        order.validate();
 
        // 4. Traiter le paiement
        Payment payment = paymentService.processPayment(
            order.getTotalAmount(),
            command.getPaymentMethod()
        );
 
        if (!payment.isSuccessful()) {
            throw new PaymentFailedException();
        }
 
        // 5. Sauvegarder la commande
        Order savedOrder = orderRepository.save(order);
 
        // 6. Envoyer confirmation email
        emailService.sendOrderConfirmation(user.getEmail(), savedOrder);
 
        return savedOrder;
    }
}

// ✅ BON : Use cases spécifiques
GetTrendsUseCase
CreateUserUseCase
UpdateUserUseCase
DeleteUserUseCase
 
// ❌ MAUVAIS : Use case fourre-tout
UserService  // Trop générique

// ✅ BON : Verbe d'action
GetTrendsUseCase
CreateOrderUseCase
SendEmailUseCase
 
// ❌ MAUVAIS : Nom vague
TrendUseCase
OrderManager

@Test
void shouldGetTrendsWhenKeywordExists() {
    // ARRANGE
    TrendRepository mockRepo = mock(TrendRepository.class);
    TrendResult mockResult = TrendResult.builder()
        .keyword("java")
        .interestScore(85)
        .build();
 
    when(mockRepo.getTrends(any())).thenReturn(Optional.of(mockResult));
 
    GetTrendsUseCase useCase = new GetTrendsUseCase(mockRepo);
 
    // ACT
    TrendResult result = useCase.execute("java", "US");
 
    // ASSERT
    assertThat(result.getKeyword()).isEqualTo("java");
    assertThat(result.getInterestScore()).isEqualTo(85);
}