Flatten a specific property of an object recursively

Question

Flatten a specific property of an object recursively

If I have a data structure containing nested objects, I need to create a type that removes specific keys and flattens certain fields recursively

Input:

{
    sys: {
        id: string;
    };
    metadata: {
        author: string;
    };
    fields: {
        name: string;
        age: number;
        father: {
            sys: {
                id: string;
            };
            metadata: {
                author: string;
            };
            name: string;
        },
        siblings: {
            sys: {
                id: string;
            };
            metadata: {
                author: string;
            };
            name: string;
        }[]
    };
}

Desired Output:

{
    name: string;
    age: number;
    father: {
        name: string;
    };
    siblings: {
        name: string;
    }[];
}

To achieve this, I attempted to create a type that filters out 'sys' and 'metadata' keys and recursively processes the 'fields' key:

type Helper<T extends object> = {
    [K in keyof T]: K extends "sys" | "metadata"
        ? never
        : K extends "fields"
        ? ...
        : T[K] extends Array<infer I>
        ? I extends object
            ? Helper<I>
            : never
        : T[K] extends object
        ? Helper<T[K]>
        : T[K];
};

typescript

Answer 1

Answer №1

It is essential to have 4 different scenarios considered in this case.

If the data type is an array, then filter out the elements of that array.
If the object contains a fields property, simply utilize the value of T['fields'].
If the value is an object, then repeat the steps recursively for each property that is not 'sys' | 'metadata'.
If none of the above conditions apply (i.e., a primitive value), then exclude the data type.

Proceed with these steps in a recursive manner.

The specified type follows these rules:

type Helper<T> =
  // Map array elements if it is an array
  T extends unknown[] ? Helper<T[number]>[] :

  // Use 'fields' data if it exists
  T extends { fields: unknown } ? Helper<T['fields']> :

  // Clean unwanted keys in object and recurse each property
  T extends object ? { [K in Exclude<keyof T, 'sys' | 'metadata'>]: Helper<T[K]> } :

  // Use the value as is if no other conditions apply
  T

It functions as expected with input data like this:

const obj: Helper<Input> = {
  name: '',
  age: 123,
  father: { name: 'asd' },
  siblings: [{ name: 'qwe' }]
} // works fine

View Playground

Answer 2

It is essential to have 4 different scenarios considered in this case.

If the data type is an array, then filter out the elements of that array.
If the object contains a fields property, simply utilize the value of T['fields'].
If the value is an object, then repeat the steps recursively for each property that is not 'sys' | 'metadata'.
If none of the above conditions apply (i.e., a primitive value), then exclude the data type.

Proceed with these steps in a recursive manner.

The specified type follows these rules:

type Helper<T> =
  // Map array elements if it is an array
  T extends unknown[] ? Helper<T[number]>[] :

  // Use 'fields' data if it exists
  T extends { fields: unknown } ? Helper<T['fields']> :

  // Clean unwanted keys in object and recurse each property
  T extends object ? { [K in Exclude<keyof T, 'sys' | 'metadata'>]: Helper<T[K]> } :

  // Use the value as is if no other conditions apply
  T

It functions as expected with input data like this:

const obj: Helper<Input> = {
  name: '',
  age: 123,
  father: { name: 'asd' },
  siblings: [{ name: 'qwe' }]
} // works fine

View Playground

Answer 3

Answer №2

Upon removal of the sys and metadata properties, it is advisable to verify whether the initial object had those properties and, if so, intersect the result with the type in that property.

To eliminate those properties, it is recommended to use the method employed by the built-in Omit utility type instead of utilizing never:

/**
 * Construct a type with the properties of T except for those in type K.
 */
type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;

It seems that a recursive approach may be necessary for your implementation. Though I'm unable to validate the TypeScript code example in your question, the provided solution may be a close match for your requirement, with the possibility of minor adjustments to tailor it to your exact needs.

An illustrative example object has been included at the conclusion to demonstrate the structure resulting from the implementation of the Helper type:

/* Type definitions and example object snippet are provided in the original text. */

TypeScript Playground

If flattening the sys and metadata properties is not necessary for your implementation, you can simplify the corresponding sections for better clarity.

For instance,

T['sys'] extends Object ? Helper<T['sys']> : T['sys']

can be simplified to just T['sys'].

Answer 4

Upon removal of the sys and metadata properties, it is advisable to verify whether the initial object had those properties and, if so, intersect the result with the type in that property.

To eliminate those properties, it is recommended to use the method employed by the built-in Omit utility type instead of utilizing never:

/**
 * Construct a type with the properties of T except for those in type K.
 */
type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;

It seems that a recursive approach may be necessary for your implementation. Though I'm unable to validate the TypeScript code example in your question, the provided solution may be a close match for your requirement, with the possibility of minor adjustments to tailor it to your exact needs.

An illustrative example object has been included at the conclusion to demonstrate the structure resulting from the implementation of the Helper type:

/* Type definitions and example object snippet are provided in the original text. */

TypeScript Playground

If flattening the sys and metadata properties is not necessary for your implementation, you can simplify the corresponding sections for better clarity.

For instance,

T['sys'] extends Object ? Helper<T['sys']> : T['sys']

can be simplified to just T['sys'].

Flatten a specific property of an object recursively

Answer №1

Answer №2

Similar questions

Establishing the parameters for a list that is not empty using a specific data type

Material UI TreeView: Organize and present node data with multiple columns in a tree structure

TypeScript: When using an API, it consistently returns an empty object with the type { [key: string]: any }

"Encountering issues with getStaticPaths not generating any paths

Troubleshooting problems encountered in Nest.js due to modifications made within a service.ts file

Transform the code provided by bundleMDX into an HTML string specifically for RSS, all the while utilizing the mdx-bundler

Creating a type that can be used with a generic type T along with an array of the same generic type T

How to toggle visibility of multiple div elements in ReactJS

Can Typescript restrict a value to only exist within a specified set of key names within the same object?

Incorporating responsive design with React and Typescript

Manage sequential observables and await user input

Exploring methods for interacting with and controlling structural directives in e2e testing

Nest is having trouble resolving dependencies for this service

Using Angular's ElementRef to set focus on an ion-textarea: "The 'setFocus' property is not found on the 'ElementRef' type."

MUI is designed to only manage either onBlur or onKeyPress, but not both simultaneously

Is it possible to utilize instanceof to verify whether a certain variable is of a class constructor type in TypeScript?

Using Angular2, assign a value to the session and retrieve a value from the session

Can we restrict type T to encompass subclasses of K, excluding K itself?

When navigating using the next and back buttons, the active state in Angular is automatically removed

The Vue store array declaration triggers a TS error stating that it is not assignable to a parameter of type never