Response status code being typed as any `number`

[Mahi]

Prerequisites

• I have written a descriptive issue title
• I have searched existing issues to ensure the bug has not already been reported

Fastify version

5.1.0

Plugin version

5.1.0

Node.js version

22.13.0

Operating system

Linux

Operating system version (i.e. 20.04, 11.3, 10)

Fedora 41

Description

The following code doesn't error:

import fastify from 'fastify';
import {Type, TypeBoxTypeProvider} from '@fastify/type-provider-typebox';

const server = fastify().withTypeProvider<TypeBoxTypeProvider>();

server.get(
  '/',
  {
    schema: {
      response: {
        200: Type.String(),
        500: Type.Boolean(),
      },
    },
  },
  async (req, reply) => {
    // this works as expected (payload type incorrect):
    reply.status(200).send(false);

    // but this doesn't error, passes silently
    reply.status(300).send('asd');
  }
);

Expected Behavior

I would expect the reply.status() to be typed as (status: 200 | 500) but it's just (status: number) instead.

My expected behavior is also how it works out-of-the-box in fastify as well:

[Uzlopak]

Why should be only 200 or 500 be valid. It could be any positive integer number.

[Mahi]

Why should be only 200 or 500 be valid. It could be any positive integer number.

Because the response is documented as:

schema: {
  response: {
    200: Type.String(),
    500: Type.Boolean(),
  },
},

If the route had other possible return codes, I would have documented those. And since I haven't, those should be the only valid options. Which I'm obviously expecting the type checker to support, just like it does with the payload type.

[Uzlopak]

You make it look like a trivial change, which it possibly isnt.
You are welcome to propose a PR to handle this case.

[Mahi]

You make it look like a trivial change

I have not said such thing, you are drawing conclusions.

You are welcome to propose a PR to handle this case.

I have no idea where you're coming from, I merely reported an issue on the project's GitHub issues page. That's what you're supposed to do when you face a bug in someone else's project. I have no time or interest in fixing the bug myself.

[Mahi]

Also this is how fastify works out of the box, so clearly the type provider is lacking:

[Eomm]

Not a strong TS user here, but I tend to agree that the only status codes accepted should be the ones listed by the user.

I can see only an issue, because in plain js you can define "2xx" as response schema key. In this case we should accept 201, 202, ..., 299

[jsumners]

I have no time or interest in fixing the bug myself.

That is fine, but do not expect someone to pick it up unless they are also facing the same issue. The Fastify project is a community driven project. It is advanced by people working on the issues that draw their attention/needs.

[drewloomer]

This seems to be because of the ReplyKeysToCodes type in Fastify not being passed the correct value for Key. Backtracking a bit, FastifyReply tries to parse valid codes from RouteGeneric['Reply'], but for whatever reason that part of the schema isn't passed around correctly. That's kind of where I lose the thread about what's going on, so I haven't identified the root cause.

I do, however, have a workaround.

type TypedFastifySchema<
  R extends TSchema = TSchema,
  B extends TSchema = TSchema,
  Q extends TSchema = TSchema,
  P extends TSchema = TSchema,
  H extends TSchema = TSchema,
> = {
  description: string;
  tags: string[];
  body?: B;
  querystring?: Q;
  params?: P;
  headers?: H;
  response: R;
};

type TypedRoute<Schema extends TypedFastifySchema> = {
  Reply: {
    [Code in keyof Schema["response"]]: Static<Schema["response"][Code]>;
  };
  Body: Schema["body"];
  Querystring: Schema["querystring"];
  Params: Schema["params"];
  Headers: Schema["headers"];
};

const exampleSchema = {
  description: "Validate response codes",
  tags: ["example"],
  body: Type.Object({}),
  response: {
    200: Type.Object({}),
    404: Type.Object({}),
    500: Type.Object({}),
  },
} as const satisfies TypedFastifySchema;

export const exampleRouter = (async (app) => {
  app.post<TypedRoute<typeof exampleSchema>>(
    "/",
    { schema: exampleSchema },
    async (req, res) => {
      // Argument of type '300' is not assignable to parameter of type '200 | 404 | 500'
      // return res.status(300).send({});
      return res.status(200).send({});
    },
  );
}) satisfies FastifyPluginAsyncTypebox;