Issue with TypeScript: Difficulty accessing keys in a recursive manner

Question

Issue with TypeScript: Difficulty accessing keys in a recursive manner

I've created a custom type that eliminates any nullish values when working with objects.

export type ExcludeNullish<T> = Exclude<T, null | undefined>;
export type ExcludeNullishKeys<T> = {
    [K in keyof T]-?: T[K] extends boolean | string | number | symbol ? ExcludeNullish<T[K]> : ExcludeNullishKeys<T[K]>;
};

However, I encountered an issue while trying to access a nested key using TypeScript:

export type CustomObj = ExcludeNullishKeys<{
    parentKey: {
        childKey?: {
            data: 'not available';
        } | null;
    } | null;
}>;
export type AccessingNestedObject = CustomObj['parentKey']['childKey'];

The error message states:

Property 'childKey' does not exist on type 'ExcludeNullishKeys<{ childKey?: { data: "not available"; } | null | undefined; } | null>'.

It seems like the compiler is treating the resulting type as ExcludeNullishKeys rather than recognizing it as an object without any nullish values. Any insights on this behavior?

typescript

Answer 1

Answer №1

By implementing a supporting type to expand the type of RandomObj, it becomes evident that there are flaws in your approach within the OmitNullishKeys function. The resulting type of RandomObj still includes values that could potentially be null.

type ExpandType<T> = T extends object
  ? T extends infer O ? { [K in keyof O]: ExpandType<O[K]> } : never
  : T;

type ExpandedRandomObj = ExpandType<RandomObj>;
/*
type ExpandedRandomObj = {
    stackOverflow: {
        forums: {
            thread1: 'not available';
        } | null;
    } | null;
}
*/

TS playground

Answer 2

By implementing a supporting type to expand the type of RandomObj, it becomes evident that there are flaws in your approach within the OmitNullishKeys function. The resulting type of RandomObj still includes values that could potentially be null.

type ExpandType<T> = T extends object
  ? T extends infer O ? { [K in keyof O]: ExpandType<O[K]> } : never
  : T;

type ExpandedRandomObj = ExpandType<RandomObj>;
/*
type ExpandedRandomObj = {
    stackOverflow: {
        forums: {
            thread1: 'not available';
        } | null;
    } | null;
}
*/

TS playground

Answer 3

Answer №2

The issue was initially resolved by:

export type N = null | undefined;
export type OmitNullish<T> = T extends (infer U)[] ? Exclude<U, N>[] : Exclude<U,N>
export type OmitNullishKeys<T> = {
  [key in keyof Required<T>]-?: T extends Record<string, unknown> ? OmitNullish<OmitNullishKeys<T[K]>> : OmitNullish<T[K]>
}

This action effectively resolved the issue

The exclusion of nullish values was not being applied to objects due to the absence of OmitNullish
Using keyof without specifying non-optionality resulted in a value of T | undefined. The use of Required ensures that the key is treated as mandatory.

although it did enforce the non-nullish rules for classes like Date.

By implementing an alternative solution presented by @jcalz and adding a conditional statement to prevent class overwrites, we obtain

type OmitNullish<T, E = Date> = T extends E ? T : NonNullable<{ 
  [key in keyof T]-?: OmitNullish<T[K]>
}>

this offers a concise method to ensure all elements within an object are non-nullish.

Answer 4

The issue was initially resolved by:

export type N = null | undefined;
export type OmitNullish<T> = T extends (infer U)[] ? Exclude<U, N>[] : Exclude<U,N>
export type OmitNullishKeys<T> = {
  [key in keyof Required<T>]-?: T extends Record<string, unknown> ? OmitNullish<OmitNullishKeys<T[K]>> : OmitNullish<T[K]>
}

This action effectively resolved the issue

The exclusion of nullish values was not being applied to objects due to the absence of OmitNullish
Using keyof without specifying non-optionality resulted in a value of T | undefined. The use of Required ensures that the key is treated as mandatory.

although it did enforce the non-nullish rules for classes like Date.

By implementing an alternative solution presented by @jcalz and adding a conditional statement to prevent class overwrites, we obtain

type OmitNullish<T, E = Date> = T extends E ? T : NonNullable<{ 
  [key in keyof T]-?: OmitNullish<T[K]>
}>

this offers a concise method to ensure all elements within an object are non-nullish.

Issue with TypeScript: Difficulty accessing keys in a recursive manner

Answer №1

Answer №2

Similar questions

Is there a way to dynamically define the return type of a function in Typescript?

Error in Typescript: 'SyncClient' not found in Twilio

API endpoint generating a Vue component as a rendered output

Utilizing React Typescript Discriminating Unions to choose between two different types based solely on props

Error: Unable to Locate Module (Typescript with baseUrl Configuration)

How to dynamically generate Angular component selectors with variables or loops?

Unexplained Reference Error in Next.js Typescript: Variable Accessed before Initialization

What is the best way to depict object key replacements within a Typescript definition?

Achieving JSX rendering in Vue.js with TypeScript starting from a basic CLI setup along with the JSX package integration

Utilizing Pipes within a Method in Angular 2 along with Dependency Injection triggers an "Insufficient Number of Arguments" error

Tips for resolving the error message "Nextjs with Typescript: 'describe' is not defined"

Global variable appears undefined in Angular 2 view, yet it is still displaying

Converting Getters into JSON

Odd behavior of escape characters in Typescript

Tips for eliminating the gap between digits and symbols in an OutlinedTextField within the Material Ui framework

If an interface property is set as (), what significance does it hold?

Error message: "react-router typescript navigation version 0.13.3 - Unable to access 'router' property"

Angular File Upload Button Tutorial

Incorporating an external SVG file into an Angular project and enhancing a particular SVG element within the SVG with an Angular Material Tooltip, all from a TypeScript file

The type 'RefObject<HTMLDivElement>' cannot be matched with type 'RefObject<HTMLInputElement>' in this context