HttpClient, interceptors et couche d’API

// v21 : HttpClient est disponible dans root sans aucune configuration
export class UsersApi {
  private readonly http = inject(HttpClient); // fonctionne directement
}

// vous n’appelez provideHttpClient() que pour le CONFIGURER
export const appConfig: ApplicationConfig = {
  providers: [
    provideHttpClient(
      withInterceptors([authInterceptor, errorInterceptor]),
      // withXhr(),   // v22 : Fetch est la valeur par défaut ; XHR seulement si vous avez besoin de la progression d’un upload
    ),
  ],
};

// Interceptor fonctionnel : une fonction (req, next) => Observable
export const authInterceptor: HttpInterceptorFn = (req, next) => {
  const token = inject(AuthStore).token();
  if (!token || !req.url.startsWith('/api')) return next(req);
  return next(req.clone({ setHeaders: { Authorization: `Bearer ${token}` } }));
};

export const loadingInterceptor: HttpInterceptorFn = (req, next) => {
  if (req.context.get(SKIP_LOADING)) return next(req);     // métadonnées par requête
  const loading = inject(LoadingStore);
  loading.start();
  return next(req).pipe(finalize(() => loading.stop()));
};

export const errorInterceptor: HttpInterceptorFn = (req, next) => {
  // inject() uniquement ici, de façon synchrone : dans catchError on n’est plus dans un contexte d’injection
  const router = inject(Router);
  return next(req).pipe(
    catchError((err: HttpErrorResponse) => {
      if (err.status === 401) router.navigate(['/login']);
      return throwError(() => err);
    }),
  );
};

// Ne réessaie que les erreurs serveur (5xx), deux fois, avec une pause
export const retryInterceptor: HttpInterceptorFn = (req, next) => {
  if (req.method !== 'GET') return next(req); // ne jamais répéter un POST automatiquement
  return next(req).pipe(
    retry({
      count: 2,
      delay: (error: HttpErrorResponse) =>
        error.status >= 500 ? timer(300) : throwError(() => error),
    }),
  );
};

// dans un service, pas une variable de module : côté serveur, elle serait partagée par tous
@Service()
export class ResponseCache {
  private readonly entries = new Map<string, HttpResponse<unknown>>();
  get(key: string) {
    return this.entries.get(key);
  }
  set(key: string, response: HttpResponse<unknown>) {
    this.entries.set(key, response);
  }
}

// Garde les réponses GET ; sur un hit, le reste de la chaîne ne s’exécute pas du tout
export const cacheInterceptor: HttpInterceptorFn = (req, next) => {
  if (req.method !== 'GET') return next(req);
  const cache = inject(ResponseCache);
  const hit = cache.get(req.urlWithParams);
  if (hit) return of(hit.clone());
  return next(req).pipe(
    tap((event) => {
      if (event instanceof HttpResponse) cache.set(req.urlWithParams, event);
    }),
  );
};

// data-access/products-api.ts — URL, DTO et mapping au même endroit
@Service()
export class ProductsApi {
  private readonly http = inject(HttpClient);

  list(q = ''): Observable<Product[]> {
    return this.http
      .get<PageDto<ProductDto>>('/api/products', { params: { q } })
      .pipe(map((page) => page.items.map(toProduct)));
  }

  get(id: number): Observable<Product> {
    return this.http.get<ProductDto>(`/api/products/${id}`).pipe(
      map(toProduct),
      retry({ count: 2, delay: (_, attempt) => timer(300 * attempt) }), // backoff
    );
  }

  create(body: CreateProductRequest): Observable<Product> {
    return this.http.post<ProductDto>('/api/products', body).pipe(map(toProduct));
  }
}

// LECTURE réactive → httpResource (dans un composant ou un store)
readonly product = httpResource(() => `/api/products/${this.id()}`, { parse: toProduct });

// ÉCRITURE → HttpClient (une commande, pas un état)
async save() {
  const saved = await firstValueFrom(this.api.create(this.form().value()));
  this.router.navigate(['/products', saved.id]);
}

// v22 : FetchBackend est la valeur par défaut (withFetch() est déprécié — vous pouvez le retirer)
provideHttpClient(); // utilise fetch()

// Progression d’upload ? Fetch ne la gère pas → XHR explicite
provideHttpClient(withXhr());
this.http.post('/api/upload', file, { reportUploadProgress: true, observe: 'events' });
// reportProgress est déprécié → reportUploadProgress / reportDownloadProgress

// v22.1 : JSONP est déprécié (HttpClient.jsonp, HttpClientJsonpModule)