Utilizing Typescript generics to define constraints for the type of T[K], where K is the key and T is the object

Question

Utilizing Typescript generics to define constraints for the type of T[K], where K is the key and T is the object

In the setting I'm dealing with, specific objects with an id attribute expire every "tick" and require retrieval using getObjectById. I am interested in creating a setter function to update a property of an object by mapping

thing.property => getObjectById(thing.property.id)

. This function should accept a thing T and a key K, where T[K] can either be an object with an id (HasID) or an array of such objects (HasID[]).

I believe I am close to a solution, but it requires some adjustments. The current implementation is as follows (a static method in a class named $):

static refresh<T extends {[K in keyof T]: HasID}, K extends keyof T>(thing: T, key: K): void;
static refresh<T extends {[K in keyof T]: HasID[]}, K extends keyof T>(thing: T, key: K): void;
static refresh<T extends {[K in keyof T]: HasID | HasID[]}, K extends keyof T>(thing: T, key: K): void {
    if (_.isArray(thing[key])) {
        thing[key] = _.map(thing[key] as HasID[], s => getObjectById(s.id)) as HasID[];
    } else {
        thing[key] = getObjectById(thing[key].id) as HasID;
    }
}

For instance, the desired outcome for

foo: {bar: HasID, baz: HasID[], biz: string[]}

would be:

$.refresh(foo, 'bar') // foo.bar = getObjectById(foo.bar.id)
$.refresh(foo, 'baz') // foo.baz = _.map(foo.baz, x=>getObjectById(x.id))
$.refresh(foo, 'biz') // error: foo.biz is not HasID or HasID[]
$.refresh(foo, 'boo') // error: 'boo' is not a key of foo

Can someone offer guidance on how to correctly define the type of T[K]?

typescript generics typescript-generics

Answer 1

Answer №1

Almost there, the issue is that only the key specified by K in object T needs to be HasID or HasID[], not every key.

class $ {
  static update<T extends { [P in K]: HasID }, K extends string>(item: T, key: K): void;
  static update<T extends { [P in K]: HasID[] }, K extends string>(item: T, key: K): void;
  static update<T extends { [P in K]: HasID | HasID[] }, K extends string>(item: T, key: K): void {

  }
}

let obj: { val1: HasID, val2: HasID[], val3: string[] };
$.update(obj, 'val1') // obj.val1 = getObjectById(obj.val1.id)
$.update(obj, 'val2') // obj.val2 = _.map(obj.val2, x=>getObjectById(x.id))
$.update(obj, 'val3') // error: obj.val3 is not HasID or HasID[]
$.update(obj, 'val4') // error: 'val4' is not a key in obj

Instead of { [P in K]: HasID }, you can use Record<K, HasId>. I retained your initial version for better comparison purposes. With Record, the signatures would be:

class $ {
  static update<T extends Record<K, HasID>, K extends string>(item: T, key: K): void;
  static update<T extends Record<K, HasID>[], K extends string>(item: T, key: K): void;
  static update<T extends Record<K, HasID | HasID[]>, K extends string>(item: T, key: K): void {

  }
}

Answer 2

Almost there, the issue is that only the key specified by K in object T needs to be HasID or HasID[], not every key.

class $ {
  static update<T extends { [P in K]: HasID }, K extends string>(item: T, key: K): void;
  static update<T extends { [P in K]: HasID[] }, K extends string>(item: T, key: K): void;
  static update<T extends { [P in K]: HasID | HasID[] }, K extends string>(item: T, key: K): void {

  }
}

let obj: { val1: HasID, val2: HasID[], val3: string[] };
$.update(obj, 'val1') // obj.val1 = getObjectById(obj.val1.id)
$.update(obj, 'val2') // obj.val2 = _.map(obj.val2, x=>getObjectById(x.id))
$.update(obj, 'val3') // error: obj.val3 is not HasID or HasID[]
$.update(obj, 'val4') // error: 'val4' is not a key in obj

Instead of { [P in K]: HasID }, you can use Record<K, HasId>. I retained your initial version for better comparison purposes. With Record, the signatures would be:

class $ {
  static update<T extends Record<K, HasID>, K extends string>(item: T, key: K): void;
  static update<T extends Record<K, HasID>[], K extends string>(item: T, key: K): void;
  static update<T extends Record<K, HasID | HasID[]>, K extends string>(item: T, key: K): void {

  }
}

Utilizing Typescript generics to define constraints for the type of T[K], where K is the key and T is the object

Answer №1

Similar questions

Exploring methods to successfully upload a blob to Firebase and modify it using cloud functions

The variable is accessed before it is initialized in the context of Next.js and Server Actions

typescript: tips for selecting a data type within an object

What is the correct way to extract a value from a keyvalue pair?

The base class is invoking a function from its child class

Discovering the most recent 10 date elements in a JSON object within a React application

MikroORM - Conditional join without foreign key constraints on the ID

In the scenario where I have a nested readonly array within an object, what is the best way to duplicate that object and transform the array to allow for mutations (such as inserting into Akita)?

What is preventing me from setting the User object to null in my Angular application?

"Converting to Typescript resulted in the absence of a default export in the module

Facing a 'No provider for' error in my Angular 2.0.0 application

The parameter must be of type 'string', but you are attempting to assign a 'Promise<any>'

The inclusion of individual CSS files in a TypeScript React project does not have any effect

Enhancing Angular2 authentication with Auth0 for enabling Cross-Origin Resource Sharing

Executing NestJS code after applying a pipe but before reaching the method handler

leveraging parcel for importing typescript dependencies

Apologies, but there was an error attempting to differentiate 'nombreyo'. Please note that only arrays and iterables are permitted for this action

Creating cohesive stories in Storybook with multiple components

Retrieve data upon component mounting and deactivate the query in React-query

Using const enums across multiple files with react-scripts-ts