Guide d’Implémentation des Adapters

┌─────────────────┐
│   Use Case      │
│  (Application)  │
└────────┬────────┘
         │ utilise
         ▼
┌─────────────────┐
│ TrendRepository │ ← Port de sortie (interface)
│    (Domain)     │
└────────▲────────┘
         │ implements
┌────────┴────────┐
│  Mock Adapter   │ ← Adapter (implémentation)
│(Infrastructure) │
└─────────────────┘

@Singleton
@Requires(property = "app.trend-source", value = "mock")
public class MockTrendRepositoryAdapter implements TrendRepository {
    @Override
    public Optional<TrendResult> getTrends(TrendQuery query) {
        return Optional.of(generateMockData(query));
    }
}

@Singleton
@Requires(property = "app.trend-source", value = "google-api")
public class GoogleTrendsApiAdapter implements TrendRepository {
    @Inject
    @Client(id = "google-trends")
    HttpClient httpClient;
 
    @Override
    public Optional<TrendResult> getTrends(TrendQuery query) {
        GoogleApiDto dto = httpClient.toBlocking()
            .retrieve("/trends?q=" + query.keyword(), GoogleApiDto.class);
 
        return Optional.of(toDomain(dto));
    }
}

@Singleton
public class DatabaseTrendAdapter implements TrendRepository {
    @Inject
    TrendEntityRepository jpaRepository;
 
    @Override
    public Optional<TrendResult> getTrends(TrendQuery query) {
        return jpaRepository.findByKeywordAndRegion(
            query.keyword(),
            query.region()
        ).map(this::toDomain);
    }
}

@Singleton
public class FileTrendAdapter implements TrendRepository {
    private final ObjectMapper objectMapper;
    private final Path filePath = Paths.get("data/trends.json");
 
    @Override
    public Optional<TrendResult> getTrends(TrendQuery query) {
        TrendFileDto[] trends = objectMapper.readValue(
            filePath.toFile(),
            TrendFileDto[].class
        );
 
        return Arrays.stream(trends)
            .filter(t -> t.keyword.equals(query.keyword()))
            .map(this::toDomain)
            .findFirst();
    }
}

// infrastructure/dto/GoogleApiDto.java
@Data
public class GoogleApiDto {
    private String keyword;
    private Integer score;
 
    // ❌ MAUVAIS : Le DTO dépendrait du Domain !
    public TrendResult toDomain() {
        return new TrendResult(keyword, score);
    }
}

// infrastructure/adapter/GoogleTrendsApiAdapter.java
@Singleton
public class GoogleTrendsApiAdapter implements TrendRepository {
 
    @Override
    public Optional<TrendResult> getTrends(TrendQuery query) {
        GoogleApiDto dto = httpClient.retrieve(...);
 
        // ✅ BON : L'adapter fait la traduction
        return Optional.of(toDomain(dto));
    }
 
    private TrendResult toDomain(GoogleApiDto dto) {
        return TrendResult.builder()
                .keyword(dto.getKeyword())
                .interestScore(dto.getScore())
                .build();
    }
}

// DTO (structure de l'API)
@Data
public class CountryApiDto {
    @JsonProperty("translations")
    private Map<String, TranslationDto> translations;
}
 
// Adapter : Conversion Map → List
private List<Translation> convertTranslations(
    Map<String, TranslationDto> translationsMap
) {
    if (translationsMap == null) {
        return List.of();
    }
 
    return translationsMap.entrySet().stream()
            .map(entry -> new Translation(
                entry.getKey(),              // languageCode
                entry.getValue().getCommon(),
                entry.getValue().getOfficial()
            ))
            .collect(Collectors.toList());
}

// Entity (BDD)
@Entity
public class SessionEntity {
    @Column(columnDefinition = "TEXT")
    private String metadataJson;  // JSON brut
}
 
// Adapter : Conversion String → Map
private Map<String, Object> deserializeMetadata(String json) {
    try {
        return objectMapper.readValue(
            json,
            new TypeReference<Map<String, Object>>() {}
        );
    } catch (Exception e) {
        log.warn("Failed to deserialize metadata", e);
        return Map.of();
    }
}

// DTO
@Data
public class CountryApiDto {
    private NameDto name;
 
    @Data
    public static class NameDto {
        private String common;
        private String official;
    }
}
 
// Adapter : Conversion objet imbriqué
private Country toDomain(CountryApiDto dto) {
    Name name = new Name(
        dto.getName().getCommon(),
        dto.getName().getOfficial()
    );
 
    return new Country(name, translations);
}

