A backend request object, that allows you to abstract away the generic request logic around the specific calls.

request.ts

/**
  This code is licensed under the terms of the MIT license
*/

export class ResponseError extends Error {
  public code!: number;
}

export const request = async <T>(
  path: string,
  options: RequestInit & { params?: Record<string, any> } = {
    headers: new Headers(),
  },
  retry: number = 0,
  _retry_initial_count: number = 0 // @info: Internal use only - Used to count the number of retries
): Promise<T> => {
  const isAbsolute = /^(?:[a-z+]+:)?\/\//i.test(path);
  let url = `${!isAbsolute ? BASE_SERVER_URL : ''}${path}`;

  // Extract params from options
  const { params, ...fetchOptions } = options;
  const method = fetchOptions.method?.toUpperCase() || 'GET';

  if (method === 'GET' && params && Object.keys(params).length) {
    const queryString = new URLSearchParams(params).toString();
    url += `?${queryString}`;
  } else if (params && Object.keys(params).length) {
    fetchOptions.body = JSON.stringify(params);
    fetchOptions.headers = new Headers(fetchOptions.headers);
    fetchOptions.headers.set('Content-Type', 'application/json');
  }

  console.debug(path, fetchOptions, {
    params,
    isAbsolute,
    url,
    retry,
    _retry_initial_count,
  });

  return await fetch(url, fetchOptions).then(async (response) => {
    if (!response.ok) {
      if (retry > 0) {
        return request(
          path,
          { ...fetchOptions, params },
          retry - 1,
          _retry_initial_count || retry
        );
      }
      const json = await response.json();
      const error = new ResponseError(
        json?.error || response.statusText || 'network request failed'
      );
      error.code = response.status;
      throw error;
    }

    const contentType = response.headers.get('content-type');
    if (contentType?.includes('application/json')) {
      const json = await response.json();
      if (json.error) throw new Error(json.error);
      return json;
    }

    return response.text() as unknown as T;
  });
};

usage_example.ts

import { request } from './request';

export const fetchInit = async (
  user_id: string
): Promise<UserInitResponse> => {
  return request(`/init`, {
    method: 'POST',
    params: {
      user_id
    },
  });
};

fetchInit('aBc1234DeF').then((responseData) => {
  console.log({responseData});
})