Is it possible to ensure that all values from a specific type are represented in an enum collection?

Question

Is it possible to ensure that all values from a specific type are represented in an enum collection?

I have a Prisma enum that I've defined (not in TypeScript), and I'm curious if it's possible to synchronize a TypeScript String enum with the generated Type from the Prisma Client. Here are the key details:

export const GroupInvitationStatus: {
  Pending: 'Pending',
  Accepted: 'Accepted',
  Declined: 'Declined'
};

export type GroupInvitationStatus = (typeof GroupInvitationStatus)[keyof typeof GroupInvitationStatus]

Upon importing GroupInvitationStatus from the Prisma Client, I noticed its contents:

(alias) type GroupInvitationStatus = "Pending" | "Accepted" | "Declined"

My aim is to ensure that every value in the Prisma enum (referenced through the imported type) is specified in my TypeScript string enum.

Is this achievable? I've reviewed the TypeScript documentation on enums and searched for solutions but haven't found one yet.

Is it too much? Should I just stick to using the type directly and skip defining an enum?

Update 1: I came across this solution from Stack Overflow that seems promising for my requirements.

Is there a way to dynamically generate enums on TypeScript based on Object Keys?

However, I am struggling to make TypeScript react to changes made in the Prisma Client, contained within the node modules.

While this alternative seems better, it doesn't address my specific situation. I'm starting to think that using the generated const instead of the type as an enum would work just as effectively.

New update: Here is a Code Sandbox with more context. In "prisma-client.ts," I mimic exports from a node module in my project, and in "target-file.enum.ts," I utilize the exports from the Prisma Client.

https://codesandbox.io/s/sweet-curran-n7ruyt?file=/src/target-file.enum.ts

typescript prisma

Answer 1

Answer №1

Found on a Typescript playground

To see how it operates, check out the details provided here.

This functionality can be achieved by placing this snippet in a .d.ts file:

declare const GroupInvitationStatus: {
  Pending: 'Pending',
  Accepted: 'Accepted',
  Declined: 'Declined'
};

Essentially working as an enum, it is advised not to duplicate Enum for your own purpose.

Answer 2

Found on a Typescript playground

To see how it operates, check out the details provided here.

This functionality can be achieved by placing this snippet in a .d.ts file:

declare const GroupInvitationStatus: {
  Pending: 'Pending',
  Accepted: 'Accepted',
  Declined: 'Declined'
};

Essentially working as an enum, it is advised not to duplicate Enum for your own purpose.

Answer 3

Answer №2

In this guide, I will outline a method for creating what I refer to as "synthetic string enums": dynamic objects with read-only keys and values that are identical to each other, generated from a tuple of string literals. The types used in the creation process can be limited based on an existing string union (imported). While verbose due to TypeScript's nature, this approach offers flexibility and ensures type correctness.

The key element enabling this technique is a higher-order function that utilizes a generic type constraint to form an identity function where the input parameter conforms to the original type restriction.

I have extensively annotated the code to provide documentation within your codebase should you choose to implement it. If anything seems unclear or if errors are detected, feel free to seek clarification by leaving a comment.

I recommend exploring the code in the // import type {GroupInvitationStatus} from 'some_module_specifier'; // Example showing the imported content mentioned above: type GroupInvitationStatus = 'Accepted' | 'Declined' | 'Pending'; /** * Generates a new identity function that takes and returns a value, * triggering a compiler error if the value does not extend * the specified constraint. */ function createConstrainedIdentityFn <Constraint = never>(): <T extends Constraint>(value: T) => T { return value => value; } /** An approximation of TS's string enum runtime object type */ type StringEnumObj<StrUnion extends string> = { readonly [S in StrUnion]: S }; /** Converts a string tuple into an object with key-value pairs */ function objectFromTuple <T extends readonly string[]>( strings: T, ): StringEnumObj<T[number]> { return Object.fromEntries(strings.map(s => [s, s])) as StringEnumObj<T[number]>; // Type assertion required } // This part needs manual updating but aids in safe iteration over keys using string literals const groupInvitationStatusTuple = createConstrainedIdentityFn<readonly GroupInvitationStatus[]>()( ['Accepted', 'Declined', 'Pending'] as const, ); // Trying to use values beyond the imported union results in a compilation error. createConstrainedIdentityFn<readonly GroupInvitationStatus[]>()(['Accepted', 'Declined', 'Pending', 'nope'] as const); /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Argument of type 'readonly ["Accepted", "Declined", "Pending", "nope"]' is not assignable to parameter of type 'readonly GroupInvitationStatus[]'. Type '"Accepted" | "Declined" | "Pending" | "nope"' is not assignable to type 'GroupInvitationStatus'. Type '"nope"' is not assignable to type 'GroupInvitationStatus'.(2345) */ // Continuing from where we left off earlier

