feat(client): implement Angular HTTP client for API interactions

- Added client generation code to handle API requests using Angular's HttpClient.
- Introduced utility functions for building URLs, merging configurations, and handling headers.
- Implemented request and response interceptors for enhanced request handling.
- Created types for request options, response styles, and client configuration.
- Developed authentication handling with support for various auth schemes.
- Added body and query parameter serialization utilities for request formatting.
- Established a flexible configuration system for client initialization and request customization.

Author: max-scopp

examples/openapi-ts-angular/package.json

@@ -12,11 +12,14 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
+    "@angular/common": "20.1.6",
+    "@angular/core": "20.1.6",
     "@radix-ui/react-form": "0.1.1",
     "@radix-ui/react-icons": "1.3.2",
     "@radix-ui/themes": "3.1.6",
     "react": "19.0.0",
-    "react-dom": "19.0.0"
+    "react-dom": "19.0.0",
+    "rxjs": "7.8.2"
   },
   "devDependencies": {
     "@config/vite-base": "workspace:*",

examples/openapi-ts-angular/src/client/client/client.gen.ts

@@ -0,0 +1,162 @@
+import type { HttpResponse } from '@angular/common/http';
+import { HttpClient, HttpEventType, HttpRequest } from '@angular/common/http';
+import {
+  assertInInjectionContext,
+  inject,
+  provideAppInitializer,
+} from '@angular/core';
+import { firstValueFrom } from 'rxjs';
+import { filter } from 'rxjs/operators';
+
+import type { Client, Config, ResolvedRequestOptions } from './types.gen';
+import {
+  buildUrl,
+  createConfig,
+  createInterceptors,
+  mergeConfigs,
+  mergeHeaders,
+  setAuthParams,
+} from './utils.gen';
+
+export function provideHeyApiClient(client: Client) {
+  return provideAppInitializer(() => {
+    const httpClient = inject(HttpClient);
+    client.setConfig({ httpClient });
+  });
+}
+
+export const createClient = (config: Config = {}): Client => {
+  let _config = mergeConfigs(createConfig(), config);
+
+  const getConfig = (): Config => ({ ..._config });
+
+  const setConfig = (config: Config): Config => {
+    _config = mergeConfigs(_config, config);
+    return getConfig();
+  };
+
+  const interceptors = createInterceptors<
+    HttpRequest<unknown>,
+    HttpResponse<unknown>,
+    unknown,
+    ResolvedRequestOptions
+  >();
+
+  const request: Client['request'] = async (options) => {
+    const opts = {
+      ..._config,
+      ...options,
+      headers: mergeHeaders(_config.headers, options.headers),
+      httpClient: options.httpClient ?? _config.httpClient,
+      serializedBody: undefined,
+    };
+
+    if (!opts.httpClient) {
+      assertInInjectionContext(request);
+      opts.httpClient = inject(HttpClient);
+    }
+
+    if (opts.security) {
+      await setAuthParams({
+        ...opts,
+        security: opts.security,
+      });
+    }
+
+    if (opts.requestValidator) {
+      await opts.requestValidator(opts);
+    }
+
+    if (opts.body && opts.bodySerializer) {
+      opts.serializedBody = opts.bodySerializer(opts.body);
+    }
+
+    // remove Content-Type header if body is empty to avoid sending invalid requests
+    if (opts.serializedBody === undefined || opts.serializedBody === '') {
+      opts.headers.delete('Content-Type');
+    }
+
+    const url = buildUrl(opts);
+
+    let req = new HttpRequest<unknown>(opts.method, url, {
+      redirect: 'follow',
+      ...opts,
+      body: opts.serializedBody,
+    });
+
+    for (const fn of interceptors.request._fns) {
+      if (fn) {
+        req = await fn(req, opts);
+      }
+    }
+
+    let response;
+    const result = {
+      request: req,
+      response,
+    };
+
+    try {
+      response = await firstValueFrom(
+        opts.httpClient
+          .request(req)
+          .pipe(filter((event) => event.type === HttpEventType.Response)),
+      );
+
+      for (const fn of interceptors.response._fns) {
+        if (fn) {
+          response = await fn(response, req, opts);
+        }
+      }
+
+      let bodyResponse = response.body as Record<string, unknown>;
+
+      if (opts.responseValidator) {
+        await opts.responseValidator(bodyResponse);
+      }
+
+      if (opts.responseTransformer) {
+        bodyResponse = (await opts.responseTransformer(bodyResponse)) as Record<
+          string,
+          unknown
+        >;
+      }
+
+      return (
+        opts.responseStyle === 'data'
+          ? bodyResponse
+          : { data: bodyResponse, ...result }
+      ) as any;
+    } catch (error) {
+      for (const fn of interceptors.error._fns) {
+        if (fn) {
+          (await fn(error, response!, req, opts)) as string;
+        }
+      }
+
+      return opts.responseStyle === 'data'
+        ? undefined
+        : {
+            error,
+            ...result,
+          };
+    }
+  };
+
+  return {
+    buildUrl,
+    connect: (options) => request({ ...options, method: 'CONNECT' }),
+    delete: (options) => request({ ...options, method: 'DELETE' }),
+    get: (options) => request({ ...options, method: 'GET' }),
+    getConfig,
+    head: (options) => request({ ...options, method: 'HEAD' }),
+    interceptors,
+    options: (options) => request({ ...options, method: 'OPTIONS' }),
+    patch: (options) => request({ ...options, method: 'PATCH' }),
+    post: (options) => request({ ...options, method: 'POST' }),
+    put: (options) => request({ ...options, method: 'PUT' }),
+    request,
+    setConfig,
+    trace: (options) => request({ ...options, method: 'TRACE' }),
+  };
+};