Is it possible to retrieve all mandatory attributes of a TypeScript object?

Question

Is it possible to retrieve all mandatory attributes of a TypeScript object?

Is there a method or approach available that can retrieve all necessary properties from a TypeScript interface or an object? For instance, something along the lines of

Object.getOwnPropertyDescriptors(myObject)

or keyof T, but with the specific details on whether a property is required or optional.

typescript reflection

Answer 1

Answer №1

During runtime, it is impossible to determine the required or optional properties of an object in TypeScript as this information is erased by the time the code executes. Although you can include your own runtime details using decorators, modifying the actual code that generates classes and objects is necessary. Therefore, retrieving a list of required property names from an object or constructor at runtime is unattainable.

However, at design time, it is feasible to extract the mandatory and optional keys of a type as a subtype of keyof T. This approach utilizes conditional types and leverages the fact that an empty object type {} is assignable to a weak type (a type with no obligatory properties). For example:

type RequiredKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? never : K }[keyof T];
type OptionalKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? K : never }[keyof T];

Here is an illustration of how to use it:

interface SomeType {
  required: string;
  optional?: number;
  requiredButPossiblyUndefined: boolean | undefined;
}

type SomeTypeRequiredKeys = RequiredKeys<SomeType>; 
// type SomeTypeRequiredKeys = "required" | "requiredButPossiblyUndefined" 🙂

type SomeTypeOptionalKeys = OptionalKeys<SomeType>; 
// type SomeTypeOptionalKeys = "optional" 🙂

Note that this method may not work effectively with types containing index signatures:

interface SomeType {
  required: string;
  optional?: number;
  requiredButPossiblyUndefined: boolean | undefined;
  [k: string]: unknown; // index signature
} 

type SomeTypeRequiredKeys = RequiredKeys<SomeType>;
// type SomeTypeRequiredKeys = never 🙁

type SomeTypeOptionalKeys = OptionalKeys<SomeType>;
// type SomeTypeOptionalKeys = string 🙁

If you require handling indexable types, a more intricate solution involves extracting known literal keys first and then identifying the required and optional properties:

(EDIT: The following was updated to address changes in TS4.3, see ms/TS#44143)

type RequiredLiteralKeys<T> = keyof { [K in keyof T as string extends K ? never : number extends K ? never :
    {} extends Pick<T, K> ? never : K]: 0 }

type OptionalLiteralKeys<T> = keyof { [K in keyof T as string extends K ? never : number extends K ? never :
    {} extends Pick<T, K> ? K : never]: 0 }

type IndexKeys<T> = string extends keyof T ? string : number extends keyof T ? number : never;

This results in:

type SomeTypeRequiredKeys = RequiredLiteralKeys<SomeType>;
// type SomeTypeRequiredKeys = "required" | "requiredButPossiblyUndefined" 🙂

type SomeTypeOptionalKeys = OptionalLiteralKeys<SomeType>; 
// type SomeTypeOptionalKeys = "optional" 🙂

type SomeTypeIndexKeys = IndexKeys<SomeType>;
// type SomeTypeIndexKeys = string 🙂

Answer 2

During runtime, it is impossible to determine the required or optional properties of an object in TypeScript as this information is erased by the time the code executes. Although you can include your own runtime details using decorators, modifying the actual code that generates classes and objects is necessary. Therefore, retrieving a list of required property names from an object or constructor at runtime is unattainable.

However, at design time, it is feasible to extract the mandatory and optional keys of a type as a subtype of keyof T. This approach utilizes conditional types and leverages the fact that an empty object type {} is assignable to a weak type (a type with no obligatory properties). For example:

type RequiredKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? never : K }[keyof T];
type OptionalKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? K : never }[keyof T];

Here is an illustration of how to use it:

interface SomeType {
  required: string;
  optional?: number;
  requiredButPossiblyUndefined: boolean | undefined;
}

type SomeTypeRequiredKeys = RequiredKeys<SomeType>; 
// type SomeTypeRequiredKeys = "required" | "requiredButPossiblyUndefined" 🙂