Answer 4

In this guide, I will outline a method for creating what I refer to as "synthetic string enums": dynamic objects with read-only keys and values that are identical to each other, generated from a tuple of string literals. The types used in the creation process can be limited based on an existing string union (imported). While verbose due to TypeScript's nature, this approach offers flexibility and ensures type correctness.

The key element enabling this technique is a higher-order function that utilizes a generic type constraint to form an identity function where the input parameter conforms to the original type restriction.

I have extensively annotated the code to provide documentation within your codebase should you choose to implement it. If anything seems unclear or if errors are detected, feel free to seek clarification by leaving a comment.

I recommend exploring the code in the // import type {GroupInvitationStatus} from 'some_module_specifier'; // Example showing the imported content mentioned above: type GroupInvitationStatus = 'Accepted' | 'Declined' | 'Pending'; /** * Generates a new identity function that takes and returns a value, * triggering a compiler error if the value does not extend * the specified constraint. */ function createConstrainedIdentityFn <Constraint = never>(): <T extends Constraint>(value: T) => T { return value => value; } /** An approximation of TS's string enum runtime object type */ type StringEnumObj<StrUnion extends string> = { readonly [S in StrUnion]: S }; /** Converts a string tuple into an object with key-value pairs */ function objectFromTuple <T extends readonly string[]>( strings: T, ): StringEnumObj<T[number]> { return Object.fromEntries(strings.map(s => [s, s])) as StringEnumObj<T[number]>; // Type assertion required } // This part needs manual updating but aids in safe iteration over keys using string literals const groupInvitationStatusTuple = createConstrainedIdentityFn<readonly GroupInvitationStatus[]>()( ['Accepted', 'Declined', 'Pending'] as const, ); // Trying to use values beyond the imported union results in a compilation error. createConstrainedIdentityFn<readonly GroupInvitationStatus[]>()(['Accepted', 'Declined', 'Pending', 'nope'] as const); /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Argument of type 'readonly ["Accepted", "Declined", "Pending", "nope"]' is not assignable to parameter of type 'readonly GroupInvitationStatus[]'. Type '"Accepted" | "Declined" | "Pending" | "nope"' is not assignable to type 'GroupInvitationStatus'. Type '"nope"' is not assignable to type 'GroupInvitationStatus'.(2345) */ // Continuing from where we left off earlier

Is it possible to ensure that all values from a specific type are represented in an enum collection?

Answer №1

Answer №2

Similar questions

Retrieve the accurate file name and line number from the stack: Error object in a JavaScript React Typescript application

An Unexpected Typescript Error Occurred While Creating an RxCollection With RxDB

"Using Angular and TypeScript to dynamically show or hide tabs based on the selected language on a website

Is OnPush Change Detection failing to detect state changes?

When using TypeORM's save() method with an array of objects, the @PrimaryColumn() annotations are ignored, resulting

Is there a way to incorporate several select choices using specific HTML?

The attribute 'name' cannot be found within the class 'MyComponent'

Having trouble configuring Jest for TypeScript integration

What are the steps to styling a component with CSS Emotion?

Why is it necessary to include a dollar sign before interpolation in Angular?

Set up a personalized React component library with Material-UI integration by installing it as a private NPM package

The array used within the useEffect hook and the getCoordinates function appears to be distinct when printed with console

Struggling with continuously re-rendering a color background when using useMemo in React?

Tips for preventing the error message "The property 'map' is not present on type 'string | string[]'."

Transforming an array of JavaScript objects into arrays of key-value pairs based on a specific property with ES6 syntax

Issue with updating boolean values in reactive form controls causing functionality to not work as expected

Ways to prevent altering values in ngModel

The TypeScript alternative to Axios request with native fetch functionality

Accessing object properties on the fly in TypeScript

Guide to creating a personalized pipe that switches out periods for commas