Array syntax for enums

[guyariely]

Currently, when orval parses enums, it generates an object and a type (which is derived from the object). For example:

export type GameLevel = typeof GameLevel[keyof typeof GameLevel];

// @eslint-disable typescript-eslint/no-redeclare
export const GameLevel = {
  A: "A",
  B: "B",
  C: "C",
} as const;

I think there are a few benefits of generating an array, rather than an object:

export const GameLevelArray = ["A", "B", "C"] as const;

Zod enums

Using the array syntax works very well with zod enums:

const GameLevelEnum = z.enum(GameLevelArray);
type GameLevelEnum = z.infer<typeof GameLevelEnum>; // 'A' | 'B' | 'C'

But not with the object syntax:

const GameLevelEnum = z.enum(Object.keys(GameLevel));
type GameLevelEnum = z.infer<typeof GameLevelEnum>; // string

Better inference when iterating

In the array syntax:

GameLevelArray.map(level => {
  level; // inferred as 'A' | 'B' | 'C'
});

In the object syntax:

Object.keys(GameLevel).map(level => {
  level; // inferred as string
});

Type guard

Using the array syntax can be used as a type guard:

function foo(level: string) {
  if (GameLevelArray.includes(level)) {
    level; // inferred as 'A' | 'B' | 'C'
  }
}

Which does not work with the object syntax:

function foo(level: string) {
  if (Object.keys(GameLevel).includes(level)) {
    level; // inferred as string
  }

  if (level in GameLevel) {
    level; // inferred as string
  }
}

Note that this currectly only works when updating the includes signature like this.

Conclusion

These are just some of the use cases I found for using the array syntax while working on a large typescript project that is using orval heavily. On the other hand, I did not find any use (yet) to the object syntax.

What is your opinion on adding an option to orval config to choose how the enums will be generated?

[melloware]

In 6.24.0 you can generate native Typescript enums now with an option.