Enums aren't generated to OAS/Swagger Specification

[marclave]

I might be doing something wrong, but when i make an endpoint with an enum in the body i don't get the enum in the swagger file

import { Elysia, t } from 'elysia'

export const plugin = new Elysia({
    prefix: '/a'
})
    .post('/hello-world', ({ body }) => body, {
        body: t.Object({
            type: t.Enum({
                MOD: 'mod_skin',
                VIP: 'vip_skin',
            })
        }),
    })

the output is

"requestBody": {
        "content": {
          "application/json": {
            "schema": {
              "type": "object",
              "properties": {
                "type": {
                  "anyOf": [
                    {
                      "const": "mod_skin",
                      "type": "string"
                    },
                    {
                      "const": "vip_skin",
                      "type": "string"
                    },

vs

schema:
            type: string
            enum: [asc, desc]

so the rendered output is either

Scalar

Swagger UI

let me know if it's something I can change or if it's something we need to add to the swagger generation code ✨

[Nmans01]

+1, I've just noticed the same.

[rottmann]

Same with Union and Literal.

[nxht]

As it seems Typebox won't implement OpenAPI compatible schema, I think it'd be good to have custom Typebox schema for enum in elysia, or elysia-swagger.

For example, here's the way I'm currently handling enums.

import type { StringOptions, TSchema } from '@sinclair/typebox';
import { Kind, TypeGuard, TypeRegistry } from '@sinclair/typebox';

export type StringEnumOption = StringOptions;

export type TStringEnum = TSchema &
  StringOptions & {
    [Kind]: 'StringEnum';
    static: string;
    type: 'string';
    enum: string[];
  };

export const tStringEnum = (
  enumStrings: string[],
  options: StringEnumOption = {},
): TStringEnum => {
  const { ...stringOptions } = options;

  return {
    ...stringOptions,
    enum: enumStrings,
    [Kind]: 'StringEnum',
    type: 'string',
    error: `Invalid enum value. Expected: ['${enumStrings.join("','")}']`,
  } as TStringEnum;
};

TypeRegistry.Set<TStringEnum>('StringEnum', (schema, value) => {
  if (typeof value !== 'string') return false;

  if (schema.enum.includes(value)) {
    return true;
  }
  return false;
});

Usage example

const YN = tStringEnum(['Y', 'N'], { maxLength: 1 })

And the result schema

{
  "YN": {
    "maxLength": 1,
    "enum": [
      "Y",
      "N"
    ],
    "type": "string"
  }
}