How to selectively make properties optional in Typescript conditions

Question

How to selectively make properties optional in Typescript conditions

Currently, I am working on creating a utility type to unwrap nested monads of Options in my code. Here is the progress I have made so far:

export interface Option<T> {
  type: symbol;
  isSome(): boolean;
  isNone(): boolean;
  match<U>(fn: Match<T, U>): U;
  map<U>(fn: (val: T) => U): Option<U>;
  andThen<U>(fn: (val: T) => Option<U>): Option<U>;
  or<U>(optb: Option<U>): Option<T | U>;
  and<U>(optb: Option<U>): Option<U>;
  unwrapOr(def: T): T;
  unwrap(): T | never;
}

export type UnwrappedOptionsType<T> = T extends (infer U)[]
  ? UnwrappedOptionsType<U>[]
  : T extends object
  ? {
      [P in keyof T]: T[P] extends Option<infer R>
        ? UnwrappedOptionsType<R> | undefined
        : UnwrappedOptionsType<T[P]>;
    }
  : T;

My expectation is that the types will be inferred correctly and properties that are Options become optional. For example, consider the following type:

type SignUpRequest = {
    username: string;
    password: string;
    email: Option<string>;
}

When using

UnwrappedOptionsType<SignUpRequest>

, expected output should be:

{
    username: string;
    password: string;
    email?: string | undefined;
}

However, the actual result obtained is:

{
    username: string;
    password: string;
    email: string;
}

The type of the option is successfully inferred, but it does not accept undefined. How can I make these options optional?

Edit: Updated code for reproducibility. Also, the requirement is for properties to be explicitly optional, not just possibly undefined.

typescript

Answer 1

Answer №1

Consider the following implementation:

type UnwrapOptions<T> =
    T extends Option<infer U> ? UnwrapOptions<U> | undefined :
    T extends readonly any[] ? {[I in keyof T]: UnwrapOptions<T[I]>} :
    T extends object ? (
        { [K in keyof T as Option<any> extends T[K] ? never : K]: UnwrapOptions<T[K]> } &
        { [K in keyof T as Option<any> extends T[K] ? K : never]?: UnwrapOptions<T[K]> }
    ) extends infer U ? { [K in keyof U]: U[K] } : never :
    T;

This complex structure implements a recursive conditional type logic. It may exhibit unexpected behaviors or limitations due to specific edge cases, so thorough testing is recommended before practical application.

Examining this code further:

If UnwrapOptions<T> is evaluated with T set as...
- ...an Option<U>, the function recursively computes UnwrapOptions<U> (in case of nested Options) and combines it with undefined in a union format.
- ...an array or tuple type, each element goes through an iterative process applying UnwrapOptions.
- ...a primitive type, it directly returns that primitive value.
- ...a non-array object type, properties are separated into assignable and non-assignable types based on Option presence. These are then merged back together through intersections.

To test this functionality, consider the following examples:

type SignUpRequest = {
    username: string;
    password: string;
    email: Option<string>;
}

type UnwrappedSignupRequest = UnwrapOptions<SignUpRequest>;
/* Result:{
    username: string;
    password: string;
    email?: string | undefined;
} */

The expected output for the above scenario matches the intended behavior. Let's expand with a more intricate data structure:

interface Foo {
    a: string;
    b?: number;
    c: string[];
    d: { z?: string };
    e: Option<number>;
    f: Option<string>[];
    g: Option<string> | number;
    h: [1, Option<2>, 3];
    i: { y: Option<string> };
    j: Option<{ x: Option<{ w: string }> }>;
    k: Foo;
}

This results in:

type UnwrappedFoo = UnwrapOptions<Foo>;
/* Output:
    - Properties unwrapped individually
    - Recursive property (k) displayed as 'any' in IntelliSense but maintains its original sub-properties.
*/

Upon inspection, all properties within the complex Foo structure are appropriately handled by the function logic.

Access the TypeScript Playground for hands-on experimentation

Answer 2

Consider the following implementation:

type UnwrapOptions<T> =
    T extends Option<infer U> ? UnwrapOptions<U> | undefined :
    T extends readonly any[] ? {[I in keyof T]: UnwrapOptions<T[I]>} :
    T extends object ? (
        { [K in keyof T as Option<any> extends T[K] ? never : K]: UnwrapOptions<T[K]> } &
        { [K in keyof T as Option<any> extends T[K] ? K : never]?: UnwrapOptions<T[K]> }
    ) extends infer U ? { [K in keyof U]: U[K] } : never :
    T;

This complex structure implements a recursive conditional type logic. It may exhibit unexpected behaviors or limitations due to specific edge cases, so thorough testing is recommended before practical application.

