chore(app): replace httpClient with http and refactor UserService for reusability

- Standardize `HttpClient` injection across services by renaming `httpClient` to `http`.
- Refactor `UserService` to introduce `extractUser` and `createCacheContext` helper methods.

Author: Ismaestro

src/app/core/services/storage/file.service.ts

@@ -6,9 +6,9 @@ import type { Observable } from 'rxjs';
   providedIn: 'root',
 })
 export class FileService {
-  private readonly httpClient = inject(HttpClient);
+  private readonly http = inject(HttpClient);
 
   getFileAsText(fileUrl: string): Observable<string> {
-    return this.httpClient.get(fileUrl, { responseType: 'text' });
+    return this.http.get(fileUrl, { responseType: 'text' });
   }
 }

src/app/features/authentication/services/authentication.service.ts

@@ -27,7 +27,7 @@ export const REFRESH_TOKEN_KEY = 'refresh-token';
 })
 export class AuthenticationService {
   private readonly endpoints = getEndpoints();
-  private readonly httpClient = inject(HttpClient);
+  private readonly http = inject(HttpClient);
   private readonly storageService = inject(LOCAL_STORAGE);
   private readonly languageService = inject(LanguageService);
 
@@ -53,7 +53,7 @@ export class AuthenticationService {
     };
 
     return this.handleAuthResponse(
-      this.httpClient.post<RegisterResponse>(this.endpoints.auth.v1.authentication, payload, {
+      this.http.post<RegisterResponse>(this.endpoints.auth.v1.authentication, payload, {
         headers: {
           'Accept-Language': this.languageService.convertLocaleToAcceptLanguage(),
         },
@@ -68,15 +68,15 @@ export class AuthenticationService {
     };
 
     return this.handleAuthResponse(
-      this.httpClient.post<LoginResponse>(this.endpoints.auth.v1.login, payload),
+      this.http.post<LoginResponse>(this.endpoints.auth.v1.login, payload),
     ).pipe(map((data) => data.user));
   }
 
   refreshToken(): Observable<RefreshTokenResponseData> {
     const refreshToken = this.storageService?.getItem(REFRESH_TOKEN_KEY);
 
     return this.handleAuthResponse(
-      this.httpClient.post<RefreshTokenResponse>(this.endpoints.auth.v1.refreshToken, {
+      this.http.post<RefreshTokenResponse>(this.endpoints.auth.v1.refreshToken, {
         refreshToken,
       }),
     );

src/app/features/authentication/services/user.service.ts

@@ -4,53 +4,47 @@ import type { Observable } from 'rxjs';
 import { map } from 'rxjs';
 import { CACHING_ENABLED } from '~core/interceptors/caching.interceptor';
 import type { GetMeResponse } from '~features/authentication/types/get-me-response.type';
-import type { User } from '~features/authentication/types/user.type';
 import type { UpdateUserRequest } from '~features/authentication/types/update-user-request.type';
 import type { UpdateUserResponse } from '~features/authentication/types/update-user-response.type';
 import type { CatchPokemonRequest } from '~features/authentication/types/catch-pokemon-request.type';
 import type { CatchPokemonResponse } from '~features/authentication/types/catch-pokemon-response.type';
+import type { User } from '~features/authentication/types/user.type';
 import { getEndpoints } from '~core/constants/endpoints.constants';
 
 @Injectable({
   providedIn: 'root',
 })
 export class UserService {
+  private readonly http = inject(HttpClient);
   private readonly endpoints = getEndpoints();
-  private readonly httpClient = inject(HttpClient);
 
-  getMe(options?: { cache: boolean }): Observable<User> {
-    const { cache = true } = options ?? {};
-    return this.httpClient
+  getMe(options?: { cache?: boolean }): Observable<User> {
+    const cache = options?.cache ?? true;
+
+    return this.http
       .get<GetMeResponse>(this.endpoints.user.v1.user, {
-        context: new HttpContext().set(CACHING_ENABLED, cache),
+        context: this.createCacheContext(cache),
       })
-      .pipe(
-        map((response: GetMeResponse) => {
-          const { data } = response;
-          return data.user;
-        }),
-      );
+      .pipe(this.extractUser());
   }
 
   updateUser(updateUserRequest: UpdateUserRequest): Observable<User> {
-    return this.httpClient
+    return this.http
       .patch<UpdateUserResponse>(this.endpoints.user.v1.user, updateUserRequest)
-      .pipe(
-        map((response: UpdateUserResponse) => {
-          const { data } = response;
-          return data.user;
-        }),
-      );
+      .pipe(this.extractUser());
   }
 
   catchPokemon(catchPokemonRequest: CatchPokemonRequest): Observable<User> {
-    return this.httpClient
+    return this.http
       .post<CatchPokemonResponse>(this.endpoints.user.v1.pokemonCatch, catchPokemonRequest)
-      .pipe(
-        map((response: CatchPokemonResponse) => {
-          const { data } = response;
-          return data.user;
-        }),
-      );
+      .pipe(this.extractUser());
+  }
+
+  private extractUser<T extends { data: { user: User } }>() {
+    return map((response: T) => response.data.user);
+  }
+
+  private createCacheContext(cache: boolean): HttpContext {
+    return new HttpContext().set(CACHING_ENABLED, cache);
   }
 }

src/app/features/pokemon/services/pokemon.service.ts

@@ -13,10 +13,10 @@ import type { LastUpdatedPokemonIdsResponse } from '~features/pokemon/types/last
 })
 export class PokemonService {
   private readonly endpoints = getEndpoints();
-  private readonly httpClient = inject(HttpClient);
+  private readonly http = inject(HttpClient);
 
   getPokemon(pokemonIdOrName: string | number): Observable<Pokemon> {
-    return this.httpClient.get<Pokemon>(this.endpoints.pokemon.v1.pokemon(pokemonIdOrName), {
+    return this.http.get<Pokemon>(this.endpoints.pokemon.v1.pokemon(pokemonIdOrName), {
       params: new HttpParams().set('limit', '1'),
       context: new HttpContext().set(CACHING_ENABLED, true),
     });
@@ -38,13 +38,11 @@ export class PokemonService {
   }
 
   getLastUpdatedPokemonIds(): Observable<string[]> {
-    return this.httpClient
-      .get<LastUpdatedPokemonIdsResponse>(this.endpoints.pokemon.v1.lastUpdated)
-      .pipe(
-        map((response: LastUpdatedPokemonIdsResponse) => {
-          const { data } = response;
-          return data.pokemonIds;
-        }),
-      );
+    return this.http.get<LastUpdatedPokemonIdsResponse>(this.endpoints.pokemon.v1.lastUpdated).pipe(
+      map((response: LastUpdatedPokemonIdsResponse) => {
+        const { data } = response;
+        return data.pokemonIds;
+      }),
+    );
   }
 }