type SomeTypeOptionalKeys = OptionalKeys<SomeType>; 
// type SomeTypeOptionalKeys = "optional" 🙂

Note that this method may not work effectively with types containing index signatures:

interface SomeType {
  required: string;
  optional?: number;
  requiredButPossiblyUndefined: boolean | undefined;
  [k: string]: unknown; // index signature
} 

type SomeTypeRequiredKeys = RequiredKeys<SomeType>;
// type SomeTypeRequiredKeys = never 🙁

type SomeTypeOptionalKeys = OptionalKeys<SomeType>;
// type SomeTypeOptionalKeys = string 🙁

If you require handling indexable types, a more intricate solution involves extracting known literal keys first and then identifying the required and optional properties:

(EDIT: The following was updated to address changes in TS4.3, see ms/TS#44143)

type RequiredLiteralKeys<T> = keyof { [K in keyof T as string extends K ? never : number extends K ? never :
    {} extends Pick<T, K> ? never : K]: 0 }

type OptionalLiteralKeys<T> = keyof { [K in keyof T as string extends K ? never : number extends K ? never :
    {} extends Pick<T, K> ? K : never]: 0 }

type IndexKeys<T> = string extends keyof T ? string : number extends keyof T ? number : never;

This results in:

type SomeTypeRequiredKeys = RequiredLiteralKeys<SomeType>;
// type SomeTypeRequiredKeys = "required" | "requiredButPossiblyUndefined" 🙂

type SomeTypeOptionalKeys = OptionalLiteralKeys<SomeType>; 
// type SomeTypeOptionalKeys = "optional" 🙂

type SomeTypeIndexKeys = IndexKeys<SomeType>;
// type SomeTypeIndexKeys = string 🙂

Answer 3

Answer №2

For those still seeking a solution in the year 2022, I found success with the following approach:

export type GetOptionalKeys<T> = {[K in keyof T as (undefined extends T[K] ? K : never)]: T[K]}

export type GetRequiredKeys<T> = {[K in keyof T as (undefined extends T[K] ? never : K)]: T[K]}

Check out this resource: https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#key-remapping-via-as

Answer 4

For those still seeking a solution in the year 2022, I found success with the following approach:

export type GetOptionalKeys<T> = {[K in keyof T as (undefined extends T[K] ? K : never)]: T[K]}

export type GetRequiredKeys<T> = {[K in keyof T as (undefined extends T[K] ? never : K)]: T[K]}

Check out this resource: https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#key-remapping-via-as

Answer 5

Answer №3

Below is the proposed solution:

type _OptionalKeys<A extends object, B extends object> = {
  [K in KnownKeys<A> & KnownKeys<B>]: Pick<A, K> extends Pick<B, K> ? never : K
};

/**
 * The function OptionalKeys retrieves optional keys from a type `T`.
 * For example, `{ a: string; b: string | undefined; c?: string }` => `'c'`.
 */
export type OptionalKeys<T extends object> = _OptionalKeys<
  T,
  Required<T>
>[KnownKeys<T>];

In essence, we are identifying OptionalKeys to later extract the RequiredKeys.

/**
 * RequiredKeys retrieves required keys from a type `T`.
 * For example, `{ a: string; b: string | undefined; c?: string }` => `'b' | 'c'`.
 */
export type RequiredKeys<T extends object> = Exclude<
  KnownKeys<T>,
  OptionalKeys<T>
>;

Now, what exactly does KnownKeys signify?

/**
 * Extracts the keys of a union type
 */
// tslint:disable-next-line:no-any
export type KeysOfUnion<T> = T extends any ? keyof T : never;

/**
 * Retrieves known keys from an object – irrespective of having an index signature.
 */
export type KnownKeys<T extends object> = {
  [K in keyof T]: string extends K ? never : number extends K ? never : K
} extends { [_ in keyof T]: infer U }
  ? {} extends U
    ? never
    : U
  : never;

Additionally, you could reverse the process by initially identifying RequiredKeys, then determining OptionalKeys, simply by altering

Pick<A, K> extends Pick<B, K>

to

Pick<B, K> extends Pick<A, K>

within _OptionalKeys and renaming it to _RequiredKeys.

This solution (originally created for my rbx package) can be applied on both union types and singleton types with ease.

Answer 6

Below is the proposed solution:

type _OptionalKeys<A extends object, B extends object> = {
  [K in KnownKeys<A> & KnownKeys<B>]: Pick<A, K> extends Pick<B, K> ? never : K
};

/**
 * The function OptionalKeys retrieves optional keys from a type `T`.
 * For example, `{ a: string; b: string | undefined; c?: string }` => `'c'`.
 */
export type OptionalKeys<T extends object> = _OptionalKeys<
  T,
  Required<T>
>[KnownKeys<T>];

In essence, we are identifying OptionalKeys to later extract the RequiredKeys.

/**
 * RequiredKeys retrieves required keys from a type `T`.
 * For example, `{ a: string; b: string | undefined; c?: string }` => `'b' | 'c'`.
 */
export type RequiredKeys<T extends object> = Exclude<
  KnownKeys<T>,
  OptionalKeys<T>
>;

Now, what exactly does KnownKeys signify?

/**
 * Extracts the keys of a union type
 */
// tslint:disable-next-line:no-any
export type KeysOfUnion<T> = T extends any ? keyof T : never;

/**
 * Retrieves known keys from an object – irrespective of having an index signature.
 */
export type KnownKeys<T extends object> = {
  [K in keyof T]: string extends K ? never : number extends K ? never : K
} extends { [_ in keyof T]: infer U }
  ? {} extends U
    ? never
    : U
  : never;

Additionally, you could reverse the process by initially identifying RequiredKeys, then determining OptionalKeys, simply by altering

Pick<A, K> extends Pick<B, K>

to

Pick<B, K> extends Pick<A, K>

within _OptionalKeys and renaming it to _RequiredKeys.

This solution (originally created for my rbx package) can be applied on both union types and singleton types with ease.

Answer 7

Answer №4

This method proved to be effective for me

type MandatoryProps<T> = {
    [K in keyof T as string extends K ? never : number extends K ? never : {} extends Pick<T, K> ? never : K]: T[K]
  }

interface Person {
    id: string;
    name: string;
    age?: string;
    height?: number;
    hobbies: string[];
}

type Result = MandatoryProps<Person>

Answer 8

This method proved to be effective for me

type MandatoryProps<T> = {
    [K in keyof T as string extends K ? never : number extends K ? never : {} extends Pick<T, K> ? never : K]: T[K]
  }

interface Person {
    id: string;
    name: string;
    age?: string;
    height?: number;
    hobbies: string[];
}

type Result = MandatoryProps<Person>

Is it possible to retrieve all mandatory attributes of a TypeScript object?

Answer №1

Answer №2

Answer №3

Answer №4

Similar questions

Generating images with HTML canvas only occurs once before stopping

Gain insights on Stripe Webhooks with Firebase Functions and Node.js

Trustpilot: The function window.Trustpilot.loadFromElement does not exist in Safari

Next.js Version 13 - Unable to find solution for 'supports-color' conflict

The use of findDOMNode has been marked as outdated in StrictMode. Specifically, findDOMNode was utilized with an instance of Transition (generated by MUI Backdrop) that is contained

The ng-model used within an *ngFor loop is not displaying the correct value

Exploring the functionality of angular reactive forms in creating intricate JSON structures

Subscription Code Incrementally Triggering Upon Each Component Load

What is the best way to add items to arrays with matching titles?

Sidenav Angular Material cdkScrollable is an effective tool for creating scrollable

What is the best way to transform an Observable array containing objects into an Observable that emits the data contained within those objects?

Generating a random number to be input into the angular 2 form group index can be done by following these

What is the correct way to utilize Global Variables in programming?

Uh-oh! Angular 6 has encountered an unexpected error with template parsing

How should JSON files stored on the server side be properly utilized in Next.js?

Filtering an array dynamically in Typescript depending on the entered value

Running pre-commit eslint autofix but encountering errors that do not exist

Implementing Angular 2 - Steps to ensure a service is accessible within the app module

Retrieving specific properties from a JSON object and logging them

Creating adaptable Object Properties using Zod