Develop a mapping system using enums that ensures compiler errors are enforced

Question

Develop a mapping system using enums that ensures compiler errors are enforced

I am struggling to enforce a mapping on an object in TypeScript. My goal is to define a type or interface that maps from ANIMAL_PLACE to ANIMAL_TYPE. I want the type to ensure that any object created with these mappings includes both the ANIMAL_PLACE and ANIMAL_TYPE keys. However, I have only been able to achieve this halfway.

export enum ANIMAL_TYPE {
    dog = "dog",
    cat = "cat",
    fish = "fish",
    foo = "foo"
}

export enum ANIMAL_PLACE {
    europe = 'europe',
    africa = 'africa',
    asia = "asia"
}

// Despite my efforts, this type does not trigger a compiler error when ANIMAL_PLACE or ANIMAL_TYPE is missing
type AnimalPlaceToAnimalMapType = {
    [ANIMAL_PLACE.africa]: [ANIMAL_TYPE.cat, ANIMAL_TYPE.fish]
    [ANIMAL_PLACE.europe]: [ANIMAL_TYPE.dog]
}

// Only ANIMAL_PLACE triggers a compiler error when missing from the record
const AnimalPlaceToAnimalMapRecord: Record<ANIMAL_PLACE, ANIMAL_TYPE[]> = {
    [ANIMAL_PLACE.africa]: [ANIMAL_TYPE.cat, ANIMAL_TYPE.fish],
    [ANIMAL_PLACE.europe]: [ANIMAL_TYPE.dog],
};

Try out the code in this Playground

If I cannot achieve an error when either key is missing, is there a way to trigger a compiler error specifically if ANIMAL_TYPE is omitted instead of ANIMAL_PLACE...?

typescript

Answer 1

Answer №1

To ensure that two types are "the same" in TypeScript, you can create a utility type. Although this utility type actually checks for mutual assignability rather than strict sameness, it serves the purpose well:

type Same<T extends U, U extends V, V = T> = void;

While the utility type itself doesn't output anything significant, it sets constraints on the types T and U. So, when you use Same<T, U> with different types, a compiler error will be triggered for either T or U:

type T1 = Same<string, string>; // okay
type T2 = Same<string, number>; // error!
// Type 'string' does not satisfy the constraint 'number'.
type T3 = Same<"abc", string>; // error!
// Type 'string' does not satisfy the constraint '"abc"'.

The workaround for TypeScript's rejection of a directly circular constraint is to introduce a third type parameter V. This way, U extends V, and V defaults to T. Essentially, when you use Same<T, U>, it mimics Same<T, U, T>, and TypeScript will throw an error if U extends T is false.

By applying this approach, we can ensure that the keys of AnimalPlaceToAnimalMapType's union align with the ANIMAL_PLACE type, and the array element types in AnimalPlaceToAnimalMapType's union match the ANIMAL_TYPE:

type VerifyMap =
    Same<keyof AnimalPlaceToAnimalMapType, ANIMAL_PLACE> &
    Same<AnimalPlaceToAnimalMapType[keyof AnimalPlaceToAnimalMapType][number], ANIMAL_TYPE>

For a detailed explanation of the utility type implementation and further checks, refer to the original post or the provided Playground link.

Answer 2

To ensure that two types are "the same" in TypeScript, you can create a utility type. Although this utility type actually checks for mutual assignability rather than strict sameness, it serves the purpose well:

type Same<T extends U, U extends V, V = T> = void;

While the utility type itself doesn't output anything significant, it sets constraints on the types T and U. So, when you use Same<T, U> with different types, a compiler error will be triggered for either T or U:

type T1 = Same<string, string>; // okay
type T2 = Same<string, number>; // error!
// Type 'string' does not satisfy the constraint 'number'.
type T3 = Same<"abc", string>; // error!
// Type 'string' does not satisfy the constraint '"abc"'.

The workaround for TypeScript's rejection of a directly circular constraint is to introduce a third type parameter V. This way, U extends V, and V defaults to T. Essentially, when you use Same<T, U>, it mimics Same<T, U, T>, and TypeScript will throw an error if U extends T is false.

By applying this approach, we can ensure that the keys of AnimalPlaceToAnimalMapType's union align with the ANIMAL_PLACE type, and the array element types in AnimalPlaceToAnimalMapType's union match the ANIMAL_TYPE:

type VerifyMap =
    Same<keyof AnimalPlaceToAnimalMapType, ANIMAL_PLACE> &
    Same<AnimalPlaceToAnimalMapType[keyof AnimalPlaceToAnimalMapType][number], ANIMAL_TYPE>

