Handling Type Inference for Custom Response Wrapping in Elysia with Eden and TypeScript

[santhaug]

Hi everyone,

I'm using Elysia with Eden to build my API, and I'm facing an issue with TypeScript type inference when applying a custom response wrapping plugin.

I have a mapResponse plugin that wraps all my API responses in a custom structure to maintain a consistent response format across all endpoints. The structure looks like this:

{
  status: {
    success: boolean;
    code: number;
    message: string;
  };
  error: {
    name?: string;
    message?: string;
  };
  data: T; // Original response data
}

Here is a simplified version of the mapResponse plugin:

import { Elysia } from 'elysia';

export const mapResponse = () =>
  new Elysia()
    .mapResponse(({ response, set }) => {
      return {
        status: {
          success: set.status < 400,
          code: set.status,
          message: 'OK',
        },
        error: {},
        data: response,
      };
    })
    .as('plugin');

For example, I have a simple health check route:

import { Elysia, t } from 'elysia';

new Elysia({ prefix: '/health' })
  .get(
    '/',
    () => {
      return { health: 'Ok' };
    },
    {
      response: t.Object({
        health: t.String(),
      }),
    }
  );

TypeScript infers the response types based on the handler's return value (unwrapped data), leading to type mismatches in my client code.

In the images, you can see that the inferred type for data is { health: string; }, but due to the response wrapping, the actual response is:

{
  status: {
    success: true,
    code: 200,
    message: 'OK',
  },
  error: {},
  data: {
    health: 'Ok',
  },
}

Similarly, for errors, the inferred type does not match the wrapped error structure.

My Question:

What's the best way to handle this situation?

I want to avoid modifying each handler to return the wrapped response directly, as it duplicates the logic in the mapResponse plugin. I'm looking for a solution that allows me to keep my handlers clean and have the type inference correctly reflect the wrapped response structure.

I'm eager to hear your suggestions and best practices for this scenario.
Thank you!