Should endpoints be able to handle multiple schemas?

[felzix]

This code does not work. Build error:

Argument of type '{ status: string; error: string; }' is not assignable to parameter of type 'never'.

It seems obvious to me that this should work but the documentation doesn't have anything to say about this usecase. AFAIK this is precisely how HTTP is intended to be used, especially when implementing a CRUD-like interface.

I tried a few variations without success.

const createApiEndpointFactory = <T extends z.ZodType>(schema: T) =>
  new EndpointsFactory(
    new ResultHandler({
      positive: [
        {
          statusCode: 200,
          schema,
        },
        {
          statusCode: 204,
          mimeType: null,
          schema: z.never(),
        },
      ],
      negative: [
        {
          statusCode: [400, 500],
          schema: z.object({ status: z.literal("error"), error: z.string() }),
        },
        {
          statusCode: 404,
          mimeType: null,
          schema: z.never(),
        },
      ],
      handler: ({ error, response, output }) => {
        if (error) {
          const statusCode =
            error instanceof createHttpError.HttpError ? error.statusCode : 500;

          if (statusCode === 404) return void response.status(404);
          if (statusCode === 400 || statusCode === 500)
            // ERROR BELOW
            return void response.status(statusCode).json({
              status: "error" as "error",
              error: error.message,
            });
        } else {
          // ignore this for now
          if (output) return void response.status(200).json(output);
          else return void response.status(204);
        }
      },
    })
  );

(I searched for similar questions but I didn't see any titles that looked promising. I might have missed something.)

[felzix]

Dammit I found the answer. Nevermind.

[felzix]

Seems that the "correct" solution throws out the typing information, so the handler implementation isn't type-checked. The broader type is still reflected in the generated client but the "never" type is simply gone - my 200 and 204 both use the same type:

type GetApiV1SkillPositiveVariant1 = {
  data: {
    skills: string[];
  };
};

So... I guess this library only supports the extremely common but incorrect HTTP usage. Blast.

[RobinTail]

Hello @felzix ,

this is the way:

new EndpointsFactory(
    new ResultHandler({
      positive: (schema) => [ // <— fn argument should go here
        {
          statusCode: 200,
          schema,
        },
        {
          statusCode: 204,
          mimeType: null,
          schema: z.never(),
        },
      ],
// ...

Then there is no error.