Tips for guaranteeing a Typescript string enum with identical key and value pairs

Question

Tips for guaranteeing a Typescript string enum with identical key and value pairs

I am looking for a way to create a generic type that verifies certain criteria on an enum:

all fields must be strings
all values must be equal to their respective keys

For example, the following enums would meet the requirements:

enum correct1 {
  bar = 'bar',
  baz = 'baz',
}

enum correct2 {
  quux = 'quux',
}

However, the following enums would not:

enum wrongFoo {
  bar = 'bar',
  baz = 'WRONG',
}

enum wrongFoo2 {
  bar = 1
}

Can you provide the correct syntax to achieve this validation?

typescript enums

Answer 1

Answer №1

To implement a manual compile-time check, where you need to add something manually after defining your enum, you can use the following code:

type EnsureCorrectEnum<T extends { [K in Exclude<keyof T, number>]: K }> = true;

Then, you can have the compiler check

EnsureCorrectEnum<typeof YourEnumObjectHere>

. If it compiles without errors, everything is good; otherwise, there is an issue:

type Correct1Okay = EnsureCorrectEnum<typeof correct1>; // okay
type Correct2Okay = EnsureCorrectEnum<typeof correct2>; // okay

type WrongFooBad = EnsureCorrectEnum<typeof wrongFoo>; // error!
//   ┌─────────────────────────────> ~~~~~~~~~~~~~~~
// Types of property 'baz' are incompatible.

type WrongFoo2Bad = EnsureCorrectEnum<typeof wrongFoo2>; // error!
//   ┌──────────────────────────────> ~~~~~~~~~~~~~~~~
// Types of property 'bar' are incompatible.

The error messages are quite descriptive in this scenario.

Hopefully, this explanation is helpful to you and good luck with your implementation!

Link to code

Answer 2

To implement a manual compile-time check, where you need to add something manually after defining your enum, you can use the following code:

type EnsureCorrectEnum<T extends { [K in Exclude<keyof T, number>]: K }> = true;

Then, you can have the compiler check

EnsureCorrectEnum<typeof YourEnumObjectHere>

. If it compiles without errors, everything is good; otherwise, there is an issue:

type Correct1Okay = EnsureCorrectEnum<typeof correct1>; // okay
type Correct2Okay = EnsureCorrectEnum<typeof correct2>; // okay

type WrongFooBad = EnsureCorrectEnum<typeof wrongFoo>; // error!
//   ┌─────────────────────────────> ~~~~~~~~~~~~~~~
// Types of property 'baz' are incompatible.

type WrongFoo2Bad = EnsureCorrectEnum<typeof wrongFoo2>; // error!
//   ┌──────────────────────────────> ~~~~~~~~~~~~~~~~
// Types of property 'bar' are incompatible.

The error messages are quite descriptive in this scenario.

Hopefully, this explanation is helpful to you and good luck with your implementation!

Link to code

Answer 3

Answer №2

Here is an alternative approach that eliminates the need to define a new type for each check:

const validateKeyValues = <T>(kv: { [K in keyof T]: K }) => {};

enum success {
  apple = 'apple',
  banana = 'banana',
}
enum failure {
  apple = 'apple',
  banana = 'bad',
}

validateKeyValues(success);
validateKeyValues(failure); // Error: Type 'failure.banana' is not assignable to type '"banana"'.

Answer 4

Here is an alternative approach that eliminates the need to define a new type for each check:

const validateKeyValues = <T>(kv: { [K in keyof T]: K }) => {};

enum success {
  apple = 'apple',
  banana = 'banana',
}
enum failure {
  apple = 'apple',
  banana = 'bad',
}

validateKeyValues(success);
validateKeyValues(failure); // Error: Type 'failure.banana' is not assignable to type '"banana"'.

Answer 5

Answer №3

It seems like a utility we developed might be useful in your case. While it doesn't exactly generate an enum, it does produce a type-safe object where the keys mirror their names and implement keyof typeof for added string-type security.

This tool was invented prior to the existence of string enums, hence the label "enum" although it functions more like an object. Nonetheless, it serves as a great alternative to hardcoded strings.

/**
 * This function creates a pseudo string enum object. Usage example:
 *     const Ab = strEnum(['a', 'b']);
 *     type AbKeys = keyof typeof Ab;
 * @param keys keys in the enum
 * @returns enum object
 */
export function generateStringEnum<T extends string>(keys: T[]): {[K in T]: K} {
    return keys.reduce((res, key) => {
        res[key] = key;
        return res;
    }, Object.create(null));
}

const Ab = generateStringEnum(['a', 'b']);
type AbKeys = keyof typeof Ab;

const Bc = generateStringEnum(['b', 'c']);
type BcKeys = keyof typeof Ab;

console.log(Bc.blah) // Compilation error - blah property does not exist
// Error: invalid string
const b: AbKeys = "e"; 
// Although an enum would trigger an error, this isn't truly an enum
// Primary drawback of this approach
const a: AbKeys = Bc.b;

Even if it may not directly meet your requirements, this tool could prove beneficial for individuals who aren't mandated to utilize enums.

Answer 6

It seems like a utility we developed might be useful in your case. While it doesn't exactly generate an enum, it does produce a type-safe object where the keys mirror their names and implement keyof typeof for added string-type security.

