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

Exploring Vue 3.3: Understanding Generics and Dynamic Properties

Tips for preserving @typedef during the TypeScript to JavaScript transpilation process

updating rows in a table

trouble with file paths in deno

Using a form template to bind radio buttons and automatically populate fields based on the selected radio button

Generating an instance of a class by using the class name as a string

Error: Exceeded Maximum Re-Renders. React has set a limit on the number of renders to avoid infinite loops. Issue found in the Toggle Component of Next.js

Does the routing in Angular 2 get disrupted by parameter breaks in sub-modules?

Dynamic importing fails to locate file without .js extension

Tips for utilizing an object key containing a dash ("-") within it

Angular2 - adding the authentication token to request headers

Discovering the ReturnType in Typescript when applied to functions within functions

React modal not closing when clicking outside the modal in Bootstrap

Cross-origin resource sharing (CORS) seems to be creating a barrier for the communication between my Angular

What is the best way to assign JSON values to my class property?

Declaration in Typescript for an array of strings that will be returned as a

Eliminating the parent property name from the validation message of a nested object

What could cause a member variable to be uninitialized in the ngInit method in Ionic/Angular, even though it was initially set in the constructor

Return true for cucumber datatable in typescript without fail

The length of video files created by MediaRecorder is not retained