For a detailed explanation of the utility type implementation and further checks, refer to the original post or the provided Playground link.

Answer 3

Answer №2

type AnimalPlaceToAnimalMapType = {
    [ANIMAL_PLACE.africa]: [ANIMAL_TYPE.cat, ANIMAL_TYPE.fish]
    [ANIMAL_PLACE.europe]: [ANIMAL_TYPE.dog]
}

Declared as a type that corresponds to its value, without any direct relationship between keys and values.

It would be more explicit to specify that the type equals its corresponding value.

No errors are present as the type is accurate and no assumptions need to be made.

However, if you define a

Record<ANIMAL_PLACE, ANIMAL_TYPE[]>

, all ANIMAL_PLACE entries must be accounted for.

In this example, an error occurs because ANIMAL_PLACE.asia is not declared.

To address this, you can make all keys optional by setting up your const like this:

const AnimalPlaceToAnimalMapRecord: { [K in ANIMAL_PLACE]?: ANIMAL_TYPE[]} = {
    [ANIMAL_PLACE.africa]: [ANIMAL_TYPE.cat, ANIMAL_TYPE.fish],
    [ANIMAL_PLACE.europe]: [ANIMAL_TYPE.dog],
};

While this approach allows for optional keys, additional type-checking will be required due to uncertain key usage.

If you desire a compiler error when omitting an ANIMAL_TYPE, you can structure it as follows:

type AnimalTypeToAnimalPlaceMap = Record<ANIMAL_TYPE, ANIMAL_PLACE[]>;

Answer 4

type AnimalPlaceToAnimalMapType = {
    [ANIMAL_PLACE.africa]: [ANIMAL_TYPE.cat, ANIMAL_TYPE.fish]
    [ANIMAL_PLACE.europe]: [ANIMAL_TYPE.dog]
}

Declared as a type that corresponds to its value, without any direct relationship between keys and values.

It would be more explicit to specify that the type equals its corresponding value.

No errors are present as the type is accurate and no assumptions need to be made.

However, if you define a

Record<ANIMAL_PLACE, ANIMAL_TYPE[]>

, all ANIMAL_PLACE entries must be accounted for.

In this example, an error occurs because ANIMAL_PLACE.asia is not declared.

To address this, you can make all keys optional by setting up your const like this:

const AnimalPlaceToAnimalMapRecord: { [K in ANIMAL_PLACE]?: ANIMAL_TYPE[]} = {
    [ANIMAL_PLACE.africa]: [ANIMAL_TYPE.cat, ANIMAL_TYPE.fish],
    [ANIMAL_PLACE.europe]: [ANIMAL_TYPE.dog],
};

While this approach allows for optional keys, additional type-checking will be required due to uncertain key usage.

If you desire a compiler error when omitting an ANIMAL_TYPE, you can structure it as follows:

type AnimalTypeToAnimalPlaceMap = Record<ANIMAL_TYPE, ANIMAL_PLACE[]>;

Develop a mapping system using enums that ensures compiler errors are enforced

Answer №1

Answer №2

Similar questions

Alter the value by clicking a button within the DynamicRadioGroupModel in ng Dynamic Forms

Eliminate the eslint@typescript-eslint/no-unused-vars error in TypeScript when the index parameter is not utilized within a map function

TS2322 error: What does it mean when the type is both not assignable and assignable?

What is the best way to import a reusable component from the theme folder in a React Native project?

The p-calendar feature is experiencing compatibility issues with Internet Explorer, Edge, and Firefox

Resolver problem involving Angular HttpClient

What is the best way to connect input values with ngFor and ngModel?

The process of HTML compilation is halted due to the unexpected presence of the forbidden 'null' data type, despite the fact that null cannot actually be a valid value in

Unable to replicate the function

Tips for transforming TypeScript Enum properties into their corresponding values and vice versa

What is the process for creating a TypeScript type that is generic and includes a keyof property?

Using `this` within an object declaration

typescript: How to restrict an array's type in a specific order

Manipulating and inserting objects into an array using React and Typescript with an undefined type

Destructuring objects with default values from two related interfaces

The default behavior of Angular-Keycloak does not include automatically attaching the bearer token to my http requests

Is there a way to locate a model using a value within a OneToMany connection?

Having trouble with implementing custom checkboxes in a d3 legend?

Using Moment JS to display the days of the upcoming week

I encountered an error when attempting to utilize a recursive type alias in a generic context