[Feature Request] Option to resolve BaseUrl at runtime

[chcederquist]

Problem

An API may be present on several different servers. When building a JS bundle, you don't necessarily want to couple that bundle to a single API. However, that is the case with the baseURL, which doesn't have a way to be set at runtime, other than through using a transformer override.

Feature Request

I would like to be able to point the base URL to a runtime variable or a function that resolves it the same you do with custom fetch clients or JSON revivers. E.g.
{... baseUrl: { resolve: './baseUrlResolve.ts'} }

// baseUrlResolve.ts
function getBaseUrl() {
  return window.apiBaseUrl;
}
export default getBaseUrl

The function would be called every time the base URL was to be resolved.

Alternatively a static variable could be referenced:
{... baseUrl: { variable: 'window.baseUrl'} }

[chcederquist]

Output.override.transformer is build-time, not run-time.

[Toilal]

I wrote those mutators for axios and fetch. Call setBaseUrl onfetch generated code, or set an axios instance with preconfigured baseURL (setAxiosInstance). But it would be great to have a ready to use feature inside orval.

import axios, {
  type AxiosInstance,
  type AxiosPromise,
  type AxiosRequestConfig,
  type AxiosResponse,
} from 'axios';

let axiosInstance: AxiosInstance | undefined;
let axiosInstanceFactory: () => AxiosInstance = () => {
  return axios.create();
};

export function getAxiosInstanceFactory(): () => AxiosInstance {
  return axiosInstanceFactory;
}

export function setAxiosInstanceFactory(factory: () => AxiosInstance) {
  axiosInstanceFactory = factory;
  axiosInstance = undefined;
}

export function getAxiosInstance(): AxiosInstance {
  if (!axiosInstance) {
    axiosInstance = newAxiosInstance();
  }

  return axiosInstance;
}

export function setAxiosInstance(instance: AxiosInstance) {
  axiosInstance = instance;
}

export function newAxiosInstance(): AxiosInstance {
  return getAxiosInstanceFactory()();
}

export async function request<T = unknown, D = unknown>(
  config: AxiosRequestConfig<D>,
): AxiosPromise<AxiosResponse<T>> {
  return getAxiosInstance().request(config);
}

export async function requestData<T = unknown, D = unknown>(config: AxiosRequestConfig<D>): Promise<T> {
  const response = await getAxiosInstance().request(config);
  return response.data;
}

export type MaybePromise<T> = Promise<T> | T;

export type RequestInterceptor = (
  input: RequestInfo | URL,
  init?: RequestInit,
) => MaybePromise<[RequestInfo | URL, RequestInit | undefined]>;
export type ResponseInterceptor = (
  response: Response,
  input: RequestInfo | URL,
  init?: RequestInit,
) => MaybePromise<Response>;
export type ResponseParser<T = unknown> = (
  response: Response,
  input: RequestInfo | URL,
  init?: RequestInit,
) => MaybePromise<ParsedResponse<T>>;
export type FetchExceptionHandler = (
  error: unknown,
  input: RequestInfo | URL,
  init?: RequestInit,
) => Response;

const requestInterceptors: RequestInterceptor[] = [];
const responseInterceptors: ResponseInterceptor[] = [];
const responseParsers: ResponseParser[] = [];

/**
 * Add a request interceptor in interceptors chain.
 *
 * @param interceptor a function that can intercept request input to alter it.
 */
export function addRequestInterceptor(interceptor: RequestInterceptor): () => void {
  requestInterceptors.push(interceptor);
  return () => {
    const index = requestInterceptors.indexOf(interceptor);
    requestInterceptors.splice(index, 1);
  };
}

/**
 * Remove all request interceptors.
 */
export function clearRequestInterceptors(): void {
  requestInterceptors.length = 0;
}

/**
 * Add a response interceptor in interceptors chain.
 *
 * @param interceptor a function that can intercept request response to alter it.
 */
export function addResponseInterceptor(interceptor: ResponseInterceptor): () => void {
  responseInterceptors.push(interceptor);
  return () => {
    const index = responseInterceptors.indexOf(interceptor);
    responseInterceptors.splice(index, 1);
  };
}

/**
 * Remove all response interceptors.
 */
export function clearResponseInterceptors(): void {
  responseInterceptors.length = 0;
}

