ngx-openapi-typescript 0.0.1

package/README.md

@@ -0,0 +1,139 @@
+# ngx-openapi-typescript
+
+Type-safe Angular resource signals and HTTP client backed by [openapi-typescript](https://openapi-ts.dev/).
+
+This library provides two main utilities:
+
+- **`createOpenApiResource`** — a reactive factory built on Angular's `httpResource` that gives you compile-time type safety for every HTTP request and response shape defined in your OpenAPI schema.
+- **`OpenApiHttpClient`** — a typed wrapper around Angular's `HttpClient` for imperative (non-reactive) HTTP calls.
+
+Both are driven by the types generated by `openapi-typescript`, so typos in paths, wrong parameter names, or incorrect body shapes are caught at **compile time**, not at runtime.
+
+## Installation
+
+```sh
+npm install ngx-openapi-typescript openapi-typescript-helpers
+```
+
+This package is built for Angular `^21.2.0` and `^22.0.0` and expects these peer dependencies in your app:
+
+- `@angular/common ^21.2.0 || ^22.0.0`
+- `@angular/core ^21.2.0 || ^22.0.0`
+- `openapi-typescript-helpers ^0.1.0`
+
+If you want to generate types locally, also install the generator as a dev dependency:
+
+```sh
+npm install -D openapi-typescript
+```
+
+## Generating types
+
+Generate type definitions by pointing `openapi-typescript` at your OpenAPI spec:
+
+```sh
+npx openapi-typescript https://api.example.com/openapi.yaml -o src/api.types.ts
+```
+
+This creates a `paths` interface that both utilities consume.
+
+## API
+
+### `createOpenApiResource`
+
+A factory for creating reactive Angular resource signals. Must be called inside an Angular injection context (component/service field initializer or constructor).
+
+```ts
+import type { paths } from './api.types';
+import { createOpenApiResource } from 'ngx-openapi-typescript';
+
+@Component({ ... })
+export class PetListComponent {
+  // Set up once per component/service
+  private readonly api = createOpenApiResource<paths>({
+    baseUrl: 'https://api.example.com',
+  });
+
+  // Simple GET — no params required
+  protected readonly pets = this.api('/pets');
+
+  // Reactive GET with params — re-fetches when the signals read inside the lambda change
+  protected readonly petsLimited = this.api('/pets', () => ({
+    params: { query: { limit: 10 } },
+  }));
+
+  // Pass signal-driven path params — re-fetches when petId() changes
+  private readonly petId = signal(1);
+  protected readonly pet = this.api('/pets/{petId}', () => ({
+    params: { path: { petId: this.petId() } },
+  }));
+
+  // Return undefined to put the resource in Idle state (no request made)
+  private readonly enabled = signal(false);
+  protected readonly lazyPets = this.api('/pets', () =>
+    this.enabled() ? {} : undefined,
+  );
+}
+```
+
+#### Method Override
+
+The factory defaults to GET. You can pass a `method` option to use a different HTTP method,
+but Angular recommends using `httpResource` only for reads. Prefer `OpenApiHttpClient` for mutations.
+
+```ts
+// Explicit method override (not recommended for production use)
+protected readonly createResult = this.api('/pets', () => ({
+  body: { name: 'Buddy' },
+}), { method: 'post' });
+```
+
+### `OpenApiHttpClient`
+
+A base class that wraps Angular's `HttpClient` with OpenAPI types. Ideal for imperative calls, mutations, or service-layer code.
+
+```ts
+import type { paths } from './api.types';
+import { OpenApiHttpClient } from 'ngx-openapi-typescript';
+import { Injectable } from '@angular/core';
+
+@Injectable({ providedIn: 'root' })
+export class PetApiClient extends OpenApiHttpClient<paths> {
+  constructor() {
+    super({ baseUrl: 'https://api.example.com' });
+  }
+}
+```
+
+```ts
+// In a component/service
+@Component({ ... })
+export class PetDetailComponent {
+  private readonly api = inject(PetApiClient);
+
+  load(id: number) {
+    this.api
+      .get('/pets/{petId}', { params: { path: { petId: id } } })
+      .subscribe(pet => console.log(pet)); // pet is typed as Pet
+  }
+
+  create(name: string) {
+    this.api
+      .post('/pets', { body: { name } })
+      .subscribe(newPet => console.log(newPet));
+  }
+}
+```
+
+## Development
+
+```sh
+# Build the library
+ng build ngx-openapi-typescript
+
+# Run tests
+ng test ngx-openapi-typescript
+
+# Start the demo app
+ng serve demo
+```

package/fesm2022/ngx-openapi-typescript.mjs

@@ -0,0 +1,194 @@
+import { HttpParams, httpResource, HttpClient } from '@angular/common/http';
+import { inject } from '@angular/core';
+
+/** Builds a full URL by substituting path parameters into the path template */
+function buildUrl(baseUrl, path, pathParams) {
+    let url = baseUrl + path;
+    if (pathParams) {
+        for (const [key, value] of Object.entries(pathParams)) {
+            url = url.replace(`{${key}}`, encodeURIComponent(String(value)));
+        }
+    }
+    return url;
+}
+/** Converts a query parameter map to an `HttpParams` instance */
+function toHttpParams(query) {
+    if (!query)
+        return undefined;
+    let params = new HttpParams();
+    for (const [key, value] of Object.entries(query)) {
+        if (value === undefined || value === null)
+            continue;
+        if (Array.isArray(value)) {
+            for (const v of value) {
+                params = params.append(key, String(v));
+            }
+        }
+        else {
+            params = params.set(key, String(value));
+        }
+    }
+    return params;
+}
+
+/** Coerces the request object to a plain shape for URL building */
+function toRequestShape(req) {
+    return (req ?? {});
+}
+/**
+ * Creates a type-safe callable factory for Angular `httpResource`s backed by an OpenAPI schema.
+ *
+ * Must be called inside an Angular injection context (e.g. component/service field initializer
+ * or constructor), because the returned function uses `httpResource` internally.
+ *
+ * The returned function defaults to GET. Pass `{ method: 'post' }` (or other method) in the
+ * options to use a different HTTP method. Note: Angular recommends using `httpResource` only
+ * for reads; prefer `OpenApiHttpClient` for mutations.
+ *
+ * @example
+ * ```ts
+ * import type { paths } from './api.types'; // generated by openapi-typescript
+ *
+ * const api = createOpenApiResource<paths>({ baseUrl: 'https://api.example.com' });
+ *
+ * // Reactive GET resource (default)
+ * const pets = api('/pets', () => ({ params: { query: { limit: 10 } } }));
+ *
+ * // GET with path params (signal-driven)
+ * const petId = signal(1);
+ * const pet = api('/pets/{petId}', () => ({ params: { path: { petId: petId() } } }));
+ *
+ * // Explicit method override (prefer OpenApiHttpClient for mutations)
+ * const created = api('/pets', () => ({ body: { name: 'Buddy' } }), { method: 'post' });
+ * ```
+ */
+function createOpenApiResource(config) {
+    const baseUrl = config?.baseUrl ?? '';
+    return ((path, reqFnOrOpts, maybeOpts) => {
+        const hasRequestFn = typeof reqFnOrOpts === 'function';
+        const requestFn = hasRequestFn ? reqFnOrOpts : () => ({});
+        const options = hasRequestFn ? maybeOpts : reqFnOrOpts;
+        const method = (options?.method ?? 'get').toUpperCase();
+        return httpResource(() => {
+            const req = requestFn();
+            if (req === undefined)
+                return undefined;
+            const r = toRequestShape(req);
+            return {
+                url: buildUrl(baseUrl, path, r.params?.path),
+                method,
+                body: r.body,
+                params: toHttpParams(r.params?.query),
+                headers: r.headers,
+                context: r.context,
+                withCredentials: r.withCredentials,
+            };
+        }, options);
+    });
+}
+
+/** Coerces the options to a plain shape */
+function toShape(opts) {
+    return (opts ?? {});
+}
+function buildOptions(r) {
+    return {
+        responseType: 'json',
+        observe: 'body',
+        params: toHttpParams(r.params?.query),
+        // Cast needed: our public API allows ReadonlyArray<string> (consistent with httpResource),
+        // but Angular HttpClient methods require string[].
+        headers: r.headers,
+        context: r.context,
+        withCredentials: r.withCredentials,
+    };
+}
+/**
+ * A type-safe HTTP client for OpenAPI-described APIs.
+ *
+ * Wraps Angular's `HttpClient` and binds request/response types to an OpenAPI
+ * schema generated by `openapi-typescript`.
+ *
+ * Designed to be subclassed per-API:
+ *
+ * @example
+ * ```ts
+ * import type { paths } from './api.types'; // generated by openapi-typescript
+ *
+ * @Injectable({ providedIn: 'root' })
+ * export class PetApiClient extends OpenApiHttpClient<paths> {
+ *   constructor() {
+ *     super({ baseUrl: 'https://api.example.com' });
+ *   }
+ * }
+ * ```
+ *
+ * Or used directly inside an injection context:
+ *
+ * @example
+ * ```ts
+ * const client = new OpenApiHttpClient<paths>({ baseUrl: 'https://api.example.com' });
+ * ```
+ */
+class OpenApiHttpClient {
+    http = inject(HttpClient);
+    baseUrl;
+    constructor(config) {
+        this.baseUrl = config?.baseUrl ?? '';
+    }
+    /**
+     * Performs a typed GET request.
+     *
+     * @example
+     * ```ts
+     * client.get('/pets', { params: { query: { limit: 10 } } }).subscribe(pets => console.log(pets));
+     * ```
+     */
+    get(path, options) {
+        const r = toShape(options);
+        return this.http.get(buildUrl(this.baseUrl, String(path), r.params?.path), buildOptions(r));
+    }
+    /**
+     * Performs a typed POST request.
+     */
+    post(path, options) {
+        const r = toShape(options);
+        return this.http.post(buildUrl(this.baseUrl, String(path), r.params?.path), r.body, buildOptions(r));
+    }
+    /**
+     * Performs a typed PUT request.
+     */
+    put(path, options) {
+        const r = toShape(options);
+        return this.http.put(buildUrl(this.baseUrl, String(path), r.params?.path), r.body, buildOptions(r));
+    }
+    /**
+     * Performs a typed PATCH request.
+     */
+    patch(path, options) {
+        const r = toShape(options);
+        return this.http.patch(buildUrl(this.baseUrl, String(path), r.params?.path), r.body, buildOptions(r));
+    }
+    /**
+     * Performs a typed DELETE request.
+     */
+    delete(path, options) {
+        const r = toShape(options);
+        const httpOptions = buildOptions(r);
+        if (r.body !== undefined) {
+            httpOptions.body = r.body;
+        }
+        return this.http.delete(buildUrl(this.baseUrl, String(path), r.params?.path), httpOptions);
+    }
+}
+
+/*
+ * Public API Surface of ngx-openapi-typescript
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { OpenApiHttpClient, createOpenApiResource };
+//# sourceMappingURL=ngx-openapi-typescript.mjs.map

package/fesm2022/ngx-openapi-typescript.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ngx-openapi-typescript.mjs","sources":["../../../projects/ngx-openapi-typescript/src/lib/url-utils.ts","../../../projects/ngx-openapi-typescript/src/lib/open-api-resource.ts","../../../projects/ngx-openapi-typescript/src/lib/open-api-http-client.ts","../../../projects/ngx-openapi-typescript/src/public-api.ts","../../../projects/ngx-openapi-typescript/src/ngx-openapi-typescript.ts"],"sourcesContent":["import { HttpParams } from '@angular/common/http';\r\n\r\n/** Builds a full URL by substituting path parameters into the path template */\r\nexport function buildUrl(\r\n  baseUrl: string,\r\n  path: string,\r\n  pathParams?: Record<string, string | number | boolean>,\r\n): string {\r\n  let url = baseUrl + path;\r\n  if (pathParams) {\r\n    for (const [key, value] of Object.entries(pathParams)) {\r\n      url = url.replace(`{${key}}`, encodeURIComponent(String(value)));\r\n    }\r\n  }\r\n  return url;\r\n}\r\n\r\n/** Converts a query parameter map to an `HttpParams` instance */\r\nexport function toHttpParams(\r\n  query?: Record<\r\n    string,\r\n    string | number | boolean | ReadonlyArray<string | number | boolean> | null | undefined\r\n  >,\r\n): HttpParams | undefined {\r\n  if (!query) return undefined;\r\n  let params = new HttpParams();\r\n  for (const [key, value] of Object.entries(query)) {\r\n    if (value === undefined || value === null) continue;\r\n    if (Array.isArray(value)) {\r\n      for (const v of value) {\r\n        params = params.append(key, String(v));\r\n      }\r\n    } else {\r\n      params = params.set(key, String(value));\r\n    }\r\n  }\r\n  return params;\r\n}\r\n","import {\r\n  HttpContext,\r\n  HttpHeaders,\r\n  HttpResourceOptions,\r\n  HttpResourceRef,\r\n  httpResource,\r\n} from '@angular/common/http';\r\nimport type { PathsWithMethod, SuccessResponseJSON } from 'openapi-typescript-helpers';\r\nimport type { HasRequiredKeys, HttpMethod, OpenApiOperationRequest, PathRecord } from './types';\r\nimport { buildUrl as _buildUrl, toHttpParams as _toHttpParams } from './url-utils';\r\n\r\n// Re-export helpers so consumers and tests can import them from this module.\r\nexport { buildUrl, toHttpParams } from './url-utils';\r\n\r\n/** Configuration for creating an OpenAPI resource factory */\r\nexport interface OpenApiResourceConfig {\r\n  /** Base URL to prepend to all resource paths */\r\n  baseUrl?: string;\r\n}\r\n\r\n/** Options for the resource call, extending Angular's HttpResourceOptions with an optional HTTP method */\r\nexport type OpenApiResourceCallOptions<TValue, TError = unknown> = HttpResourceOptions<\r\n  TValue,\r\n  TError\r\n> & { method?: HttpMethod };\r\n\r\n/** Extracts the operation type for a given path and method */\r\ntype OpOf<Paths, Path extends keyof Paths, Method extends string> = Paths[Path] extends {\r\n  [K in Method]: infer Op;\r\n}\r\n  ? Op\r\n  : never;\r\n\r\n/** Coerces the request object to a plain shape for URL building */\r\nfunction toRequestShape(req: unknown): {\r\n  params?: {\r\n    path?: Record<string, string | number | boolean>;\r\n    query?: Record<string, string | number | boolean | null | undefined>;\r\n  };\r\n  body?: unknown;\r\n  headers?: HttpHeaders | Record<string, string | ReadonlyArray<string>>;\r\n  context?: HttpContext;\r\n  withCredentials?: boolean;\r\n} {\r\n  return ((req ?? {}) as ReturnType<typeof toRequestShape>);\r\n}\r\n\r\n/** Extract which HTTP methods a given path supports */\r\ntype MethodsOfPath<Paths, Path extends keyof Paths> = {\r\n  [M in HttpMethod]: Paths[Path] extends { [K in M]: unknown } ? M : never;\r\n}[HttpMethod];\r\n\r\n/**\r\n * Narrows to only those paths (for the given method) where the full request object\r\n * has no required keys — i.e. `requestFn` can be safely omitted.\r\n */\r\ntype PathsWithOptionalRequest<Paths extends PathRecord, Method extends HttpMethod> = {\r\n  [P in PathsWithMethod<Paths, Method> & keyof Paths]: HasRequiredKeys<\r\n    OpenApiOperationRequest<NonNullable<OpOf<Paths, P, Method>>>\r\n  > extends true\r\n  ? never\r\n  : P;\r\n}[PathsWithMethod<Paths, Method> & keyof Paths];\r\n\r\n/** The callable type returned by `createOpenApiResource` */\r\nexport interface OpenApiResource<Paths extends PathRecord> {\r\n  /**\r\n   * Creates a reactive resource for an OpenAPI endpoint with an explicit HTTP method.\r\n   *\r\n   * The `method` option is restricted to the methods the given path supports.\r\n   */\r\n  <Path extends keyof Paths & string, Method extends MethodsOfPath<Paths, Path>>(\r\n    path: Path,\r\n    requestFn: () => OpenApiOperationRequest<NonNullable<OpOf<Paths, Path, Method>>> | undefined,\r\n    options: OpenApiResourceCallOptions<\r\n      SuccessResponseJSON<NonNullable<OpOf<Paths, Path, Method>>>,\r\n      unknown\r\n    > & { method: Method },\r\n  ): HttpResourceRef<SuccessResponseJSON<NonNullable<OpOf<Paths, Path, Method>>> | undefined>;\r\n\r\n  /**\r\n   * Creates a reactive GET resource for an OpenAPI endpoint (default).\r\n   *\r\n   * The resource re-fetches automatically when the signals read inside `requestFn` change.\r\n   * When `requestFn` returns `undefined` the resource is put into the Idle state.\r\n   */\r\n  <Path extends PathsWithMethod<Paths, 'get'> & keyof Paths>(\r\n    path: Path,\r\n    requestFn: () => OpenApiOperationRequest<NonNullable<OpOf<Paths, Path, 'get'>>> | undefined,\r\n    options?: HttpResourceOptions<\r\n      SuccessResponseJSON<NonNullable<OpOf<Paths, Path, 'get'>>>,\r\n      unknown\r\n    >,\r\n  ): HttpResourceRef<SuccessResponseJSON<NonNullable<OpOf<Paths, Path, 'get'>>> | undefined>;\r\n\r\n  /**\r\n   * Creates a reactive resource for an OpenAPI endpoint with an explicit HTTP method,\r\n   * omitting `requestFn`. Only available when the operation has no required parameters or body.\r\n   */\r\n  <Path extends keyof Paths & string, Method extends MethodsOfPath<Paths, Path>>(\r\n    path: Path extends PathsWithOptionalRequest<Paths, Method> ? Path : never,\r\n    options: OpenApiResourceCallOptions<\r\n      SuccessResponseJSON<NonNullable<OpOf<Paths, Path, Method>>>,\r\n      unknown\r\n    > & { method: Method },\r\n  ): HttpResourceRef<SuccessResponseJSON<NonNullable<OpOf<Paths, Path, Method>>> | undefined>;\r\n\r\n  /**\r\n   * Creates a reactive GET resource for an OpenAPI endpoint, omitting `requestFn`.\r\n   * Only available when the operation has no required parameters or body.\r\n   * The resource fetches immediately and always stays active.\r\n   */\r\n  <Path extends PathsWithOptionalRequest<Paths, 'get'>>(\r\n    path: Path,\r\n    options?: HttpResourceOptions<\r\n      SuccessResponseJSON<NonNullable<OpOf<Paths, Path, 'get'>>>,\r\n      unknown\r\n    >,\r\n  ): HttpResourceRef<SuccessResponseJSON<NonNullable<OpOf<Paths, Path, 'get'>>> | undefined>;\r\n}\r\n\r\n/**\r\n * Creates a type-safe callable factory for Angular `httpResource`s backed by an OpenAPI schema.\r\n *\r\n * Must be called inside an Angular injection context (e.g. component/service field initializer\r\n * or constructor), because the returned function uses `httpResource` internally.\r\n *\r\n * The returned function defaults to GET. Pass `{ method: 'post' }` (or other method) in the\r\n * options to use a different HTTP method. Note: Angular recommends using `httpResource` only\r\n * for reads; prefer `OpenApiHttpClient` for mutations.\r\n *\r\n * @example\r\n * ```ts\r\n * import type { paths } from './api.types'; // generated by openapi-typescript\r\n *\r\n * const api = createOpenApiResource<paths>({ baseUrl: 'https://api.example.com' });\r\n *\r\n * // Reactive GET resource (default)\r\n * const pets = api('/pets', () => ({ params: { query: { limit: 10 } } }));\r\n *\r\n * // GET with path params (signal-driven)\r\n * const petId = signal(1);\r\n * const pet = api('/pets/{petId}', () => ({ params: { path: { petId: petId() } } }));\r\n *\r\n * // Explicit method override (prefer OpenApiHttpClient for mutations)\r\n * const created = api('/pets', () => ({ body: { name: 'Buddy' } }), { method: 'post' });\r\n * ```\r\n */\r\nexport function createOpenApiResource<Paths extends PathRecord>(\r\n  config?: OpenApiResourceConfig,\r\n): OpenApiResource<Paths> {\r\n  const baseUrl = config?.baseUrl ?? '';\r\n\r\n  return ((\r\n    path: string,\r\n    reqFnOrOpts?: (() => unknown) | OpenApiResourceCallOptions<unknown>,\r\n    maybeOpts?: OpenApiResourceCallOptions<unknown>,\r\n  ) => {\r\n    const hasRequestFn = typeof reqFnOrOpts === 'function';\r\n    const requestFn = hasRequestFn ? reqFnOrOpts : () => ({});\r\n    const options = hasRequestFn ? maybeOpts : (reqFnOrOpts as OpenApiResourceCallOptions<unknown> | undefined);\r\n    const method = (options?.method ?? 'get').toUpperCase();\r\n\r\n    return httpResource(\r\n      () => {\r\n        const req = requestFn();\r\n        if (req === undefined) return undefined;\r\n        const r = toRequestShape(req);\r\n        return {\r\n          url: _buildUrl(baseUrl, path, r.params?.path),\r\n          method,\r\n          body: r.body,\r\n          params: _toHttpParams(r.params?.query),\r\n          headers: r.headers,\r\n          context: r.context,\r\n          withCredentials: r.withCredentials,\r\n        };\r\n      },\r\n      options,\r\n    );\r\n  }) as OpenApiResource<Paths>;\r\n}\r\n","import { HttpClient, HttpContext, HttpHeaders, HttpParams } from '@angular/common/http';\r\nimport { inject } from '@angular/core';\r\nimport type { Observable } from 'rxjs';\r\nimport type {\r\n  PathsWithMethod,\r\n  RequestBodyJSON,\r\n  SuccessResponseJSON,\r\n} from 'openapi-typescript-helpers';\r\nimport type {\r\n  OpenApiOperationRequest,\r\n  PathRecord,\r\n} from './types';\r\nimport { buildUrl, toHttpParams } from './url-utils';\r\n\r\n/** Configuration for `OpenApiHttpClient` */\r\nexport interface OpenApiHttpClientConfig {\r\n  /** Base URL to prepend to all request paths */\r\n  baseUrl?: string;\r\n}\r\n\r\n/** Extracts the operation type for a given path and method */\r\ntype OpOf<Paths, Path extends keyof Paths, Method extends string> = Paths[Path] extends {\r\n  [K in Method]: infer Op;\r\n}\r\n  ? Op\r\n  : never;\r\n\r\n/** Coerces the options to a plain shape */\r\nfunction toShape(opts: unknown): {\r\n  params?: {\r\n    path?: Record<string, string | number | boolean>;\r\n    query?: Record<string, string | number | boolean | null | undefined>;\r\n  };\r\n  body?: unknown;\r\n  headers?: HttpHeaders | Record<string, string | ReadonlyArray<string>>;\r\n  context?: HttpContext;\r\n  withCredentials?: boolean;\r\n} {\r\n  return ((opts ?? {}) as ReturnType<typeof toShape>);\r\n}\r\n\r\nfunction buildOptions(r: ReturnType<typeof toShape>): {\r\n  responseType: 'json';\r\n  observe: 'body';\r\n  params?: HttpParams;\r\n  headers?: HttpHeaders | Record<string, string | string[]>;\r\n  context?: HttpContext;\r\n  withCredentials?: boolean;\r\n} {\r\n  return {\r\n    responseType: 'json',\r\n    observe: 'body',\r\n    params: toHttpParams(r.params?.query),\r\n    // Cast needed: our public API allows ReadonlyArray<string> (consistent with httpResource),\r\n    // but Angular HttpClient methods require string[].\r\n    headers: r.headers as HttpHeaders | Record<string, string | string[]> | undefined,\r\n    context: r.context,\r\n    withCredentials: r.withCredentials,\r\n  };\r\n}\r\n\r\n/**\r\n * A type-safe HTTP client for OpenAPI-described APIs.\r\n *\r\n * Wraps Angular's `HttpClient` and binds request/response types to an OpenAPI\r\n * schema generated by `openapi-typescript`.\r\n *\r\n * Designed to be subclassed per-API:\r\n *\r\n * @example\r\n * ```ts\r\n * import type { paths } from './api.types'; // generated by openapi-typescript\r\n *\r\n * @Injectable({ providedIn: 'root' })\r\n * export class PetApiClient extends OpenApiHttpClient<paths> {\r\n *   constructor() {\r\n *     super({ baseUrl: 'https://api.example.com' });\r\n *   }\r\n * }\r\n * ```\r\n *\r\n * Or used directly inside an injection context:\r\n *\r\n * @example\r\n * ```ts\r\n * const client = new OpenApiHttpClient<paths>({ baseUrl: 'https://api.example.com' });\r\n * ```\r\n */\r\nexport class OpenApiHttpClient<Paths extends PathRecord> {\r\n  private readonly http = inject(HttpClient);\r\n  private readonly baseUrl: string;\r\n\r\n  constructor(config?: OpenApiHttpClientConfig) {\r\n    this.baseUrl = config?.baseUrl ?? '';\r\n  }\r\n\r\n  /**\r\n   * Performs a typed GET request.\r\n   *\r\n   * @example\r\n   * ```ts\r\n   * client.get('/pets', { params: { query: { limit: 10 } } }).subscribe(pets => console.log(pets));\r\n   * ```\r\n   */\r\n  get<Path extends PathsWithMethod<Paths, 'get'> & keyof Paths>(\r\n    path: Path,\r\n    options?: OpenApiOperationRequest<NonNullable<OpOf<Paths, Path, 'get'>>>,\r\n  ): Observable<SuccessResponseJSON<NonNullable<OpOf<Paths, Path, 'get'>>>> {\r\n    const r = toShape(options);\r\n    return this.http.get<SuccessResponseJSON<NonNullable<OpOf<Paths, Path, 'get'>>>>(\r\n      buildUrl(this.baseUrl, String(path), r.params?.path),\r\n      buildOptions(r),\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Performs a typed POST request.\r\n   */\r\n  post<Path extends PathsWithMethod<Paths, 'post'> & keyof Paths>(\r\n    path: Path,\r\n    options?: OpenApiOperationRequest<NonNullable<OpOf<Paths, Path, 'post'>>>,\r\n  ): Observable<SuccessResponseJSON<NonNullable<OpOf<Paths, Path, 'post'>>>> {\r\n    const r = toShape(options);\r\n    return this.http.post<SuccessResponseJSON<NonNullable<OpOf<Paths, Path, 'post'>>>>(\r\n      buildUrl(this.baseUrl, String(path), r.params?.path),\r\n      r.body as RequestBodyJSON<NonNullable<OpOf<Paths, Path, 'post'>>>,\r\n      buildOptions(r),\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Performs a typed PUT request.\r\n   */\r\n  put<Path extends PathsWithMethod<Paths, 'put'> & keyof Paths>(\r\n    path: Path,\r\n    options?: OpenApiOperationRequest<NonNullable<OpOf<Paths, Path, 'put'>>>,\r\n  ): Observable<SuccessResponseJSON<NonNullable<OpOf<Paths, Path, 'put'>>>> {\r\n    const r = toShape(options);\r\n    return this.http.put<SuccessResponseJSON<NonNullable<OpOf<Paths, Path, 'put'>>>>(\r\n      buildUrl(this.baseUrl, String(path), r.params?.path),\r\n      r.body as RequestBodyJSON<NonNullable<OpOf<Paths, Path, 'put'>>>,\r\n      buildOptions(r),\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Performs a typed PATCH request.\r\n   */\r\n  patch<Path extends PathsWithMethod<Paths, 'patch'> & keyof Paths>(\r\n    path: Path,\r\n    options?: OpenApiOperationRequest<NonNullable<OpOf<Paths, Path, 'patch'>>>,\r\n  ): Observable<SuccessResponseJSON<NonNullable<OpOf<Paths, Path, 'patch'>>>> {\r\n    const r = toShape(options);\r\n    return this.http.patch<SuccessResponseJSON<NonNullable<OpOf<Paths, Path, 'patch'>>>>(\r\n      buildUrl(this.baseUrl, String(path), r.params?.path),\r\n      r.body as RequestBodyJSON<NonNullable<OpOf<Paths, Path, 'patch'>>>,\r\n      buildOptions(r),\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Performs a typed DELETE request.\r\n   */\r\n  delete<Path extends PathsWithMethod<Paths, 'delete'> & keyof Paths>(\r\n    path: Path,\r\n    options?: OpenApiOperationRequest<NonNullable<OpOf<Paths, Path, 'delete'>>>,\r\n  ): Observable<SuccessResponseJSON<NonNullable<OpOf<Paths, Path, 'delete'>>>> {\r\n    const r = toShape(options);\r\n    const httpOptions = buildOptions(r) as { body?: unknown } & ReturnType<typeof buildOptions>;\r\n\r\n    if (r.body !== undefined) {\r\n      httpOptions.body = r.body as RequestBodyJSON<NonNullable<OpOf<Paths, Path, 'delete'>>>;\r\n    }\r\n\r\n    return this.http.delete<SuccessResponseJSON<NonNullable<OpOf<Paths, Path, 'delete'>>>>(\r\n      buildUrl(this.baseUrl, String(path), r.params?.path),\r\n      httpOptions,\r\n    );\r\n  }\r\n}\r\n","/*\r\n * Public API Surface of ngx-openapi-typescript\r\n */\r\n\r\nexport { createOpenApiResource } from './lib/open-api-resource';\r\nexport type {\r\n  OpenApiResource, OpenApiResourceCallOptions, OpenApiResourceConfig\r\n} from './lib/open-api-resource';\r\n\r\nexport { OpenApiHttpClient } from './lib/open-api-http-client';\r\nexport type { OpenApiHttpClientConfig } from './lib/open-api-http-client';\r\n\r\nexport type {\r\n  HasRequiredKeys,\r\n  HttpMethod, OpenApiOperationRequest,\r\n  OpenApiRequestOptions, OperationBody, OperationParamsObject, PathParameters, PathRecord, PathsWithMethod, QueryParameters, RequestBodyJSON, SuccessResponseJSON\r\n} from './lib/types';\r\n\r\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":["_buildUrl","_toHttpParams"],"mappings":"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"}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "ngx-openapi-typescript",
+  "version": "0.0.1",
+  "peerDependencies": {
+    "@angular/common": "^21.2.0 || ^22.0.0",
+    "@angular/core": "^21.2.0 || ^22.0.0",
+    "openapi-typescript-helpers": "^0.1.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "sideEffects": false,
+  "module": "fesm2022/ngx-openapi-typescript.mjs",
+  "typings": "types/ngx-openapi-typescript.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./types/ngx-openapi-typescript.d.ts",
+      "default": "./fesm2022/ngx-openapi-typescript.mjs"
+    }
+  }
+}

