RPC Discriminated Union Inferred Type?

[stephencweiss]

Is there a way to have an inferred discriminated union type in a response for an API?

For example:

const signinVerify = signinAPI.post(
  "/verify",
  validator("form", (value, c) => {
    const parsed = VerifyRequestSchema.safeParse(value);
    if (!parsed.success) {
      errnote("Invalid verification request", parsed.error);
      return c.json({ error: "Invalid request!" }, 401);
    }
    return parsed.data;
  }),
  async (c) => {
    const { code } = c.req.valid("form");
    const res = await verify(code);

    if (res === 'approved') {
      // Retrieve user data from database...
      const user = db.getUser();
      return c.jsonT({
        // Fake data to demonstrate how it might work
        otpStatus: res,
        ...user
      }, 200);
    } else {
      return c.jsonT({
        otpStatus: res,
      }, 200)
    }
  },
);



type SigninVerifyResponse = typeof signinVerify;
export type SigninAPI =
  | SigninVerifyResponse

Specifically - this works if I only have one jsonT, but when I make the second one also jsonT, then I get the following type error:

No overload matches this call.
  The last overload gave the following error.
    Argument of type 'MiddlewareHandler<Env, "/verify", { in: { form: { code: string; }; }; out: { form: { code: string; }; }; }>' is not assignable to parameter of type 'H<Env, "/api/signin/verify", { in: { form: { code: string; }; }; out: { form: { code: string; }; }; }, { otpStatus: "approved"; userId: string; invitedBy: string; cliqId: string; }>'.
      Type 'MiddlewareHandler<Env, "/verify", { in: { form: { code: string; }; }; out: { form: { code: string; }; }; }>' is not assignable to type 'MiddlewareHandler<Env, "/api/signin/verify", { in: { form: { code: string; }; }; out: { form: { code: string; }; }; }>'.
        Types of parameters 'c' and 'c' are incompatible.
          Type 'Context<Env, "/api/signin/verify", { in: { form: { code: string; }; }; out: { form: { code: string; }; }; }>' is not assignable to type 'Context<Env, "/verify", { in: { form: { code: string; }; }; out: { form: { code: string; }; }; }>'.
            Types of property 'req' are incompatible.
              Type 'HonoRequest<"/api/signin/verify", { form: { code: string; }; }>' is not assignable to type 'HonoRequest<"/verify", { form: { code: string; }; }>'.
                Type '"/api/signin/verify"' is not assignable to type '"/verify"'.

[stephencweiss]

FWIW - it seems like the infer guide returns the same thing I get from the RPC types via jsonT

[stephencweiss]

One possible approach is to simply not use the jsonT and define it myself. This is obviously not ideal as it means that it doesn't stay up to date automatically:

const SigninVerifyResponseSuccessSchema = z.object({
  ...UserSchema.shape,
  otpStatus: z.enum(["approved"]),
});
const SignInVerifyBaseResponseSchema = z.object({
  otpStatus: z.enum(["pending", "canceled"]),
});

const SigninVerifyResponseSchema = z.union([
  SigninVerifyResponseSuccessSchema,
  SignInVerifyBaseResponseSchema,
]);
export type SigninVerifyResponseDTO = z.infer<typeof SigninVerifyResponseSchema>;

Though - it gets me part of the way there, so this is the general approach I'm taking at the moment.