Angular v20
WARNING
Angular client is currently in beta. The interface might change before it becomes stable. We encourage you to leave feedback on GitHub.
About
Angular is a web framework that empowers developers to build fast, reliable applications.
The Angular client for Hey API generates a type-safe client from your OpenAPI spec, fully compatible with validators, transformers, and all core features.
Collaborators
Features
- Angular v20 support
- seamless integration with
@hey-api/openapi-tsecosystem - type-safe response data and errors
- support for
@Injectable()decorators - response data validation and transformation
- access to the original request and response
- granular request and response customization options
- minimal learning curve thanks to extending the underlying technology
- support bundling inside the generated output
Installation
In your configuration, add @hey-api/client-angular to your plugins and you'll be ready to generate client artifacts. 🎉
export default {
input: 'hey-api/backend', // sign up at app.heyapi.dev
output: 'src/client',
plugins: ['@hey-api/client-angular'],
};npx @hey-api/openapi-ts \
-i hey-api/backend \
-o src/client \
-c @hey-api/client-angularProviders
You can use the Angular client in your application by adding provideHeyApiClient to your providers.
import { provideHeyApiClient, client } from './client/client.gen';
export const appConfig: ApplicationConfig = {
providers: [
provideHttpClient(withFetch()),
provideHeyApiClient(client),
],
};Configuration
The Angular client is built as a thin wrapper on top of Angular, extending its functionality to work with Hey API. If you're already familiar with Angular, configuring your client will feel like working directly with Angular.
When we installed the client above, it created a client.gen.ts file. You will most likely want to configure the exported client instance. There are two ways to do that.
setConfig()
This is the simpler approach. You can call the setConfig() method at the beginning of your application or anytime you need to update the client configuration. You can pass any HttpRequest configuration option to setConfig(), and even your own httpClient implementation.
import { client } from 'client/client.gen';
client.setConfig({
baseUrl: 'https://example.com',
});The disadvantage of this approach is that your code may call the client instance before it's configured for the first time. Depending on your use case, you might need to use the second approach.
Runtime API
Since client.gen.ts is a generated file, we can't directly modify it. Instead, we can tell our configuration to use a custom file implementing the Runtime API. We do that by specifying the runtimeConfigPath option.
export default {
input: 'hey-api/backend', // sign up at app.heyapi.dev
output: 'src/client',
plugins: [
{
name: '@hey-api/client-angular',
runtimeConfigPath: './src/hey-api.ts',
},
],
};In our custom file, we need to export a createClientConfig() method. This function is a simple wrapper allowing us to override configuration values.
import type { CreateClientConfig } from './client/client.gen';
export const createClientConfig: CreateClientConfig = (config) => ({
...config,
baseUrl: 'https://example.com',
});With this approach, client.gen.ts will call createClientConfig() before initializing the client instance. If needed, you can still use setConfig() to update the client configuration later.
createClient()
You can also create your own client instance. You can use it to manually send requests or point it to a different domain.
import { createClient } from './client/client';
const myClient = createClient({
baseUrl: 'https://example.com',
});You can also pass this instance to any SDK function through the client option. This will override the default instance from client.gen.ts.
const response = await getFoo({
client: myClient,
});SDKs
Alternatively, you can pass the client configuration options to each SDK function. This is useful if you don't want to create a client instance for one-off use cases.
const response = await getFoo({
baseUrl: 'https://example.com', // <-- override default configuration
});@Injectable
If you prefer to use the @Injectable() decorators, set the asClass option in your SDK plugin to true.
@Injectable({ providedIn: 'root' })
export class FooService {
// class methods
}export default {
input: 'hey-api/backend', // sign up at app.heyapi.dev
output: 'src/client',
plugins: [
'@hey-api/client-angular',
{
name: '@hey-api/sdk',
asClass: true,
},
],
};Interceptors
WARNING
This section is under construction. We appreciate your patience.
Auth
WARNING
This section is under construction. We appreciate your patience.
Build URL
If you need to access the compiled URL, you can use the buildUrl() method. It's loosely typed by default to accept almost any value; in practice, you will want to pass a type hint.
type FooData = {
path: {
fooId: number;
};
query?: {
bar?: string;
};
url: '/foo/{fooId}';
};
const url = client.buildUrl<FooData>({
path: {
fooId: 1,
},
query: {
bar: 'baz',
},
url: '/foo/{fooId}',
});
console.log(url); // prints '/foo/1?bar=baz'Custom httpClient
You can implement your own httpClient. This is useful if you need to extend the default httpClient methods with extra functionality, or replace it altogether.
import { client } from 'client/client.gen';
client.setConfig({
httpClient: inject(CustomHttpClient),
});You can use any of the approaches mentioned in Configuration, depending on how granular you want your custom client to be.
Plugins
You might be also interested in the Angular plugin.
API
You can view the complete list of options in the UserConfig interface.
Examples
You can view live examples on StackBlitz.
Sponsors
Help Hey API stay around for the long haul by becoming a sponsor.