Examining this code further:

If UnwrapOptions<T> is evaluated with T set as...
- ...an Option<U>, the function recursively computes UnwrapOptions<U> (in case of nested Options) and combines it with undefined in a union format.
- ...an array or tuple type, each element goes through an iterative process applying UnwrapOptions.
- ...a primitive type, it directly returns that primitive value.
- ...a non-array object type, properties are separated into assignable and non-assignable types based on Option presence. These are then merged back together through intersections.

To test this functionality, consider the following examples:

type SignUpRequest = {
    username: string;
    password: string;
    email: Option<string>;
}

type UnwrappedSignupRequest = UnwrapOptions<SignUpRequest>;
/* Result:{
    username: string;
    password: string;
    email?: string | undefined;
} */

The expected output for the above scenario matches the intended behavior. Let's expand with a more intricate data structure:

interface Foo {
    a: string;
    b?: number;
    c: string[];
    d: { z?: string };
    e: Option<number>;
    f: Option<string>[];
    g: Option<string> | number;
    h: [1, Option<2>, 3];
    i: { y: Option<string> };
    j: Option<{ x: Option<{ w: string }> }>;
    k: Foo;
}

This results in:

type UnwrappedFoo = UnwrapOptions<Foo>;
/* Output:
    - Properties unwrapped individually
    - Recursive property (k) displayed as 'any' in IntelliSense but maintains its original sub-properties.
*/

Upon inspection, all properties within the complex Foo structure are appropriately handled by the function logic.

Access the TypeScript Playground for hands-on experimentation

Answer 3

Answer №2

In order to make the option optional in your UnwrappedOptionsType type, you'll need to incorporate an additional type guard:

type UnwrappedOptionsType<T> = T extends (infer U)[]
  ? UnwrappedOptionsType<U>[]
  : T extends object
  ? {
      [P in keyof T]: T[P] extends Option<infer R>
        ? (UnwrappedOptionsType<R> | undefined) | undefined
        : UnwrappedOptionsType<T[P]>;
    }
  : T;

By implementing the type guard, the UnwrappedOptionsType for the SignUpRequest type will be as follows:

type UnwrappedOptionsType<SignUpRequest> = {
    username: string;
    password: string;
    email?: (string | undefined) | undefined;
}

This will result in the following output:

{
    username: string;
    password: string;
    email?: string | undefined;
}

Does this align with what you are aiming for?

Answer 4

In order to make the option optional in your UnwrappedOptionsType type, you'll need to incorporate an additional type guard:

type UnwrappedOptionsType<T> = T extends (infer U)[]
  ? UnwrappedOptionsType<U>[]
  : T extends object
  ? {
      [P in keyof T]: T[P] extends Option<infer R>
        ? (UnwrappedOptionsType<R> | undefined) | undefined
        : UnwrappedOptionsType<T[P]>;
    }
  : T;

By implementing the type guard, the UnwrappedOptionsType for the SignUpRequest type will be as follows:

type UnwrappedOptionsType<SignUpRequest> = {
    username: string;
    password: string;
    email?: (string | undefined) | undefined;
}

This will result in the following output:

{
    username: string;
    password: string;
    email?: string | undefined;
}

Does this align with what you are aiming for?

How to selectively make properties optional in Typescript conditions

Answer №1

Answer №2

Similar questions

Having trouble with the "Vs Code nx console generate" command? It seems that there are no flags available to configure

Proper method for typing the generics of DatePickerProps belonging to the DatePicker component in mui-x library

Am I on track with this observation?

Can the arrow function properly subscribe to an Observable in Angular and what is the accurate way to interpret it?

Database records failing to update after deployment

How can TypeScript be used to enable CSV or PDF export in a material-react-table?

When the user clicks on a specific element, ensure that it is the main focus and generate an overlay

Do type declaration files for NPM packages have to be in the .d.ts format?

Encountering a problem with the 'string' parameter when using TypeScript

Ensuring a precise data type in a class or object using TypeScript

Conditional type/interface attribute typing

Display Module within Component using Angular 5

Struggling to implement the Pick utility type alongside the React useState hook

What steps are needed to generate an RSS feed from an Angular application?

Converting JSON Arrays into Typescript Arrays

NGRX 8 reducer now outputting an Object rather than an Array

Serious issue: a dependency request is an expression (Warning from Angular CLI)

What is the most efficient way to retrieve a single type from a union that consists of either a single type or an array of types

Exploring the world of chained JavaScript Promises for automatic pagination of an API

Whenever comparing the types 'string[]' and 'DeliveryTypeEnum', this condition will consistently result in 'true' as there is no intersection between the two. This is highlighted by the error code ts(2367)