package/types/ngx-openapi-typescript.d.ts

@@ -0,0 +1,206 @@
+import { HttpHeaders, HttpContext, HttpResourceOptions, HttpResourceRef } from '@angular/common/http';
+import { RequestBodyJSON, IsOperationRequestBodyOptional, HttpMethod, SuccessResponseJSON, PathsWithMethod } from 'openapi-typescript-helpers';
+export { HttpMethod, PathsWithMethod, RequestBodyJSON, SuccessResponseJSON } from 'openapi-typescript-helpers';
+import { Observable } from 'rxjs';
+
+/**
+ * Represents an OpenAPI paths record as generated by openapi-typescript.
+ * Uses `{}` to match the same constraint used by openapi-typescript-helpers.
+ */
+type PathRecord = {};
+/** Extract path parameters from an OpenAPI operation */
+type PathParameters<Op> = Op extends {
+    parameters: {
+        path?: infer P;
+    };
+} ? NonNullable<P> extends Record<string, unknown> ? NonNullable<P> : never : never;
+/** Extract query parameters from an OpenAPI operation */
+type QueryParameters<Op> = Op extends {
+    parameters: {
+        query?: infer Q;
+    };
+} ? NonNullable<Q> extends Record<string, unknown> ? NonNullable<Q> : never : never;
+/** Check if a type has required (non-optional) keys */
+type HasRequiredKeys<T> = [T] extends [never] ? false : ({
+    [K in keyof T]-?: undefined extends T[K] ? never : K;
+}[keyof T]) extends never ? false : true;
+/** Conditionally adds a key to the object; makes it required if T has required keys */
+type ParamEntry<K extends string, T> = [T] extends [never] ? {} : HasRequiredKeys<T> extends true ? {
+    [P in K]: T;
+} : {
+    [P in K]?: T;
+};
+/** Inner `{ path?, query? }` object for an OpenAPI operation */
+type OperationParamsObject<Op> = ParamEntry<'path', PathParameters<Op>> & ParamEntry<'query', QueryParameters<Op>>;
+/** Request body type for an OpenAPI operation */
+type OperationBody<Op> = [RequestBodyJSON<Op>] extends [never] ? {
+    body?: never;
+} : IsOperationRequestBodyOptional<Op> extends true ? {
+    body?: RequestBodyJSON<Op>;
+} : {
+    body: RequestBodyJSON<Op>;
+};
+/** Common HTTP request options */
+interface OpenApiRequestOptions {
+    headers?: HttpHeaders | Record<string, string | ReadonlyArray<string>>;
+    context?: HttpContext;
+    withCredentials?: boolean;
+}
+/** Full typed request for an OpenAPI operation */
+type OpenApiOperationRequest<Op> = ParamEntry<'params', OperationParamsObject<Op>> & OperationBody<Op> & OpenApiRequestOptions;
+
+/** Configuration for creating an OpenAPI resource factory */
+interface OpenApiResourceConfig {
+    /** Base URL to prepend to all resource paths */
+    baseUrl?: string;
+}
+/** Options for the resource call, extending Angular's HttpResourceOptions with an optional HTTP method */
+type OpenApiResourceCallOptions<TValue, TError = unknown> = HttpResourceOptions<TValue, TError> & {
+    method?: HttpMethod;
+};
+/** Extracts the operation type for a given path and method */
+type OpOf$1<Paths, Path extends keyof Paths, Method extends string> = Paths[Path] extends {
+    [K in Method]: infer Op;
+} ? Op : never;
+/** Extract which HTTP methods a given path supports */
+type MethodsOfPath<Paths, Path extends keyof Paths> = {
+    [M in HttpMethod]: Paths[Path] extends {
+        [K in M]: unknown;
+    } ? M : never;
+}[HttpMethod];
+/**
+ * Narrows to only those paths (for the given method) where the full request object
+ * has no required keys — i.e. `requestFn` can be safely omitted.
+ */
+type PathsWithOptionalRequest<Paths extends PathRecord, Method extends HttpMethod> = {
+    [P in PathsWithMethod<Paths, Method> & keyof Paths]: HasRequiredKeys<OpenApiOperationRequest<NonNullable<OpOf$1<Paths, P, Method>>>> extends true ? never : P;
+}[PathsWithMethod<Paths, Method> & keyof Paths];
+/** The callable type returned by `createOpenApiResource` */
+interface OpenApiResource<Paths extends PathRecord> {
+    /**
+     * Creates a reactive resource for an OpenAPI endpoint with an explicit HTTP method.
+     *
+     * The `method` option is restricted to the methods the given path supports.
+     */
+    <Path extends keyof Paths & string, Method extends MethodsOfPath<Paths, Path>>(path: Path, requestFn: () => OpenApiOperationRequest<NonNullable<OpOf$1<Paths, Path, Method>>> | undefined, options: OpenApiResourceCallOptions<SuccessResponseJSON<NonNullable<OpOf$1<Paths, Path, Method>>>, unknown> & {
+        method: Method;
+    }): HttpResourceRef<SuccessResponseJSON<NonNullable<OpOf$1<Paths, Path, Method>>> | undefined>;
+    /**
+     * Creates a reactive GET resource for an OpenAPI endpoint (default).
+     *
+     * The resource re-fetches automatically when the signals read inside `requestFn` change.
+     * When `requestFn` returns `undefined` the resource is put into the Idle state.
+     */
+    <Path extends PathsWithMethod<Paths, 'get'> & keyof Paths>(path: Path, requestFn: () => OpenApiOperationRequest<NonNullable<OpOf$1<Paths, Path, 'get'>>> | undefined, options?: HttpResourceOptions<SuccessResponseJSON<NonNullable<OpOf$1<Paths, Path, 'get'>>>, unknown>): HttpResourceRef<SuccessResponseJSON<NonNullable<OpOf$1<Paths, Path, 'get'>>> | undefined>;
+    /**
+     * Creates a reactive resource for an OpenAPI endpoint with an explicit HTTP method,
+     * omitting `requestFn`. Only available when the operation has no required parameters or body.
+     */
+    <Path extends keyof Paths & string, Method extends MethodsOfPath<Paths, Path>>(path: Path extends PathsWithOptionalRequest<Paths, Method> ? Path : never, options: OpenApiResourceCallOptions<SuccessResponseJSON<NonNullable<OpOf$1<Paths, Path, Method>>>, unknown> & {
+        method: Method;
+    }): HttpResourceRef<SuccessResponseJSON<NonNullable<OpOf$1<Paths, Path, Method>>> | undefined>;
+    /**
+     * Creates a reactive GET resource for an OpenAPI endpoint, omitting `requestFn`.
+     * Only available when the operation has no required parameters or body.
+     * The resource fetches immediately and always stays active.
+     */
+    <Path extends PathsWithOptionalRequest<Paths, 'get'>>(path: Path, options?: HttpResourceOptions<SuccessResponseJSON<NonNullable<OpOf$1<Paths, Path, 'get'>>>, unknown>): HttpResourceRef<SuccessResponseJSON<NonNullable<OpOf$1<Paths, Path, 'get'>>> | undefined>;
+}
+/**
+ * Creates a type-safe callable factory for Angular `httpResource`s backed by an OpenAPI schema.
+ *
+ * Must be called inside an Angular injection context (e.g. component/service field initializer
+ * or constructor), because the returned function uses `httpResource` internally.
+ *
+ * The returned function defaults to GET. Pass `{ method: 'post' }` (or other method) in the
+ * options to use a different HTTP method. Note: Angular recommends using `httpResource` only
+ * for reads; prefer `OpenApiHttpClient` for mutations.
+ *
+ * @example
+ * ```ts
+ * import type { paths } from './api.types'; // generated by openapi-typescript
+ *
+ * const api = createOpenApiResource<paths>({ baseUrl: 'https://api.example.com' });
+ *
+ * // Reactive GET resource (default)
+ * const pets = api('/pets', () => ({ params: { query: { limit: 10 } } }));
+ *
+ * // GET with path params (signal-driven)
+ * const petId = signal(1);
+ * const pet = api('/pets/{petId}', () => ({ params: { path: { petId: petId() } } }));
+ *
+ * // Explicit method override (prefer OpenApiHttpClient for mutations)
+ * const created = api('/pets', () => ({ body: { name: 'Buddy' } }), { method: 'post' });
+ * ```
+ */
+declare function createOpenApiResource<Paths extends PathRecord>(config?: OpenApiResourceConfig): OpenApiResource<Paths>;
+
+/** Configuration for `OpenApiHttpClient` */
+interface OpenApiHttpClientConfig {
+    /** Base URL to prepend to all request paths */
+    baseUrl?: string;
+}
+/** Extracts the operation type for a given path and method */
+type OpOf<Paths, Path extends keyof Paths, Method extends string> = Paths[Path] extends {
+    [K in Method]: infer Op;
+} ? Op : never;
+/**
+ * A type-safe HTTP client for OpenAPI-described APIs.
+ *
+ * Wraps Angular's `HttpClient` and binds request/response types to an OpenAPI
+ * schema generated by `openapi-typescript`.
+ *
+ * Designed to be subclassed per-API:
+ *
+ * @example
+ * ```ts
+ * import type { paths } from './api.types'; // generated by openapi-typescript
+ *
+ * @Injectable({ providedIn: 'root' })
+ * export class PetApiClient extends OpenApiHttpClient<paths> {
+ *   constructor() {
+ *     super({ baseUrl: 'https://api.example.com' });
+ *   }
+ * }
+ * ```
+ *
+ * Or used directly inside an injection context:
+ *
+ * @example
+ * ```ts
+ * const client = new OpenApiHttpClient<paths>({ baseUrl: 'https://api.example.com' });
+ * ```
+ */
+declare class OpenApiHttpClient<Paths extends PathRecord> {
+    private readonly http;
+    private readonly baseUrl;
+    constructor(config?: OpenApiHttpClientConfig);
+    /**
+     * Performs a typed GET request.
+     *
+     * @example
+     * ```ts
+     * client.get('/pets', { params: { query: { limit: 10 } } }).subscribe(pets => console.log(pets));
+     * ```
+     */
+    get<Path extends PathsWithMethod<Paths, 'get'> & keyof Paths>(path: Path, options?: OpenApiOperationRequest<NonNullable<OpOf<Paths, Path, 'get'>>>): Observable<SuccessResponseJSON<NonNullable<OpOf<Paths, Path, 'get'>>>>;
+    /**
+     * Performs a typed POST request.
+     */
+    post<Path extends PathsWithMethod<Paths, 'post'> & keyof Paths>(path: Path, options?: OpenApiOperationRequest<NonNullable<OpOf<Paths, Path, 'post'>>>): Observable<SuccessResponseJSON<NonNullable<OpOf<Paths, Path, 'post'>>>>;
+    /**
+     * Performs a typed PUT request.
+     */
+    put<Path extends PathsWithMethod<Paths, 'put'> & keyof Paths>(path: Path, options?: OpenApiOperationRequest<NonNullable<OpOf<Paths, Path, 'put'>>>): Observable<SuccessResponseJSON<NonNullable<OpOf<Paths, Path, 'put'>>>>;
+    /**
+     * Performs a typed PATCH request.
+     */
+    patch<Path extends PathsWithMethod<Paths, 'patch'> & keyof Paths>(path: Path, options?: OpenApiOperationRequest<NonNullable<OpOf<Paths, Path, 'patch'>>>): Observable<SuccessResponseJSON<NonNullable<OpOf<Paths, Path, 'patch'>>>>;
+    /**
+     * Performs a typed DELETE request.
+     */
+    delete<Path extends PathsWithMethod<Paths, 'delete'> & keyof Paths>(path: Path, options?: OpenApiOperationRequest<NonNullable<OpOf<Paths, Path, 'delete'>>>): Observable<SuccessResponseJSON<NonNullable<OpOf<Paths, Path, 'delete'>>>>;
+}
+
+export { OpenApiHttpClient, createOpenApiResource };
+export type { HasRequiredKeys, OpenApiHttpClientConfig, OpenApiOperationRequest, OpenApiRequestOptions, OpenApiResource, OpenApiResourceCallOptions, OpenApiResourceConfig, OperationBody, OperationParamsObject, PathParameters, PathRecord, QueryParameters };