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

Using Flickity API in Vue 3 with Typescript Integration

The Type X is lacking essential properties found in Type Y, including length, pop, push, concat, and an additional 26 more properties. Code: [2740]

How to only disable checkboxes that are currently checked in Angular 8

Error: The property 'target' cannot be read

Creative Solution for Implementing a Type Parameter in a Generic

A guide on transforming a 1-dimensional array into a 2-dimensional matrix layout using Angular

The HTML table is displaying with an offset, which is probably caused by the *ngFor directive

Designations for removing an item at a targeted subdirectory location

I am puzzled by this error in Typescript: "Why does the element have an 'any' type when the Object type lacks an index signature?"

What is the best way to enable external access to a class component method in React and Typescript?

Can an Angular Component be displayed using a Serverless function like Lambda on AWS?

Issue connecting database with error when combining TypeORM with Next.js

Vuejs fails to properly transmit data

Ways to eliminate the white background gap between pages on ionic

Exporting Typescript to Javascript files

Unable to export Interface in Typescript - the specific module does not offer an export named Settings

Misunderstanding the concept of always being right

Troubleshooting Next.js Route Redirect Failure to Origin URL

Utilizing the output of one function as an input parameter for another function: A guide

Show JSON information in an angular-data-table