Generate a TypeScript generic function that maps class member types to class types

Question

Generate a TypeScript generic function that maps class member types to class types

I am dealing with the following function in my codebase

export async function batchEntitiesBy<Entity, T extends keyof Entity>(
  entityClass: EntityTarget<Entity>
  by: T,
  variables: readonly Entity[T][]
) {
    by: T,
  variables: readonly Entity[T][]
) {
  // retrieve entities from the database without grouping and in random order
  const entities = await db.find(entityClass, { [by]: In(variables as Entity[T][]) })

  // group the entities and order the groups based on variables order
  type EntityMap = { [key in Entity[T]]: Entity[]}

  const entityMap = {} as EM;
  entities.forEach((e) => {
    if (!entityMap[e[by]]) {
       entityMap[e[by]] = []
    }
     entityMap[e[by]].push(e)
  })
  return variables.map((v) => entityMap[v]);
}

I anticipate that Entity[T] will provide me with the type of the class member specified in by, making entityMap a mapping from type(by) to type(Entity)

Why am I encountering this error??

Type 'Entity[T]' is not assignable to type 'string | number | symbol'.
  Type 'Entity[keyof Entity]' is not assignable to type 'string | number | symbol'.
    Type 'Entity[string] | Entity[number] | Entity[symbol]' is not assignable to type 'string | number | symbol'.
      Type 'Entity[string]' is not assignable to type 'string | number | symbol'.

Edit:

If we take an example entity

class ExampleEntity {
  a: string,
  b: number
}

My expectations are:

by should be either a or b
If by is a, then I would expect Entity[T] to be string

referring to TypeScript documentation https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-1.html#keyof-and-lookup-types

Here demonstrating the same issue in playground

Edit2:

Below are some sample entities I intend to utilize with this function:

class User {
  id: string
  name: string
  address: Address
  addressId: number
}

class Address {
  id: number
  street: string
  num: number
}

example usage:

const adrIds = [1,5,2,9,4]

const users = batchEntitiesBy<User, addressId>(Users, "addressId", adrIds)

typescript typescript-generics

Answer 1

Answer №1

Summarizing the progress based on the revised question and chat discussion, an additional challenge arose from the fact that the original code utilized the values of Entity as keys in an object (EntityMap), but not all values of Entity were valid keys (specifically Address). Switching to a Map instead of an object provided a solution for this issue.

The issue in your code seems to stem from the indecision between using the generic Entity or ExampleEntity.

In the following code snippet, I consistently used ExampleEntity:

type ExampleEntity = {
    a: string,
    b: number
}

const batchExampleEntitiesBy = async <By extends keyof ExampleEntity>(
    by: By, variables: readonly ExampleEntity[By][]
) => {
    const entityMap = {} as { [key in ExampleEntity[By]]: ExampleEntity[] }

    const entities = [
        { a: 'hello', b: 1 },
        { a: 'world', b: 2 },
        { a: 'hello', b: 3 },
        { a: 'world', b: 4 },
    ] as ExampleEntity[];

    entities.forEach((e) => {
        if (!entityMap[e[by]]) {
            entityMap[e[by]] = []
        }
        entityMap[e[by]].push(e)
    })

    return variables.map((v) => entityMap[v]);
};


const foo = batchExampleEntitiesBy("a", ["hello"])

In the next code excerpt, I parameterized ExampleEntity:

type ExampleEntity = {
    a: string,
    b: number
}

type Key = string | number | symbol;

const batchEntitiesBy = <Entity extends Record<Key, Key>>() =>
    async <By extends keyof Entity>(by: By, variables: readonly Entity[By][]) => {
        const entityMap = {} as { [key in Entity[By]]: Entity[] }

        const entities = [
            { a: 'hello', b: 1 },
            { a: 'world', b: 2 },
            { a: 'hello', b: 3 },
            { a: 'world', b: 4 },
        ] as unknown as Entity[];

        entities.forEach((e) => {
            if (!entityMap[e[by]]) {
                entityMap[e[by]] = []
            }
            entityMap[e[by]].push(e)
        })

        return variables.map((v) => entityMap[v]);
    };

const batchExampleEntitiesBy = batchEntitiesBy<ExampleEntity>()

const foo = batchExampleEntitiesBy("a", ["hello"])

I anticipate that entities will likely be fetched from a server. If you opt for the parameterized version, it's advisable to align the fetching behavior with the asserted type. Additionally, runtime type checking of the server response is recommended.

Personally, I would convert this function to synchronous and expect entities as an input.

const entities = [
    { a: 'hello', b: 1 },
    { a: 'world', b: 2 },
    { a: 'hello', b: 3 },
    { a: 'world', b: 4 },
]

type Key = string | number | symbol;

const batchEntitiesBy = <
    Entity extends Record<Key, Key>,
    By extends keyof Entity