/**
 * Remove all interceptors (request and response)
 */
export function clearInterceptors() {
  clearRequestInterceptors();
  clearResponseInterceptors();
}

/**
 * Add a response parser in parsers chain.
 *
 * @param parser a function that should parse response into business object.
 */
export function addResponseParser(parser: ResponseParser): () => void {
  responseParsers.push(parser);
  return () => {
    const index = responseParsers.indexOf(parser);
    responseParsers.splice(index, 1);
  };
}

export interface ParsedResponse<T = unknown> {
  data: T | null;
  status: number;
  headers: Headers;
}

async function defaultResponseDataParser<T = unknown>(
  res: Response,
  dataProvider: () => Promise<T>,
): Promise<ParsedResponse<T>> {
  const data: T | null = [204, 205, 304].includes(res.status) ? null : await dataProvider();
  if (!res.ok) {
    const err: globalThis.Error & { info?: unknown; status?: number } = new globalThis.Error();
    err.info = data;
    err.status = res.status;
    throw err;
  }

  return { data, status: res.status, headers: res.headers };
}

let defaultResponseParser: ResponseParser = async (res: Response) => {
  const contentType = res.headers.get('content-type');

  let reader: () => Promise<unknown>;
  if (contentType && contentType.startsWith('application/json')) {
    reader = () => res.json();
  } else if (contentType && contentType.startsWith('text/')) {
    reader = () => res.text();
  } else {
    reader = () => res.blob();
  }

  return await defaultResponseDataParser(res, reader);
};

let baseUrlInterceptor: RequestInterceptor | undefined;

function baseUrlInterceptorFactory(baseUrl: string): RequestInterceptor {
  return (input, options) => {
    input =
      typeof input === 'string'
        ? new URL(input, baseUrl).toString()
        : input instanceof URL
          ? new URL(input.toString(), baseUrl).toString()
          : input;

    return [input, options];
  };
}

export function setBaseUrl(value: string | undefined) {
  if (value) {
    baseUrlInterceptor = baseUrlInterceptorFactory(value);
  } else {
    baseUrlInterceptor = undefined;
  }
}

export function setDefaultResponseParser(parser: ResponseParser) {
  defaultResponseParser = parser;
}

let _fetch: typeof fetch = fetch;

export function setFetchInstance(fetchInstance: typeof fetch) {
  _fetch = fetchInstance;
}

let exceptionHandler: FetchExceptionHandler | undefined = undefined;

export function setFetchExceptionHandler(handler: FetchExceptionHandler | undefined) {
  exceptionHandler = handler;
}

function isPromiseLike(value: unknown): value is PromiseLike<unknown> {
  return (
    value !== null &&
    (typeof value === 'object' || typeof value === 'function') &&
    typeof (value as { then?: unknown }).then === 'function'
  );
}

export async function request<R = ParsedResponse>(input: RequestInfo | URL, init?: RequestInit): Promise<R> {
  if (baseUrlInterceptor) {
    const maybePromise = baseUrlInterceptor(input, init);

    const interceptorResult = isPromiseLike(maybePromise) ? await maybePromise : maybePromise;

    input = interceptorResult[0];
    init = interceptorResult[1];
  }

  for (const interceptor of requestInterceptors) {
    const maybePromise = interceptor(input, init);

    const interceptorResult = isPromiseLike(maybePromise) ? await maybePromise : maybePromise;

    input = interceptorResult[0];
    init = interceptorResult[1];
  }

  let res: Response;
  try {
    res = await _fetch(input, init);

    for (const interceptor of responseInterceptors) {
      const maybePromise = interceptor(res, input, init);

      res = isPromiseLike(maybePromise) ? await maybePromise : maybePromise;
    }
  } catch (error) {
    if (!exceptionHandler) {
      throw error;
    }

    res = exceptionHandler(error, input, init);
  }

  for (const responseParser of responseParsers) {
    const maybePromise = await responseParser(res, input, init);

    const parsed = isPromiseLike(maybePromise) ? await maybePromise : maybePromise;

    if (parsed !== undefined) {
      return parsed as R;
    }
  }

  return (await defaultResponseParser(res, input, init)) as R;
}

export async function requestData<T = unknown>(input: RequestInfo | URL, init?: RequestInit): Promise<T> {
  const response = await request(input, init);
  return response.data as T;
}