A generalized function that provides IEntity[E][S] as its return type, delving into two levels of

Question

A generalized function that provides IEntity[E][S] as its return type, delving into two levels of

I've encountered a compilation/type error while attempting to implement something similar to the code snippet below.

interface IEntityLookup {
    [Entity.PERSON]: IPersonLookup
    [Entity.COMPANY]: ICompanyLookup
}

interface ISubEntity {
    [Entity.PERSON]: People
    [Entity.COMPANY]: Companies
}

function mapEntity<E extends Entity, S extends ISubEntity[E]>(
    entityType: E,
    subEntity: S
): IEntityLookup[E][S] | null {
    switch (entityType) {
        case Entity.PERSON:
            return mapPerson(subEntity)
        case Entity.Company:
            return mapCompany(subEntity)
    }
}

The area of interest is in the mapEntity function where I aim to return IEntityLookup[E][S]. Is achieving this possible in Typescript?

Below are the complete definitions:

enum Companies {
    TESLA = "tesla",
    MICROSOFT = "microsoft",
}

interface ITesla {
    id: string
    cars: number
}

interface IMicrosoft {
    id: string
    software: string
}

enum People {
    ELON_MUSK = "elon-musk",
    BILL_GATES = "bill-gates",
}

interface IElonMusk {
    id: string
    rockets: number
}

interface IBillGates {
    id: string
    windows_version: string
}


interface ICompanyLookup {
    [Companies.TESLA]: ITesla
    [Companies.MICROSOFT]: IMicrosoft
}

interface IPersonLookup {
    [People.ELON_MUSK]: IElonMusk
    [People.BILL_GATES]: IBillGates
}

function mapPerson<T extends People>(
    personType: T
): IPersonLookup[T] | null {
    switch (personType) {
        case People.ELON_MUSK:
            return {id: "1", rockets: 1000} as IPersonLookup[T]

        case People.BILL_GATES:
            return {id: "1", windows_version: "98"} as IPersonLookup[T]

        default:
            return null
    }
}

function mapCompany<T extends Companies>(
 companyType: T
): ICompanyLookup[T] | null {
    switch (companyType) {
        case Companies.TESLA:
            return {id: "1", cars: 1000} as ICompanyLookup[T]
        case Companies.MICROSOFT:
            return {id: "1", software: "98"} as ICompanyLookup[T]
        default:
            return null
    }
}

enum Entity {
    PERSON = "person",
    COMPANY = "company",
}

interface IEntityLookup {
    [Entity.PERSON]: IPersonLookup
    [Entity.COMPANY]: ICompanyLookup
}

interface ISubEntity {
    [Entity.PERSON]: People
    [Entity.COMPANY]: Companies
}

function mapEntity<E extends Entity, S extends ISubEntity[E]>(
    entityType: E,
    subEntity: S
): IEntityLookup[E][S] | null {
    switch (entityType) {
        case Entity.PERSON:
            return mapPerson(subEntity)
        case Entity.Company:
            return mapCompany(subEntity)
    }
}

typescript typescript-generics

Answer 1

Answer №1

It may not be directly related to the main question, but a more efficient approach in mapPerson and mapEntity would be to utilize a map for value retrieval instead of using as assertions. The use of null in this case is unnecessary since personType will always be of type Person.

function mapPerson<T extends People>(
    personType: T
): IPersonLookup[T] {
    const map: IPersonLookup = {
        [People.ELON_MUSK]: { id: "1", rockets: 1000 },
        [People.BILL_GATES]: { id: "1", windows_version: "98" }
    }
    return map[personType];
}

The errors occurring in mapEntity stem from TypeScript considerations that there is no absolute guarantee of match between entity E and subEntity S. This issue also arises when passing subEntity as an argument to mapCompany, especially within the case Entity.COMPANY branch.

Argument of type 'S' is not assignable to parameter of type 'Companies'.
  Type 'ISubEntity[E]' is not assignable to type 'Companies'.
    Type 'Companies | People' is not assignable to type 'Companies'.

One possible solution involves treating E as a union of entities, leading to potential errors such as calling mapCompany with a Person instead of a Company.

Addressing these challenges requires complex typing structures. By leveraging double-nested mapped types indexed by keyof, we access entities and sub-entities for pairing validations.

type AllLookups = {
    [E in keyof IEntityLookup]: {
        [S in keyof IEntityLookup[E]]: {
            entity: E;
            subEntity: S;
            value: IEntityLookup[E][S];
        }
    }[keyof IEntityLookup[E]]
}[keyof IEntityLookup]

This results in a union type:

type AllLookups = {
    entity: Entity.PERSON;
    subEntity: People.ELON_MUSK;
    value: IElonMusk;
} | {
    entity: Entity.PERSON;
    subEntity: People.BILL_GATES;
    value: IBillGates;
} | {
    entity: Entity.COMPANY;
    subEntity: Companies.TESLA;
    value: ITesla;
} | {
    ...;
}

In utilizing this structure within mapEntities function, primary generics are assigned to subEntity S; while the second variable T handles matching pairs for precise return types and error-checking for entity-subEntity mismatches.

This implementation streamlines function calls, providing accurate return types and detecting any inconsistencies between entity and sub-entity types.

// error -- good!
mapEntity(Entity.COMPANY, People.BILL_GATES);
// returns IBillGates
mapEntity(Entity.PERSON, People.BILL_GATES);
// returns ITesla
mapEntity(Entity.COMPANY, Companies.TESLA);

