How can i wrap the client to remove undefined from the response type?

[itoxiq]

Hello there 👋

I created a Middleware which automatically throws on all HTTP errors.
This ensures that only 2xx requests are received directly by my client.

This currently requires me to always check if the error object in the response exists -> only then the type is narrowed down from SomeResponseType | undefined to just SomeResponseType.

I tried building a wrapper which removes the undefined from the return type of the GET/PUT/POST/DELETE functions, but was unsuccessful after many attempts :/

Do you have advice or is there a better way to archive this? :)

[iampava]

+1 on this one

[potatohoney-p]

You can wrap the returned promise instead of reimplementing all the generic GET/POST signatures. That leaves the client's path, parameter and body checking intact:

async function requireData<T>(
  pending: Promise<{ data?: T; error?: unknown; response: Response }>,
) {
  const { data, error, response } = await pending;

  if (!response.ok) {
    throw new Error(`HTTP ${response.status}`, { cause: error });
  }
  if (data === undefined) {
    throw new Error(`Expected a response body, received HTTP ${response.status}`);
  }

  return data;
}

const user = await requireData(client.GET('/users/{id}', {
  params: { path: { id: '123' } },
}));
// Inferred response body type, without undefined.

The missing-body check matters even with your middleware: a successful 204, HEAD, or empty response can legitimately have data: undefined. This helper is deliberately for calls where you require a body; keep the ordinary result for endpoints where no content is valid. It preserves JSON null rather than applying NonNullable to every response.

Your middleware can stay in place. Exceptions it throws propagate through this helper; the explicit HTTP check also makes the helper usable without it. Middleware changes runtime behavior, but it doesn't change the client's declared success/error return union.

Checked with openapi-fetch@0.17.0 and TypeScript 5.9.3 in strict mode: the body type is retained without casts, HTTP errors and 204s reject, JSON null stays nullable, and parseAs: 'text' still infers string.