What is the way to create a `Partial<T>` specifically for nullable fields?

Question

What is the way to create a `Partial<T>` specifically for nullable fields?

I have a requirement for a custom Partial<T> type that can transform nullable fields into optional ones. Currently, I am focusing on typing our ORM, which converts undefined values to null for nullable fields.

In particular, I want to modify a type like this:

interface User {
  email: string
  name: string | null
}

To look like this:

interface User {
  email: string
  name?: string | null
}

I attempted to create the following type:

type NullablePartial<T> = { [P in keyof T]: T[P] extends null ? T[P] | undefined : T[P] }

However, using extends null did not function as intended for creating a union with null and other types (I want it to work with more than just strings). Also, distinguishing between optional fields and undefined values is crucial to me.

Any suggestions on how to proceed?

typescript

Answer 1

Answer №1

Transforming a type function to make only certain properties optional or non-optional can be a bit tricky in TypeScript, as there is no straightforward way to accomplish this. One method that can be used is leveraging multiple mapped types along with an intersection. A solution that should work, assuming the type passed in does not have an index signature, is as follows:

type NullablePartial<
  T,
  NK extends keyof T = { [K in keyof T]: null extends T[K] ? K : never }[keyof T],
  NP = Partial<Pick<T, NK>> & Pick<T, Exclude<keyof T, NK>>
> = { [K in keyof NP]: NP[K] }

It's important to note the use of Pick and Exclude to segment T into nullable and non-nullable properties, applying different operations to each before combining them back together with an intersection. The process of determining nullable properties involves checking if null extends T[K] (i.e., "can null be assigned to this property"), rather than the reverse.

Additionally, generic parameter defaults are utilized to streamline the type manipulation process (thus determining the nullable property key names only once as NP) and to enhance the final output type aesthetically.

Let's test it out with an example:

interface User {
  email: string
  name: string | null
}

type NPUser = NullablePartial<User>;
// type NPUser = {
//  name?: string | null | undefined;
//  email: string;
// }

This output seems sensible. Does it align with your needs? Best of luck!

Answer 2

Transforming a type function to make only certain properties optional or non-optional can be a bit tricky in TypeScript, as there is no straightforward way to accomplish this. One method that can be used is leveraging multiple mapped types along with an intersection. A solution that should work, assuming the type passed in does not have an index signature, is as follows:

type NullablePartial<
  T,
  NK extends keyof T = { [K in keyof T]: null extends T[K] ? K : never }[keyof T],
  NP = Partial<Pick<T, NK>> & Pick<T, Exclude<keyof T, NK>>
> = { [K in keyof NP]: NP[K] }

It's important to note the use of Pick and Exclude to segment T into nullable and non-nullable properties, applying different operations to each before combining them back together with an intersection. The process of determining nullable properties involves checking if null extends T[K] (i.e., "can null be assigned to this property"), rather than the reverse.

Additionally, generic parameter defaults are utilized to streamline the type manipulation process (thus determining the nullable property key names only once as NP) and to enhance the final output type aesthetically.

Let's test it out with an example:

interface User {
  email: string
  name: string | null
}

type NPUser = NullablePartial<User>;
// type NPUser = {
//  name?: string | null | undefined;
//  email: string;
// }

This output seems sensible. Does it align with your needs? Best of luck!

Answer 3

Answer №2

First, let's identify the properties that can be null.

type NullablePropertyOf<T> = {
  [K in keyof T]: null extends T[K]
    ? K
    : never
}[keyof T]

Next, we must alter the nullable properties while keeping the others unchanged. To exclude the non-nullable properties during this process, we will use the well-known Omit utility.

type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;

The final outcome involves combining the weak, partial version of the complete T with the properties that should remain unaltered.

type NullablePartial<T> = Partial<T> & Omit<T, NullablePropertyOf<T>>;

