Combining TypeScript utility types

#typescript #javascript #beginners

By now, we had a basic introduction to some of the utility types of TypeScript.

However, the real power unleashes when you combine them.

When we used the partial and required types, you might have noticed that they have one downside: they affect all properties.

By combining them with pick and omit, we can ensure only specific fields are affected.

Let's take a look at how this would work.

Disclaimer: This article is for TypeScript beginners. We have not yet covered Generics, so nothing will use generics in this article.

Making specific fields required

Let's take the following example interface:

interface User {
  id?: number;
  firstname: string;
  lastname: string;
  age?: number;
}

What if we want to make just the id required but leave the age optional?

Depending on our end use-case, we have two options here.

First, let's say all other fields can be optional, but the id must be set.

We can choose to make a new type combining Partial and Required.

It will looks like this:

type LoggedUser = Partial<User> & Required<Pick<User, 'id'>>;

What we say here is:

Take the user interface and make everything optional (Partial)
Include a required type, but Pick only the id field to make required
Assign this combination to the LoggedUser type.

We end up with a type with three optional fields: firstname, lastname and age and one required field: id.

But, in some cases, this is not exactly what we wanted, as we don't want the first and last name to be optional.
We could, of course, include them in the required statement, but that would defeat the purpose.

In that case we can write the following type:

type LoggedUser = Required<Pick<User, 'id'>> & Omit<User, 'id'>;

What this one does:

Require the id field by picking it from the user
Include the remaining user interface, but omit the id field
Assign this combination to the LoggedUser type

We have three required fields in this scenario: firstname, lastname, and id. And one optional field, the age.

As you can see, using a combination of utility types is really where they shine.
You can make crazy combinations, and once we dive into generics, we can turn these into re-usable types!