This tool was invented prior to the existence of string enums, hence the label "enum" although it functions more like an object. Nonetheless, it serves as a great alternative to hardcoded strings.

/**
 * This function creates a pseudo string enum object. Usage example:
 *     const Ab = strEnum(['a', 'b']);
 *     type AbKeys = keyof typeof Ab;
 * @param keys keys in the enum
 * @returns enum object
 */
export function generateStringEnum<T extends string>(keys: T[]): {[K in T]: K} {
    return keys.reduce((res, key) => {
        res[key] = key;
        return res;
    }, Object.create(null));
}

const Ab = generateStringEnum(['a', 'b']);
type AbKeys = keyof typeof Ab;

const Bc = generateStringEnum(['b', 'c']);
type BcKeys = keyof typeof Ab;

console.log(Bc.blah) // Compilation error - blah property does not exist
// Error: invalid string
const b: AbKeys = "e"; 
// Although an enum would trigger an error, this isn't truly an enum
// Primary drawback of this approach
const a: AbKeys = Bc.b;

Even if it may not directly meet your requirements, this tool could prove beneficial for individuals who aren't mandated to utilize enums.

Answer 7

Answer №4

Enums in Typescript are treated as objects, allowing you to utilize the Object.keys function to retrieve all keys within the enum and then compare them to their corresponding values. It's important to note that since the keys returned by Object.keys are strings, the values within the enum must also be strings.

enum correct1 {
    bar = 'bar',
    baz = 'baz',
}

enum correct2 {
    quux = 'quux',
}

enum wrongFoo {
    bar = 'bar',
    baz = 'WRONG',
}

enum wrongFoo2 {
    bar = 1
}

function isEnumValid<T extends {}>(validatedEnum: T) : boolean {
    return Object.keys(validatedEnum).every(k => k === validatedEnum[k]);
}

console.log(isEnumValid(correct1)); // true
console.log(isEnumValid(correct2)); // true
console.log(isEnumValid(wrongFoo)); // false
console.log(isEnumValid(wrongFoo2)); // false

Answer 8

Enums in Typescript are treated as objects, allowing you to utilize the Object.keys function to retrieve all keys within the enum and then compare them to their corresponding values. It's important to note that since the keys returned by Object.keys are strings, the values within the enum must also be strings.

enum correct1 {
    bar = 'bar',
    baz = 'baz',
}

enum correct2 {
    quux = 'quux',
}

enum wrongFoo {
    bar = 'bar',
    baz = 'WRONG',
}

enum wrongFoo2 {
    bar = 1
}

function isEnumValid<T extends {}>(validatedEnum: T) : boolean {
    return Object.keys(validatedEnum).every(k => k === validatedEnum[k]);
}

console.log(isEnumValid(correct1)); // true
console.log(isEnumValid(correct2)); // true
console.log(isEnumValid(wrongFoo)); // false
console.log(isEnumValid(wrongFoo2)); // false

Answer 9

Answer №5

After a bit of searching online, I came across an alternative method that might be helpful

Another Source

export enum OPTIONS {
  OPTION1 = <any>"option1",
  OPTION2 = <any>"option2"
}

This approach seems to be effective

  function(option: OPTIONS) {

  ...

  option: OPTIONS.OPTION2,

  ... (or)

  if (option === OPTIONS.OPTION2) ...

Answer 10

After a bit of searching online, I came across an alternative method that might be helpful

Another Source

export enum OPTIONS {
  OPTION1 = <any>"option1",
  OPTION2 = <any>"option2"
}

This approach seems to be effective

  function(option: OPTIONS) {

  ...

  option: OPTIONS.OPTION2,

  ... (or)

  if (option === OPTIONS.OPTION2) ...

Tips for guaranteeing a Typescript string enum with identical key and value pairs

Answer №1

Answer №2

Answer №3

Answer №4

Answer №5

Similar questions

Exploring the power of Prosemirror with NextJS through Tiptap v2

Building a dynamic and fast Vite project using "lit-ts" to create a visually appealing static website

Encountered an unexpected token error when executing karma-coverage in a project using TypeScript

"Error 404: The file you are looking for cannot be found on [custom company domain]. Please check

Show a Toast in React without relying on useEffect to manage the state

Exploring the concept of inheritance and nested views within AngularJS

I am having trouble getting the guide for setting up a NextJS app with Typescript to function properly

Angular is encountering a circular dependency while trying to access a property called 'lineno' that does not actually exist within the module exports

What is the method to have VIM recognize backticks as quotes?

Angular Reactive Forms may not properly update other inputs when binding a control to multiple inputs

Why am I unable to apply the keyof operator from one type to another type, even though both types have identical keys defined but different value types?

Type of tuple without a specific order

What are the steps to integrate material-ui with styled-components effectively?

Encountering Typescript issues while trying to access @angular/core packages

extract keys and values from an array of objects

Encountering a Next.js event type issue within an arrow function

Employing Multer and Express in conjunction with TypeScript

Is there a way to use Regex to strip the Authorization header from the logging output

Struggling to integrate D3.js with React using the useRef hook. Any suggestions on the proper approach?

What is the method for enabling imports from .ts files without file extensions?