@Override
public Optional<TrendResult> getTrends(TrendQuery query) {
    try {
        GoogleApiDto dto = httpClient.toBlocking()
                .retrieve(request, GoogleApiDto.class);
 
        return Optional.of(toDomain(dto));
 
    } catch (HttpClientResponseException e) {
        if (e.getStatus().getCode() == 404) {
            log.info("No trends found for keyword: {}", query.keyword());
        } else {
            log.error("API error ({}): {}", e.getStatus(), e.getMessage());
        }
        return Optional.empty();
 
    } catch (Exception e) {
        log.error("Unexpected error calling API", e);
        return Optional.empty();
    }
}

@Override
public Optional<TrendResult> getTrends(TrendQuery query) {
    Optional<TrendEntity> entityOpt = repository.findByKeywordAndRegion(
        query.keyword(),
        query.region()
    );
 
    // Pas de try-catch nécessaire si pas de données = cas normal
    return entityOpt.map(this::toDomain);
}

@Override
public Optional<TrendResult> getTrends(TrendQuery query) {
    try {
        GoogleApiDto dto = httpClient.toBlocking()
                .retrieve(request, GoogleApiDto.class);
 
        if (dto.getInterestData() == null) {
            throw new InvalidApiResponseException(
                "API returned null interest data"
            );
        }
 
        return Optional.of(toDomain(dto));
 
    } catch (InvalidApiResponseException e) {
        log.error("Invalid API response: {}", e.getMessage());
        throw e;  // Propager l'erreur métier
 
    } catch (Exception e) {
        log.error("Technical error", e);
        return Optional.empty();
    }
}

// Mock (dev)
@Singleton
@Requires(property = "app.trend-source", value = "mock")
public class MockTrendRepositoryAdapter implements TrendRepository { }
 
// API (prod)
@Singleton
@Requires(property = "app.trend-source", value = "google-api")
public class GoogleTrendsApiAdapter implements TrendRepository { }
 
// BDD (analyse)
@Singleton
@Requires(property = "app.trend-source", value = "database")
public class DatabaseTrendAdapter implements TrendRepository { }

# application-dev.yml
app:
  trend-source: mock
 
# application-prod.yml
app:
  trend-source: google-api

@Singleton
@Primary  // ← Adapter principal utilisé partout
public class CachedTrendRepositoryAdapter implements TrendRepository {
 
    private final TrendRepository delegate;
    private final Map<String, TrendResult> cache = new ConcurrentHashMap<>();
 
    public CachedTrendRepositoryAdapter(
            @Named("google-api") TrendRepository delegate
    ) {
        this.delegate = delegate;
    }
 
    @Override
    public Optional<TrendResult> getTrends(TrendQuery query) {
        String cacheKey = query.keyword() + "_" + query.region();
 
        // 1. Check cache
        if (cache.containsKey(cacheKey)) {
            log.info("Cache hit for: {}", cacheKey);
            return Optional.of(cache.get(cacheKey));
        }
 
        // 2. Sinon, appeler le delegate
        Optional<TrendResult> result = delegate.getTrends(query);
 
        // 3. Mettre en cache
        result.ifPresent(r -> cache.put(cacheKey, r));
 
        return result;
    }
}

@Singleton
@Primary  // ← Celui-ci sera injecté par défaut
public class GoogleTrendsApiAdapter implements TrendRepository { }
 
@Singleton
@Named("mock")  // ← Accessible via @Named("mock")
public class MockTrendRepositoryAdapter implements TrendRepository { }

@Singleton
public class GetTrendsUseCase {
    private final TrendRepository trendRepository;  // ← Google injecté
 
    private final TrendRepository mockRepository;   // ← Mock injecté
 
    public GetTrendsUseCase(
        TrendRepository trendRepository,
        @Named("mock") TrendRepository mockRepository
    ) {
        this.trendRepository = trendRepository;
        this.mockRepository = mockRepository;
    }
}

// ✅ BON : Suffixe "Adapter"
MockTrendRepositoryAdapter.java
GoogleTrendsApiAdapter.java
DatabaseTrendAdapter.java
FileTrendAdapter.java
CachedTrendRepositoryAdapter.java

// ❌ MAUVAIS
TrendRepositoryImpl.java  // Trop générique
TrendService.java  // Confus (service ou adapter ?)
GoogleTrends.java  // Pas clair que c'est un adapter