. This makes it harder to type response data without writing additional wrappers.

type User = {
  name: string;
  age: number;
}

// This won't work.
fetch<User>('/api/user/42').then(user => {
  
  // `user` will be of `unknown` type.
})

We can create a wrapper-module to avoid this problem.

// Make the `request` function generic
// to specify the return data type:
function request<TResponse>(
  url: string,
  // `RequestInit` is a type for configuring 
  // a `fetch` request. By default, an empty object.
  config: RequestInit = {}
   
// This function is async, it will return a Promise:
): Promise<TResponse> {
    
  // Inside, we call the `fetch` function with 
  // a URL and config given:
  return fetch(url, config)
    // When got a response call a `json` method on it
    .then((response) => response.json())
    // and return the result data.
    .then((data) => data as TResponse);
    
    // We also can use some post-response
    // data-transformations in the last `then` clause.
}


Now we can call this function as we would call 

request<User>('/api/users/42').then(user => {
  // Now, however, a `user` variable has the `User` type.
})

const user = await request<User>('/api/users/42');

 function doesn't handle errors. To solve that we have 2 options:

There are no obligatory rules for this but 

 tells us not to mix those concerns in a single function.

However, we will take a look at both ways. The first one is to handle errors inside of the 

function request<TResponse>(
  url: string, 
  config: RequestInit
): Promise<TResponse> {
  return fetch(url, config)
    .then(response => response.json())
    .then(data => data)
    .catch(error => {
      // Handle the error.
    })
}

 to handle unresolved promises. There is a catch though (no pun intended).

The first issue we can solve making the function 

async function request<TResponse>(
  url: string, 
  config: RequestInit
): Promise<TResponse> {
  try {
    const response = await fetch(url, config);
    return await response.json();
  }
  catch (error) {
    // Handle the error.
  }
}

However, this doesn't solve the second issue with not knowing how to handle the error. We can handle some basic network errors (Page Not Found, Bad Request) but we cannot handle any business-logic errors.

 approach, we can handle errors outside of the 

async function request<TResponse>(
  url: string, 
  config: RequestInit
): Promise<TResponse> {
  const response = await fetch(url, config);
  return await response.json();
}

// Handling errors outside:
(async () => {
  try {
    const user = await request<User>('/api/users/42');
  }
  catch (error) {
    // Handle any error happened.
  }
})()

We can also pre-define some basic request-methods, like 

const api = {
  get: <TResponse>(url: string) => 
  	request<TResponse>(url),
  
  // Using `extends` to set a type constraint:
  post: <TBody extends BodyInit, TResponse>(url: string, body: TBody) => 
  	request<TResponse>(url, { method: 'POST', body }),
}

const user = await api.get<User>('/api/users/42');

Learn

The newline Guide to Building Your First GraphQL Server with Node and TypeScript

Teach

Amelia Wattenberger

Author of Fullstack D3

Community

Tutorials on Error Handling

How to Use fetch with TypeScript

Email Newsletter

Popular Topics

Masterclasses

Tutorials

Fullstack React with TypeScript