Add configurable default value for ThrowOnError

[MrLepage]

Currently, services generated code sets the default value of ThrowOnError to false for all API request functions. This default behavior requires developers to explicitly set ThrowOnError to true for each individual API call when they want exceptions to be thrown on errors.

I propose adding a configuration option that allows setting the default value of ThrowOnError globally. This enhancement would significantly improve developer experience and code consistency for projects that prefer a "throw-by-default" error handling strategy.

Proposed changes:

• Add a new configuration option in the configuration file to set the default ThrowOnError value.
• Update the code generation logic to use this configured default when generating API request functions.

Example configuration:

export default defineConfig({
  // ... other configuration options
  services: {
    throwOnError: true, // New option
  },
});

With this configuration, all generated API request functions would default to throwing errors unless explicitly overridden.

Benefits:

• Improved code consistency across the application.
• Reduced boilerplate by eliminating the need to specify or throwOnError: true for each API call.
• Better alignment with different error handling strategies preferred by different development teams.
• Maintains flexibility by still allowing per-request override of the behavior.

[snarky-puppy]

Agree that this should be a generator option.

Meanwhile my work around is to add this post-generator step:

find ./src/clients -type f | xargs perl -pi -e 's/ThrowOnError extends boolean = false/ThrowOnError extends boolean = true/'

[smiley-uriux]

This was the first blocker I hit. When reviewing the docs I just assumed there was a way to configure this globally since the hard part appears to have been done (i.e. altering typescript types and allowing the config value to be specified at the individual method level). It's even more confusing because you can actually configure it with client.setConfig({ throwOnError: true}) but that won't alter the typescript types obviously. Ideally this configuration would live at the top-level as OP suggested and removed from client setConfig() method to avoid confusion.

@snarky-puppy thanks for the snippet. That looks like it would address the inferred return types only so those finding this should be aware that client.setConfig({ throwOnError: true }) also needs to called somewhere.

Otherwise love with this library is going!

[jpenna]

Liked the solution presented by the OP. This should be included in the CLI too.

In the meantime, using the solution proposed by @snarky-puppy above, but in a JS script:

function replaceThrowOnError() {
  const clientFile = './src/client/services.gen.ts';
  fs.readFile(clientFile, 'utf8', (err, data) => {
    if (err) {
      console.error('Error:', err);
      return;
    }
    const result = data.replace(
      /ThrowOnError extends boolean = false/g,
      'ThrowOnError extends boolean = true',
    );
    fs.writeFile(clientFile, result, 'utf8', (err) => {
      if (err) {
        console.error('Error:', err);
        return;
      }
      console.info('ThrowOnError default replaced successfully!');
    });
  });
}

[amiryadid]

Would be really glad for this kind of feature, in general passing a client-per-call is a little cumbersome but together with this config it adds a lot of overhead to each call

[modosc]

we are using "@hey-api/client-axios and in addition to the previously mentioned changes we also had to change RequestOptionsBase<false> and Config<false> to true in client/types.ts.

[nimobeeren]

I also agree that a config option on the @hey-api/sdk plugin would be a nice way to set throwOnError to true by default, both in the generated SDK types as well as the runtime client, if possible.

For now, here is a script putting @jpenna's solution together with the openapi-ts client generation. It generates the client in the same way that running npx openapi-ts would, then changes the types using simple find/replace. It uses my openapi-ts.config.ts to set the config and determine the path of the generated file to change. I run it using tsx through a script in my package.json.

import { readFile, writeFile } from "fs/promises";
import path from "path";

import { createClient } from "@hey-api/openapi-ts";
import config from "./openapi-ts.config";

// This script generates an API client just like `npx openapi-ts` would, but changing the types to
// set ThrowOnError to true by default. Note that this only changes the types; you also need to do
// `client.setConfig({ throwOnError: true })` to get it to actually throw at runtime.

await createClient(config);

const sdkPath = path.resolve(
  typeof config.output === "string" ? config.output : config.output.path,
  "sdk.gen.ts",
);

let sdkContent = await readFile(sdkPath, { encoding: "utf-8" });

sdkContent = sdkContent.replace(
  /ThrowOnError extends boolean = false/g,
  "ThrowOnError extends boolean = true",
);

await writeFile(sdkPath, sdkContent, { encoding: "utf-8" });

Here is the full commit in my project where I get this to work.

[mrlubos]

Whoah, I didn't realise this issue has already so many upvotes. We can add it to SDK options. It won't be perfect, but should unblock a bunch of folks here