refactor: simplify function signatures and improve default values in HttpClient and helpers

Author: Breimerct

src/client/http-client.ts

@@ -20,62 +20,76 @@ import {
 export class HttpClient {
   private config: HttpClientConfig;
   private interceptors: Interceptors;
-
-  constructor(config: HttpClientConfig = {}) {
+  private initValues: HttpClientConfig = {
+    baseURL: '',
+    headers: {},
+    params: {},
+    timeout: 30000,
+    interceptors: {
+      request: [],
+      response: [],
+    },
+  };
+
+  constructor(config: HttpClientConfig = this.initValues) {
     this.config = config;
     this.interceptors = {
       request: config.interceptors?.request || [],
       response: config.interceptors?.response || [],
     };
   }
 
-  setBaseURL(baseURL: string): HttpClient {
+  setBaseURL(baseURL: string) {
     this.config.baseURL = baseURL;
     return this;
   }
 
-  setHeaders(headers: HttpHeaders): HttpClient {
+  setHeaders(headers: HttpHeaders) {
     this.config.headers = mergeHeaders(this.config.headers, headers);
     return this;
   }
 
-  setHeader(key: keyof HttpHeaders, value: string): HttpClient {
+  setHeader(key: keyof HttpHeaders, value: string) {
     if (!this.config.headers) {
       this.config.headers = {};
     }
     this.config.headers[key] = value;
     return this;
   }
 
-  setParams(params: QueryParams): HttpClient {
+  setParams(params: QueryParams) {
     this.config.params = mergeParams(this.config.params, params);
     return this;
   }
 
-  setParam(key: string, value: string | number | boolean): HttpClient {
+  setParam(key: string, value: string | number | boolean) {
     if (!this.config.params) {
       this.config.params = {};
     }
     this.config.params[key] = value;
     return this;
   }
 
-  setTimeout(timeout: number): HttpClient {
+  setTimeout(timeout: number) {
     this.config.timeout = timeout;
     return this;
   }
 
-  addRequestInterceptor(interceptor: RequestInterceptor): HttpClient {
+  get getConfig() {
+    return this.config;
+  }
+
+  addRequestInterceptor(interceptor: RequestInterceptor) {
     this.interceptors.request.push(interceptor);
     return this;
   }
 
-  addResponseInterceptor(interceptor: ResponseInterceptor): HttpClient {
+  addResponseInterceptor(interceptor: ResponseInterceptor) {
     this.interceptors.response.push(interceptor);
     return this;
   }
 
-  private async applyRequestInterceptors(config: RequestConfig): Promise<RequestConfig> {
+  private async applyRequestInterceptors(config: RequestConfig) {
     let processedConfig = config;
 
     for (const interceptor of this.interceptors.request) {
@@ -85,7 +99,7 @@ export class HttpClient {
     return processedConfig;
   }
 
-  private async applyResponseInterceptors<T>(response: HttpResponse<T>): Promise<HttpResponse<T>> {
+  private async applyResponseInterceptors<T>(response: HttpResponse<T>) {
     let processedResponse = response;
 
     for (const interceptor of this.interceptors.response) {
@@ -95,13 +109,13 @@ export class HttpClient {
     return processedResponse;
   }
 
-  private async makeRequest<T = any>(config: RequestConfig): Promise<HttpResponse<T>> {
+  private async makeRequest<T = any>(config: RequestConfig) {
     try {
       const mergedConfig: RequestConfig = {
         ...config,
         headers: mergeHeaders(this.config.headers, config.headers),
         params: mergeParams(this.config.params, config.params),
-        timeout: config.timeout || this.config.timeout || 30000,
+        timeout: config.timeout || this.config.timeout || this.initValues.timeout,
       };
 
       const processedConfig = await this.applyRequestInterceptors(mergedConfig);
@@ -167,22 +181,15 @@ export class HttpClient {
     }
   }
 
-  async get<T = any>(
-    url: string,
-    config?: Partial<Omit<RequestConfig, 'method'>>,
-  ): Promise<HttpResponse<T>> {
+  async get<T = any>(url: string, config?: Partial<Omit<RequestConfig, 'method'>>) {
     return this.makeRequest<T>({
       url,
       method: 'GET',
       ...config,
     });
   }
 
-  async post<T = any>(
-    url: string,
-    body?: any,
-    config?: Partial<Omit<RequestConfig, 'method'>>,
-  ): Promise<HttpResponse<T>> {
+  async post<T = any>(url: string, body?: any, config?: Partial<Omit<RequestConfig, 'method'>>) {
     return this.makeRequest<T>({
       url,
       method: 'POST',
@@ -191,11 +198,7 @@ export class HttpClient {
     });
   }
 
-  async put<T = any>(
-    url: string,
-    body?: any,
-    config?: Partial<Omit<RequestConfig, 'method'>>,
-  ): Promise<HttpResponse<T>> {
+  async put<T = any>(url: string, body?: any, config?: Partial<Omit<RequestConfig, 'method'>>) {
     return this.makeRequest<T>({
       url,
       method: 'PUT',
@@ -204,22 +207,15 @@ export class HttpClient {
     });
   }
 
-  async delete<T = any>(
-    url: string,
-    config?: Partial<Omit<RequestConfig, 'method'>>,
-  ): Promise<HttpResponse<T>> {
+  async delete<T = any>(url: string, config?: Partial<Omit<RequestConfig, 'method'>>) {
     return this.makeRequest<T>({
       url,
       method: 'DELETE',
       ...config,
     });
   }
 
-  async patch<T = any>(
-    url: string,
-    body?: any,
-    config?: Partial<Omit<RequestConfig, 'method'>>,
-  ): Promise<HttpResponse<T>> {
+  async patch<T = any>(url: string, body?: any, config?: Partial<Omit<RequestConfig, 'method'>>) {
     return this.makeRequest<T>({
       url,
       method: 'PATCH',
@@ -228,21 +224,15 @@ export class HttpClient {
     });
   }
 
-  async head<T = any>(
-    url: string,
-    config?: Partial<Omit<RequestConfig, 'method'>>,
-  ): Promise<HttpResponse<T>> {
+  async head<T = any>(url: string, config?: Partial<Omit<RequestConfig, 'method'>>) {
     return this.makeRequest<T>({
       url,
       method: 'HEAD',
       ...config,
     });
   }
 
-  async options<T = any>(
-    url: string,
-    config?: Partial<Omit<RequestConfig, 'method'>>,
-  ): Promise<HttpResponse<T>> {
+  async options<T = any>(url: string, config?: Partial<Omit<RequestConfig, 'method'>>) {
     return this.makeRequest<T>({
       url,
       method: 'OPTIONS',
@@ -253,8 +243,4 @@ export class HttpClient {
   async request<T = any>(config: RequestConfig): Promise<HttpResponse<T>> {
     return this.makeRequest<T>(config);
   }
-
-  getConfig(): HttpClientConfig {
-    return this.config;
-  }
 }

src/helpers/get-fetch.ts

@@ -1,4 +1,4 @@
-function isNodeEnvironment(): boolean {
+function isNodeEnvironment() {
   return (
     typeof process !== 'undefined' && process.versions != null && process.versions.node != null
   );

src/helpers/utils.ts

@@ -1,7 +1,7 @@
 import { HttpCode } from '../constants';
 import { HttpError, HttpHeaders, QueryParams } from '../types';
 
-export function buildURL(baseURL: string = '', endpoint: string, params?: QueryParams): string {
+export function buildURL(baseURL: string = '', endpoint: string, params?: QueryParams) {
   const cleanBaseURL = baseURL.replace(/\/$/, '');
   const cleanEndpoint = endpoint.replace(/^\//, '');
   let fullURL = cleanBaseURL ? `${cleanBaseURL}/${cleanEndpoint}` : cleanEndpoint;
@@ -20,25 +20,29 @@ export function buildURL(baseURL: string = '', endpoint: string, params?: QueryP
   return fullURL;
 }
 
-export function mergeHeaders(...headerObjects: (HttpHeaders | undefined)[]): HttpHeaders {
-  return headerObjects.reduce<HttpHeaders>((merged, headers) => {
-    if (headers) {
-      return { ...merged, ...headers };
-    }
-    return merged;
-  }, {} as HttpHeaders);
+export function mergeHeaders(...headerObjects: (HttpHeaders | undefined)[]) {
+  return (
+    headerObjects.reduce<HttpHeaders>((merged, headers) => {
+      if (headers) {
+        return { ...merged, ...headers };
+      }
+      return merged;
+    }, {} as HttpHeaders) || {}
+  );
 }
 
-export function mergeParams(...paramObjects: (QueryParams | undefined)[]): QueryParams {
-  return paramObjects.reduce<QueryParams>((merged, params) => {
-    if (params) {
-      return { ...merged, ...params };
-    }
-    return merged;
-  }, {} as QueryParams);
+export function mergeParams(...paramObjects: (QueryParams | undefined)[]) {
+  return (
+    paramObjects.reduce<QueryParams>((merged, params) => {
+      if (params) {
+        return { ...merged, ...params };
+      }
+      return merged;
+    }, {} as QueryParams) || {}
+  );
 }
 
-export function createTimeoutSignal(timeoutMs: number): AbortSignal {
+export function createTimeoutSignal(timeoutMs: number) {
   if (typeof AbortSignal !== 'undefined' && AbortSignal.timeout) {
     return AbortSignal.timeout(timeoutMs);
   }
@@ -48,13 +52,15 @@ export function createTimeoutSignal(timeoutMs: number): AbortSignal {
   return controller.signal;
 }
 
-export function createHttpError(error: any, status: number = 0): HttpError {
+export function createHttpError(error: any, status: number = 0) {
   const message = error?.message || error?.toString() || 'Unknown error';
   const code = HttpCode[status] || 'UNKNOWN_ERROR';
 
-  return {
+  const payload: HttpError = {
     message,
     status,
     code,
   };
+
+  return payload;
 }