. 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');

AUTHOR

Alex Bespoyasov

How to Use fetch with TypeScript

 in TypeScript is a way to make your code more abstract and reusable. 

Let's say you want to create a function that returns a first element from a given list:

function head(list) {
  return list[0];
}

How to type it? We cannot know beforehand list of what type will be given. 

 to enumerate every possible type we accept:

function head(list: string[]): string
function head(list: number[]): number
function head(list: boolean[]): boolean {
  return list[0];
}

type Entity = string | number | boolean;

function head(list: Entity[]): Entity {
  return list[0];
}

...But all of those ways have a common issue. If we want to pass, for example, an object, we have to define it in the type manually. This isn't convenient, and TypeScript has a better way to do it.

Generic type is a type that accepts arguments and uses them in some way. In the case of our 

function head<TEntity>(list: TEntity[]): TEntity {
  return list[0]
}

. This parameter is used by TypeScript compiler to define the 

 type later. So, when we use this function like this:

We don't have to manually define a type now, since TypeScript will automatically defer it from the argument.

 for you if pass an array of elements with different types.

With generics, you can describe custom types and interfaces in more abstract way. 

Let's say you want to create a type-alias for array and call it 

. You would use this type somehow like this:

With TypeScript, you can define a generic type for this:

You can read it as a ”type-function“. It 

Same with interfaces. You can define an interface with type-parameters to set a type which this interface can work with:

// First, define an interface that accepts
// a TEvent type-parameter:
interface EventHandler<TEvent> {
  
  // Then, pass this parameter as a type of
  // `event` argument of `handle` method:
  handle(event: TEvent): void
}

// When typing a `clickHandler`, 
// define the `TEvent` to be the `MouseEvent` type
const clickHandler: EventHandler<MouseEvent> = {
  
  // The `e` argument will be automatically
  // assigned with `MouseEvent` type.
  handler(e) {}
}

Most of the time generic types and interfaces are used to define type-constraints.

You can also set constraints for your generic types to make sure it is used properly.

. Then, you can specify those types as a 

interface EventHandler<
  // `extends` keyword set a constraint on type-parameter.
  // With this extension `EventHandler` cannot
  // be used with any other type 
  // except for `MouseEvent` or `KeyboardEvent`.
  TEvent extends MouseEvent | KeyboardEvent
> {
  handle(event: TEvent): void
}

You can even define a constraint based on a type-parameter!

 function, that returns the value of a property in an object:

function select(object, key) {
  return object[key];
}

You don't know beforehand what type of object will be passed to this function. However, you can set a constraint on 

 argument to ensure selecting only from existing properties on the 

function select<
  // `TObject` parameter is required as a reference later:
  TObject, 
  // `TKey` refers to keys of `TObject`: 
  TKey extends keyof TObject
>(object: TObject, key: TKey) {
  return object[key];
}

When you use this function with an object:

const example = {
  username: 'Alex',
  age: 26
}

// ...The second argument will accept 
// only `username` and `age`
// because the `example` object 
// has only these 2 keys.
select(example, 'username');

This is also useful when coding in IDE with auto-completion because it will allow you to select a seconds argument:

Imagine you need to convert some type in a way to make every field optional. 

type SomeType = {
  key1: number;
  key2: string;
}

// Convert it to => 

type OptionalType = {
  key1?: number;
  key2?: number;
}

. Utility types are generic types that perform some transformation on a given type-parameters.

 makes every key in a given object optional.

There are many other useful utility types 

described in the TypeScript documentation

Learn

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

Teach

Amelia Wattenberger

Author of Fullstack D3

Community

Tutorials on Generics

How to Use fetch with TypeScript

How to Use Generics in TypeScript

This has been a really good investment!

Advance your career with newline Pro.

Email Newsletter

Popular Topics

Masterclasses

Tutorials

Fullstack React with TypeScript