fix(client-core): resolve runtimeConfigPath relative to generated output

Paths starting with './' or absolute paths are now resolved from the current
working directory and made relative to the generated output directory, so the
resulting import path is correct regardless of where the user's runtime config
file lives.

Paths without a './' prefix (e.g. '../my-config', 'my-config', '@scope/pkg')
are kept as-is to preserve the existing convention of treating them as
relative to the generated output or as bare module specifiers.

Closes #3394

Author: inas-sirhan

.changeset/fix-runtime-config-path.md

@@ -0,0 +1,5 @@
+---
+"@hey-api/openapi-ts": patch
+---
+
+**plugin(@hey-api/client-core)**: resolve `runtimeConfigPath` relative to the generated output so imports are correct regardless of where the user's config file lives

packages/openapi-ts-tests/main/runtime-config/my-config.ts

@@ -0,0 +1 @@
+export const createClientConfig = <T>(config: T): T => config;

packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-angular/runtime-config-path/client.gen.ts

@@ -0,0 +1,18 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import { createClientConfig } from '../../../../../../../runtime-config/my-config.ts';
+
+import { type ClientOptions, type Config, createClient, createConfig } from './client';
+import type { ClientOptions as ClientOptions2 } from './types.gen';
+
+/**
+ * The `createClientConfig()` function will be called on client initialization
+ * and the returned object will become the client's initial configuration.
+ *
+ * You may want to initialize your client this way instead of calling
+ * `setConfig()`. This is useful for example if you're using Next.js
+ * to ensure your client always has the correct values.
+ */
+export type CreateClientConfig<T extends ClientOptions = ClientOptions2> = (override?: Config<ClientOptions & T>) => Config<Required<ClientOptions> & T>;
+
+export const client = createClient(createClientConfig(createConfig<ClientOptions2>({ baseUrl: 'http://localhost:3000/base' })));

packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-angular/runtime-config-path/client/client.gen.ts