>(
    entities: Entity[],
    by: By,
    variables: readonly Entity[By][]
) => {
        const entityMap = {} as { [key in Entity[By]]: Entity[] }

        entities.forEach((e) => {
            if (!entityMap[e[by]]) {
                entityMap[e[by]] = []
            }
            entityMap[e[by]].push(e)
        })

        return variables.map((v) => entityMap[v]);
    };


const foo = batchEntitiesBy(entities, "a", ["hello"])

Answer 2

Summarizing the progress based on the revised question and chat discussion, an additional challenge arose from the fact that the original code utilized the values of Entity as keys in an object (EntityMap), but not all values of Entity were valid keys (specifically Address). Switching to a Map instead of an object provided a solution for this issue.

The issue in your code seems to stem from the indecision between using the generic Entity or ExampleEntity.

In the following code snippet, I consistently used ExampleEntity:

type ExampleEntity = {
    a: string,
    b: number
}

const batchExampleEntitiesBy = async <By extends keyof ExampleEntity>(
    by: By, variables: readonly ExampleEntity[By][]
) => {
    const entityMap = {} as { [key in ExampleEntity[By]]: ExampleEntity[] }

    const entities = [
        { a: 'hello', b: 1 },
        { a: 'world', b: 2 },
        { a: 'hello', b: 3 },
        { a: 'world', b: 4 },
    ] as ExampleEntity[];

    entities.forEach((e) => {
        if (!entityMap[e[by]]) {
            entityMap[e[by]] = []
        }
        entityMap[e[by]].push(e)
    })

    return variables.map((v) => entityMap[v]);
};


const foo = batchExampleEntitiesBy("a", ["hello"])

In the next code excerpt, I parameterized ExampleEntity:

type ExampleEntity = {
    a: string,
    b: number
}

type Key = string | number | symbol;

const batchEntitiesBy = <Entity extends Record<Key, Key>>() =>
    async <By extends keyof Entity>(by: By, variables: readonly Entity[By][]) => {
        const entityMap = {} as { [key in Entity[By]]: Entity[] }

        const entities = [
            { a: 'hello', b: 1 },
            { a: 'world', b: 2 },
            { a: 'hello', b: 3 },
            { a: 'world', b: 4 },
        ] as unknown as Entity[];

        entities.forEach((e) => {
            if (!entityMap[e[by]]) {
                entityMap[e[by]] = []
            }
            entityMap[e[by]].push(e)
        })

        return variables.map((v) => entityMap[v]);
    };

const batchExampleEntitiesBy = batchEntitiesBy<ExampleEntity>()

const foo = batchExampleEntitiesBy("a", ["hello"])

I anticipate that entities will likely be fetched from a server. If you opt for the parameterized version, it's advisable to align the fetching behavior with the asserted type. Additionally, runtime type checking of the server response is recommended.

Personally, I would convert this function to synchronous and expect entities as an input.

const entities = [
    { a: 'hello', b: 1 },
    { a: 'world', b: 2 },
    { a: 'hello', b: 3 },
    { a: 'world', b: 4 },
]

type Key = string | number | symbol;

const batchEntitiesBy = <
    Entity extends Record<Key, Key>,
    By extends keyof Entity
>(
    entities: Entity[],
    by: By,
    variables: readonly Entity[By][]
) => {
        const entityMap = {} as { [key in Entity[By]]: Entity[] }

        entities.forEach((e) => {
            if (!entityMap[e[by]]) {
                entityMap[e[by]] = []
            }
            entityMap[e[by]].push(e)
        })

        return variables.map((v) => entityMap[v]);
    };


const foo = batchEntitiesBy(entities, "a", ["hello"])

Generate a TypeScript generic function that maps class member types to class types

Answer №1

Similar questions

Angular authentication guard does not redirect properly after returning a Promise<UrlTree>

Is it possible to utilize a partial entity for saving with TypeORM?

Failed to decipher an ID token from firebase

MUI: Transforming the uncontrolled value state of Select into a controlled one with a new component

Navigating a page without embedding the URL in react-router-dom

Is there a specific type required for the Vue `install` function? Is it necessary to have the `directive` property on the `Vue`

The intricacies of Mongoose schemas and virtual fields

What's the best way to import a file from OneDrive to an Angular app using Typescript?

The issue with Angular's Array.push method arises when only the last object in the array is being pushed after a mat-checkbox

When logging `self`, the output field is present; however, attempting to log `self.output` results in

A guide on applying color from an API response to the border-color property in an Angular application

The functionality of Angular's mat-autocomplete is hindered when it comes to utilizing options generated by a function

What are some ways to leverage a promise-returning callback function?

Is there a way to trigger the click event in the week view of an Angular 2+ calendar?

Using TypeScript to narrow down types within mapped types

Leveraging the 'ref' keyword in TypeScript with Next.js

Tips for streamlining a conditional statement with three parameters

Ways to retrieve data object within an HTMLElement without relying on jQuery

Troubleshooting issues with TypeScript D3 v4 module import functionality

How can I extract a value from an object that is readonly, using a formatted string as the key?