Despite these advancements, assertions within the function body remain necessary as narrowing one variable does not automatically narrow the generic counterparts. Thus, further optimization may be achieved by reorganizing object properties and restructuring the switch without destructuring.

function mapEntity<S extends AllLookups['subEntity'], T extends AllLookups & { subEntity: S }>(
    entityType: T['entity'], subEntity: S
): T['value'] {
    switch (entityType) {
        case Entity.PERSON:
            return mapPerson(subEntity as People);
        case Entity.COMPANY:
            return mapCompany(subEntity as Companies);
        default:
            throw new Error("Invalid entity type " + entityType);
    }
}

Typescript Playground Link

With respect to IEntityLookup[E][S], the error arises due to indexing a union like

IEntityLookup[Entity]</code which necessitates a sophisticated mapping akin to <code>AllLookups

for retrieving sub-entity values irrespective of entity type relationships.

Answer 2

It may not be directly related to the main question, but a more efficient approach in mapPerson and mapEntity would be to utilize a map for value retrieval instead of using as assertions. The use of null in this case is unnecessary since personType will always be of type Person.

function mapPerson<T extends People>(
    personType: T
): IPersonLookup[T] {
    const map: IPersonLookup = {
        [People.ELON_MUSK]: { id: "1", rockets: 1000 },
        [People.BILL_GATES]: { id: "1", windows_version: "98" }
    }
    return map[personType];
}

The errors occurring in mapEntity stem from TypeScript considerations that there is no absolute guarantee of match between entity E and subEntity S. This issue also arises when passing subEntity as an argument to mapCompany, especially within the case Entity.COMPANY branch.

Argument of type 'S' is not assignable to parameter of type 'Companies'.
  Type 'ISubEntity[E]' is not assignable to type 'Companies'.
    Type 'Companies | People' is not assignable to type 'Companies'.

One possible solution involves treating E as a union of entities, leading to potential errors such as calling mapCompany with a Person instead of a Company.

Addressing these challenges requires complex typing structures. By leveraging double-nested mapped types indexed by keyof, we access entities and sub-entities for pairing validations.

type AllLookups = {
    [E in keyof IEntityLookup]: {
        [S in keyof IEntityLookup[E]]: {
            entity: E;
            subEntity: S;
            value: IEntityLookup[E][S];
        }
    }[keyof IEntityLookup[E]]
}[keyof IEntityLookup]

This results in a union type:

type AllLookups = {
    entity: Entity.PERSON;
    subEntity: People.ELON_MUSK;
    value: IElonMusk;
} | {
    entity: Entity.PERSON;
    subEntity: People.BILL_GATES;
    value: IBillGates;
} | {
    entity: Entity.COMPANY;
    subEntity: Companies.TESLA;
    value: ITesla;
} | {
    ...;
}

In utilizing this structure within mapEntities function, primary generics are assigned to subEntity S; while the second variable T handles matching pairs for precise return types and error-checking for entity-subEntity mismatches.

This implementation streamlines function calls, providing accurate return types and detecting any inconsistencies between entity and sub-entity types.

// error -- good!
mapEntity(Entity.COMPANY, People.BILL_GATES);
// returns IBillGates
mapEntity(Entity.PERSON, People.BILL_GATES);
// returns ITesla
mapEntity(Entity.COMPANY, Companies.TESLA);

Despite these advancements, assertions within the function body remain necessary as narrowing one variable does not automatically narrow the generic counterparts. Thus, further optimization may be achieved by reorganizing object properties and restructuring the switch without destructuring.

function mapEntity<S extends AllLookups['subEntity'], T extends AllLookups & { subEntity: S }>(
    entityType: T['entity'], subEntity: S
): T['value'] {
    switch (entityType) {
        case Entity.PERSON:
            return mapPerson(subEntity as People);
        case Entity.COMPANY:
            return mapCompany(subEntity as Companies);
        default:
            throw new Error("Invalid entity type " + entityType);
    }
}

Typescript Playground Link

With respect to IEntityLookup[E][S], the error arises due to indexing a union like

IEntityLookup[Entity]</code which necessitates a sophisticated mapping akin to <code>AllLookups

for retrieving sub-entity values irrespective of entity type relationships.

A generalized function that provides IEntity[E][S] as its return type, delving into two levels of

Answer №1

Similar questions

showing javascript strings on separate lines

The TypeScript Mongoose function is not available for type <Context = any>

Properties of untyped objects in TypeScript are not defined

Calculating the length of an Observable in an Angular 4 MEAN stack application

ngx-datatables in Angular is experiencing issues with its filtering options

Styling can be compromised by Angular due to selector element interference

The quantity of documents queried does not align with the number of data counts retrieved from Firestore

Transforming API response data into a Typescript object using React mapping

Construct a table utilizing Angular's ngFor directive that includes two rows, with the first row containing a single value from an array of objects and the second row displaying the remaining values

Sharing information from Directive to Component in Angular

Has the antd Form.create() method been substituted with something else?

Encountering problem with React Typescript fetching data from Spring Data REST API: the error message "Property '_embedded' does not exist" is being displayed

Combine array elements in Angular/Javascript based on a certain condition

Tips for leveraging angular CLI's async import feature with webpack

Verify if the keys are present within the object and also confirm if they contain a value

How can I generate codegen types using typeDefs?

Naming convention for TypeScript accessors

TypeScript is unable to identify import paths

How to dynamically incorporate methods into a TypeScript class

Issues arise with the escape key functionality when attempting to close an Angular modal