Hoping to wrap the client for single arg calls

[morleytatro]

Description

This library is super helpful. I'm looking to essentially pass in all options in one shot vs. creating the client, specifying the method, and then the path, as the generated OpenAPI spec spans a ton of files. Also, I'd like to throw on error vs. having to check data/errors.

So far, I've been using this workaround, which is nice, but not as simple as I'd like.

export function getClient<Paths extends {}>() {
  const client = createClient<Paths>({ baseUrl });
  client.use({
    async onRequest(req) {
      req.headers.set('Authorization', `Bearer ${await getToken()}`);
      return req;
    },
  });
  return client;
}

export function transformResult<T, E extends Error>({
  data,
  error,
}: { data: T; error: undefined } | { data: undefined; error: E }) {
  if (data) {
    return data;
  }
  throw error;
}

const result = await getClient<paths>()
  .GET('/some-path', {
    params: //...
  })
  .then(transformResult);

Proposal

What I'm going for is something like this syntax, but I can't for the life of me seem to get the types to line up:

export async function makeCall<
  TPaths extends {},
  TMethod extends HttpMethod = 'get',
  TEndpoint extends keyof PathsWithMethod<TPaths, TMethod> = string,
>({
  endpoint,
  method,
  args,
}: {
  endpoint: TEndpoint;
  method: TMethod;
  args: MaybeOptionalInit<TPaths[TEndpoint][TMethod], TMethod>;
}): Promise<SuccessResponseJSON<TPaths[TEndpoint][TMethod]>> {
  const client = getClient<TPaths>();
  return await client[method.toUpperCase()](endpoint, args).then(
    transformResult,
  );
}

const result = await makeCall<paths>({
  endpoint: '/some-endpoint',
  method: 'get',
  args: {
    params: {
      // ...
    },
  },
});

Checklist

I'm definitely open to helping, but like I said I've struck out thus far. Not even sure it's possible given the current method/path approach in play.

• I’m willing to open a PR for this (see CONTRIBUTING.md)