@@ -0,0 +1,248 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { HttpResponse } from '@angular/common/http';
+import { HttpClient, HttpErrorResponse, HttpEventType, HttpRequest } from '@angular/common/http';
+import {
+  assertInInjectionContext,
+  inject,
+  provideAppInitializer,
+  runInInjectionContext,
+} from '@angular/core';
+import { firstValueFrom } from 'rxjs';
+import { filter } from 'rxjs/operators';
+
+import { createSseClient } from '../core/serverSentEvents.gen';
+import type { HttpMethod } from '../core/types.gen';
+import { getValidRequestBody } from '../core/utils.gen';
+import type {
+  Client,
+  Config,
+  RequestOptions,
+  ResolvedRequestOptions,
+  ResponseStyle,
+} 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 requestOptions = <
+    TData = unknown,
+    ThrowOnError extends boolean = false,
+    TResponseStyle extends ResponseStyle = 'fields',
+  >(
+    options: RequestOptions<TData, TResponseStyle, ThrowOnError>,
+  ) => {
+    const opts = {
+      ..._config,
+      ...options,
+      headers: mergeHeaders(_config.headers, options.headers),
+      httpClient: options.httpClient ?? _config.httpClient,
+      serializedBody: undefined as string | undefined,
+    };
+
+    if (!opts.httpClient) {
+      if (opts.injector) {
+        opts.httpClient = runInInjectionContext(opts.injector, () => inject(HttpClient));
+      } else {
+        assertInInjectionContext(requestOptions);
+        opts.httpClient = inject(HttpClient);
+      }
+    }
+
+    if (opts.body !== undefined && opts.bodySerializer) {
+      opts.serializedBody = opts.bodySerializer(opts.body) as string | undefined;
+    }
+
+    // remove Content-Type header if body is empty to avoid sending invalid requests
+    if (opts.body === undefined || opts.serializedBody === '') {
+      opts.headers.delete('Content-Type');
+    }
+
+    const url = buildUrl(opts as any);
+
+    const req = new HttpRequest<unknown>(opts.method ?? 'GET', url, getValidRequestBody(opts), {
+      redirect: 'follow',
+      ...opts,
+    });
+
+    return { opts, req, url };
+  };
+
+  const beforeRequest = async <
+    TData = unknown,
+    TResponseStyle extends ResponseStyle = 'fields',
+    ThrowOnError extends boolean = boolean,
+    Url extends string = string,
+  >(
+    options: RequestOptions<TData, TResponseStyle, ThrowOnError, Url>,
+  ) => {
+    const { opts, req, url } = requestOptions(options);
+
+    if (opts.security) {
+      await setAuthParams({
+        ...opts,
+        security: opts.security,
+      });
+    }
+
+    if (opts.requestValidator) {
+      await opts.requestValidator(opts);
+    }
+
+    return { opts, req, url };
+  };
+
+  const request: Client['request'] = async (options) => {
+    const { opts, req: initialReq } = await beforeRequest(options);
+
+    let req = initialReq;
+
+    for (const fn of interceptors.request.fns) {
+      if (fn) {
+        req = await fn(req, opts as any);
+      }
+    }
+
+    const result: {
+      request: HttpRequest<unknown>;
+      response: any;
+    } = {
+      request: req,
+      response: null,
+    };
+
+    try {
+      result.response = (await firstValueFrom(
+        opts
+          .httpClient!.request(req)
+          .pipe(filter((event) => event.type === HttpEventType.Response)),
+      )) as HttpResponse<unknown>;
+
+      for (const fn of interceptors.response.fns) {
+        if (fn) {
+          result.response = await fn(result.response, req, opts as any);
+        }
+      }
+
+      let bodyResponse = result.response.body;
+
+      if (opts.responseValidator) {
+        await opts.responseValidator(bodyResponse);
+      }
+
+      if (opts.responseTransformer) {
+        bodyResponse = await opts.responseTransformer(bodyResponse);
+      }
+
+      return opts.responseStyle === 'data' ? bodyResponse : { data: bodyResponse, ...result };
+    } catch (error) {
+      if (error instanceof HttpErrorResponse) {
+        result.response = error;
+      }
+
+      let finalError = error instanceof HttpErrorResponse ? error.error : error;
+
+      for (const fn of interceptors.error.fns) {
+        if (fn) {
+          finalError = (await fn(finalError, result.response as any, req, opts as any)) as string;
+        }
+      }
+
+      if (opts.throwOnError) {
+        throw finalError;
+      }
+
+      return opts.responseStyle === 'data'
+        ? undefined
+        : {
+            error: finalError,
+            ...result,
+          };
+    }
+  };
+
+  const makeMethodFn = (method: Uppercase<HttpMethod>) => (options: RequestOptions) =>
+    request({ ...options, method });
+
+  const makeSseFn = (method: Uppercase<HttpMethod>) => async (options: RequestOptions) => {
+    const { opts, url } = await beforeRequest(options);
+    return createSseClient({
+      ...opts,
+      body: opts.body as BodyInit | null | undefined,
+      headers: opts.headers as unknown as Record<string, string>,
+      method,
+      serializedBody: getValidRequestBody(opts) as BodyInit | null | undefined,
+      url,
+    });
+  };
+
+  const _buildUrl: Client['buildUrl'] = (options) => buildUrl({ ..._config, ...options });
+
+  return {
+    buildUrl: _buildUrl,
+    connect: makeMethodFn('CONNECT'),
+    delete: makeMethodFn('DELETE'),
+    get: makeMethodFn('GET'),
+    getConfig,
+    head: makeMethodFn('HEAD'),
+    interceptors,
+    options: makeMethodFn('OPTIONS'),
+    patch: makeMethodFn('PATCH'),
+    post: makeMethodFn('POST'),
+    put: makeMethodFn('PUT'),
+    request,
+    requestOptions: (options) => {
+      if (options.security) {
+        throw new Error('Security is not supported in requestOptions');
+      }
+
+      if (options.requestValidator) {
+        throw new Error('Request validation is not supported in requestOptions');
+      }
+
+      return requestOptions(options).req;
+    },
+    setConfig,
+    sse: {
+      connect: makeSseFn('CONNECT'),
+      delete: makeSseFn('DELETE'),
+      get: makeSseFn('GET'),
+      head: makeSseFn('HEAD'),
+      options: makeSseFn('OPTIONS'),
+      patch: makeSseFn('PATCH'),
+      post: makeSseFn('POST'),
+      put: makeSseFn('PUT'),
+      trace: makeSseFn('TRACE'),
+    },
+    trace: makeMethodFn('TRACE'),
+  } as Client;
+};

packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-angular/runtime-config-path/client/index.ts

@@ -0,0 +1,25 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type { Auth } from '../core/auth.gen';
+export type { QuerySerializerOptions } from '../core/bodySerializer.gen';
+export {
+  formDataBodySerializer,
+  jsonBodySerializer,
+  urlSearchParamsBodySerializer,
+} from '../core/bodySerializer.gen';
+export { buildClientParams } from '../core/params.gen';
+export { serializeQueryKeyValue } from '../core/queryKeySerializer.gen';
+export { createClient } from './client.gen';
+export type {
+  Client,
+  ClientOptions,
+  Config,
+  CreateClientConfig,
+  Options,
+  RequestOptions,
+  RequestResult,
+  ResolvedRequestOptions,
+  ResponseStyle,
+  TDataShape,
+} from './types.gen';
+export { createConfig, mergeHeaders } from './utils.gen';