There are various approaches to achieve this. In this instance, I am making everything optional and marking what's necessary. Alternatively, you could start by selecting the non-nullable fields first, making the nullable ones optional, and then merging both types. Choose the method that best fits your requirements.

Answer 4

First, let's identify the properties that can be null.

type NullablePropertyOf<T> = {
  [K in keyof T]: null extends T[K]
    ? K
    : never
}[keyof T]

Next, we must alter the nullable properties while keeping the others unchanged. To exclude the non-nullable properties during this process, we will use the well-known Omit utility.

type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;

The final outcome involves combining the weak, partial version of the complete T with the properties that should remain unaltered.

type NullablePartial<T> = Partial<T> & Omit<T, NullablePropertyOf<T>>;

There are various approaches to achieve this. In this instance, I am making everything optional and marking what's necessary. Alternatively, you could start by selecting the non-nullable fields first, making the nullable ones optional, and then merging both types. Choose the method that best fits your requirements.

Answer 5

Answer №3

Modifying slightly the existing Partial.

Original Partial:

type Partial<T> = { [P in keyof T]?: T[P] };

Edited NullablePartial:

type NullablePartial<T> = { [P in keyof T]?: T[P] | null };

Answer 6

Modifying slightly the existing Partial.

Original Partial:

type Partial<T> = { [P in keyof T]?: T[P] };

Edited NullablePartial:

type NullablePartial<T> = { [P in keyof T]?: T[P] | null };

Answer 7

Answer №4

It seems unclear to me what sets this apart from utilizing optional interface properties in that scenario.

For example:

export interface example {
   item1?: string;    // can be null
   item2: string;
   item3: boolean;
   item4?: boolean;   // can be null
}

Do you see any issues with using this approach instead?

Answer 8

It seems unclear to me what sets this apart from utilizing optional interface properties in that scenario.

For example:

export interface example {
   item1?: string;    // can be null
   item2: string;
   item3: boolean;
   item4?: boolean;   // can be null
}

Do you see any issues with using this approach instead?

Answer 9

Answer №5

Unsure if this is what you're looking for, but I have found a way to include both undefined and null in an interface.

type NullablePartial<T> = {
  [K in keyof T]?: T[keyof T] extends null
    ? null
    : T[K];
};

Answer 10

Unsure if this is what you're looking for, but I have found a way to include both undefined and null in an interface.

type NullablePartial<T> = {
  [K in keyof T]?: T[keyof T] extends null
    ? null
    : T[K];
};

What is the way to create a `Partial<T>` specifically for nullable fields?

Answer №1

Answer №2

Answer №3

Answer №4

Answer №5

Similar questions

Generating exports while utilizing the UseReducer hook method for a React application

Enum-centric type guard

What is TS's method of interpreting the intersection between types that have the same named function properties but different signatures (resulting in an error when done

Error message "Property 'name' does not exist on type '{}'" is encountered when using Ionic/Angular HttpClient and no data type is specified

I am interested in utilizing the request-reply pattern with KafkaJS in a TypeScript environment. Could you provide guidance on how to successfully implement this?

Retrieve the time zone setting from either my browser or server, and then incorporate it into angular2-highcharts

Typescript Code Coverage with karma-jasmine and istanbul: A complete guide

Required attributes not found for data type in TypeScript

There is no such property - Axios and TypeScript

Error is being thrown due to defining a variable after it has already been declared and

Utilize Angular's Reactive Form feature to track changes in Form Control instances within a Form Array and calculate the total value dynamically

A guide to validating a pair of fields within a single object using React hooks and the Yup library

Make sure to name your Typescript component selector correctly, as it should not

Create a const assertion to combine all keys from an object into a union type

Is it possible to determine the specific type of props being passed from a parent element in TypeScript?

Best practices for handling HTTP requests in Angular 5

JavaScript - Imported function yields varied outcome from module

Angular 6 - execute function on either click event OR focus event

Strict type inference for the number data type in TypeScript

Mastering the application of map, filter, and other functions in Angular using Observables