Restricted inclusive collection utilizing embedded identifier

Question

Restricted inclusive collection utilizing embedded identifier

Attempting to segregate a discriminated union array into separate arrays of its union types has presented some challenges. I came across this particular question that provides generic discriminators.

Unfortunately, the dataset I am working with doesn't have the discriminator key at the topmost level.

type Foo = { meta: {type: "Foo"} };
type Goo = { meta: {type: "Goo"} };
type Union = Foo | Goo;

To address this issue, I made modifications by adjusting the discriminator function mentioned in the aforementioned post to anticipate the inclusion of the "meta" object one level beneath.

function discriminateNested<K extends PropertyKey, V extends string | number | boolean>(
    discriminantKey: K, discriminantValue: V
) {
    return <T extends Record<PropertyKey, any>>(
        obj: T & Record<"meta", Record<K, V extends T["meta"][K] ? T["meta"][K] : V>>
    ): obj is Extract<T, Record<"meta", Record<K, V>>> =>
        obj["meta"][discriminantKey] === discriminantValue;
}

Is there a more general approach to handle this? Perhaps by defining a nested key as a string like

discriminateNested("meta.type", "Foo")

?

typescript filter type-conversion discriminated-union

Answer 1

Answer №1

To achieve discriminating based on the value at a nested property, one approach could be to have the function discriminateNested() accept a tuple of keys and then use that information for discrimination. While it's possible to do this with dot-separated strings, using tuples provides a more straightforward typing solution.

First, you would define NestedRecord<K, V>, where K is a tuple of keys. For example,

NestedRecord<["a", "b", "c"], string>

should represent {a: {b: {c: string}}}. This definition could look like:

type NestedRecord<K extends PropertyKey[], V> =
  K extends [infer K0 extends PropertyKey, ...infer KR extends PropertyKey[]] ?
  { [P in K0]: NestedRecord<KR, V> } : V;

This definition utilizes recursive conditional types along with variadic tuple types to construct the desired nested structure.

The implementation of discriminatedNested() could resemble this:

function discriminateNested<K extends PropertyKey[], V extends string | number | boolean>(
  discriminantKeys: [...K], discriminantValue: V
) {
  return <T extends NestedRecord<K, string | number | boolean>>(
    obj: T
  ): obj is Extract<T, NestedRecord<K, V>> =>
    discriminantKeys.reduce<any>((acc, k) => acc[k], obj) === discriminantValue;
}

This function takes discriminantKeys as a tuple type K (using [...K] notation) and a discriminantValue of type

V</code. It returns a custom type guard that extracts union members assignable to <code>Nestedrecord<K, V>

. The nested indexing operation is performed using reduce() on discriminantKeys.

Let's test the functionality:

type Foo = { meta: { type: "Foo" }, a: string };
type Goo = { meta: { type: "Goo" }, b: number };
type Union = Foo | Goo;

const discFoo = discriminateNested(["meta", "type"], "Foo");

const u: Union = Math.random() < 0.5 ?
  { meta: { type: "Foo" }, a: "abc" } : { meta: { type: "Goo" }, b: 123 };

if (discFoo(u)) {
  u // Foo
  console.log(u.a.toUpperCase());
} else {
  u // Goo
  console.log(u.b.toFixed(2));
}

The discFoo type guard function successfully narrows the type based on the discriminator key and value. When applied to the input data of type Union, it correctly filters out the appropriate union members allowing for precise type checking.

Playground link available here

Answer 2

To achieve discriminating based on the value at a nested property, one approach could be to have the function discriminateNested() accept a tuple of keys and then use that information for discrimination. While it's possible to do this with dot-separated strings, using tuples provides a more straightforward typing solution.

First, you would define NestedRecord<K, V>, where K is a tuple of keys. For example,

NestedRecord<["a", "b", "c"], string>

should represent {a: {b: {c: string}}}. This definition could look like:

type NestedRecord<K extends PropertyKey[], V> =
  K extends [infer K0 extends PropertyKey, ...infer KR extends PropertyKey[]] ?
  { [P in K0]: NestedRecord<KR, V> } : V;

This definition utilizes recursive conditional types along with variadic tuple types to construct the desired nested structure.

The implementation of discriminatedNested() could resemble this:

function discriminateNested<K extends PropertyKey[], V extends string | number | boolean>(
  discriminantKeys: [...K], discriminantValue: V
) {
  return <T extends NestedRecord<K, string | number | boolean>>(
    obj: T
  ): obj is Extract<T, NestedRecord<K, V>> =>
    discriminantKeys.reduce<any>((acc, k) => acc[k], obj) === discriminantValue;
}

This function takes discriminantKeys as a tuple type K (using [...K] notation) and a discriminantValue of type

V</code. It returns a custom type guard that extracts union members assignable to <code>Nestedrecord<K, V>

. The nested indexing operation is performed using reduce() on discriminantKeys.

Let's test the functionality:

type Foo = { meta: { type: "Foo" }, a: string };
type Goo = { meta: { type: "Goo" }, b: number };
type Union = Foo | Goo;

const discFoo = discriminateNested(["meta", "type"], "Foo");

const u: Union = Math.random() < 0.5 ?
  { meta: { type: "Foo" }, a: "abc" } : { meta: { type: "Goo" }, b: 123 };

if (discFoo(u)) {
  u // Foo
  console.log(u.a.toUpperCase());
} else {
  u // Goo
  console.log(u.b.toFixed(2));
}

The discFoo type guard function successfully narrows the type based on the discriminator key and value. When applied to the input data of type Union, it correctly filters out the appropriate union members allowing for precise type checking.

Playground link available here

Restricted inclusive collection utilizing embedded identifier

Answer №1

Similar questions

Absence of "Go to Definition" option in the VSCode menu

Creating a String Array and linking it to an Input Field

The specified property is not present in the type '{}'

Leveraging Angular2's observable stream in combination with *ngFor

Is there a way to retrieve keys of the object from this combination type?

The child component is receiving null input data from the Angular async pipe, despite the fact that the data is not null in the

The formControl value is not being shown on the display

The compiler option 'esnext.array' does not provide support for utilizing the Array.prototype.flat() method

The module has defined the component locally, however, it has not been made available for

Create seamless communication between Angular application and React build

Unlock the power of Angular Component methods even when outside the Angular library with the help of @ViewChild()

The navigation function in Angular, this.router.navigate, is causing issues and

Do const generics similar to Rust exist in TypeScript?

Converting ts files to js: A comprehensive guide

Encountered an error while trying to access a property that is undefined - attempting to call

Steps for converting TypeScript code to JavaScript using jQuery, without the need for extra libraries or frameworks like NPM

Two distinct arrays interacting and syncing with each other through a single API request

Extract all objects from an array where a specific field contains an array

How can I filter an array by a nested property using Angular?

Tips for positioning a div alongside its parent div