@jaseeey/request-manager 2.2.2 → 2.3.0

package/README.md

@@ -23,6 +23,7 @@ It is intentionally focused: not a full HTTP client, cache layer, or request que
 - [FAQ](#faq)
 - [Known limitations](#known-limitations)
 - [Background and scope](#background-and-scope)
+- [Features summary](#features-summary)
 - [Contributing](#contributing)
 - [License](#license)
 
@@ -65,13 +66,15 @@ You can use both: a query library for cache and lifecycle, and RequestManager un
 npm install @jaseeey/request-manager axios
 ```
 
-**Axios is a peer dependency** (`axios >= 1`). The package does not bundle a client for you; you pass your own `AxiosInstance` into `call()`. Install Axios alongside this library if it is not already in your project:
+**Axios is a peer dependency** (`axios ^1`). The package does not bundle a client for you; you pass your own `AxiosInstance` into `call()`. Install Axios alongside this library if it is not already in your project:
 
 ```bash
 npm install axios
 ```
 
-Requires **Node.js 18+** for development tooling; the published package is plain ESM/CJS JavaScript for bundlers and Node.
+Requires **Node.js 22.12+** for development tooling (running the test suite); the
+published package remains plain ESM/CJS JavaScript that runs on Node.js 18+ in your
+applications.
 
 ---
 
@@ -147,7 +150,7 @@ Each in-flight request is stored under a key built from:
 
 1. **Axios client instance** (identity, not config equality)
 2. **HTTP method** (compared case-insensitively, e.g. `GET` and `get` match)
-3. **URL string** (exact string match of the `url` argument—not Axios's fully resolved URL)
+3. **URL string** (exact string match of the `url` argument—or its `baseURL`-resolved form when `resolveBaseURL` is enabled)
 4. **`config.params`** (deterministic serialisation; missing/`undefined`/empty params are equivalent)
 
 ```text
@@ -165,13 +168,14 @@ for (const [hash, entry] of requestManager.activeRequests) {
     entry.identity.method;         // e.g. 'get'
     entry.identity.url;
     entry.identity.params;         // as supplied (or null)
-    entry.identity.paramsSerialised;
+    entry.identity.paramsSerialized;
+    entry.identity.paramsSerialised;   // deprecated alias of `paramsSerialized`
     entry.original;                // underlying Axios promise
     entry.processed;               // shared caller promise
 }
 ```
 
-See also [`baseURL` is not part of the key](#baseurl-is-not-part-of-the-key).
+By default the raw `url` argument is the key segment; enable [`resolveBaseURL`](#constructor) to key on the `baseURL`-resolved URL instead.
 
 ### Lifecycle
 
@@ -194,6 +198,7 @@ There is **no cache** of completed responses. De-duplication applies only to con
 | Different `data` bodies | Yes (same key) | Body is **not** in the key (mutations are usually user actions) |
 | Different headers, timeout, signal, etc. | Yes (same key) | Other config is **not** in the key |
 | Same path, different full URL strings | No | `'/users?id=1'` and `'/users?id=2'` are different keys |
+| Relative URL and its `baseURL`-resolved absolute form | No (Yes with `resolveBaseURL`) | Opt-in `baseURL`-aware keying |
 | Different Axios instances | No | Separate clients never share de-duplication |
 | Different methods | No | `GET` and `POST` to the same URL are independent |
 
@@ -330,6 +335,9 @@ await RequestManager.call(client, 'GET', 'https://example.com/health');
 - `onSuccess` may return a `Promise`; it is awaited.
 - `onError` is not awaited; keep it synchronous or fire-and-forget async work carefully.
 - Method matching for de-duplication is case-insensitive.
+- `call()` rejects with a `TypeError` when the client is not an Axios-like instance, the
+  `method` or `url` is invalid, or `config.params` is not serialisable (e.g. a circular
+  reference).
 
 ### Instance fields
 
@@ -345,10 +353,17 @@ Clearing the map mid-flight is not recommended except in tests. If you clear an
 
 ```typescript
 const manager = new RequestManager();
+const resolvedManager = new RequestManager({ resolveBaseURL: true });
 ```
 
 Creates an isolated manager. The generic type parameter on the class is historical; prefer generics on `call()` for response typing.
 
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `resolveBaseURL` | `boolean` | `false` | Resolve relative URLs against the client's `baseURL` before keying, so a relative URL and its absolute form share one in-flight request |
+
+With `resolveBaseURL` enabled, `'/users/me'` on a client created with `baseURL: 'https://api.example.com'` de-duplicates against `'https://api.example.com/users/me'`. Resolution mirrors Axios's own `buildFullPath` rules: absolute and protocol-relative URLs are left untouched, and joining follows the same trailing-slash rules Axios uses.
+
 ---
 
 ## Effective usage patterns
@@ -592,26 +607,7 @@ De-duplication includes `config.params` but not request bodies, headers, timeout
 
 ### Exact URL string matching
 
-`/users` and `/users/` are different keys. Relative URLs are not normalised against `baseURL` for keying—the string you pass is the key segment.
-
-### `baseURL` is not part of the key
-
-Axios may resolve a relative `url` against the client's `baseURL` when sending the request, but RequestManager keys only on the **`url` argument string**.
-
-```typescript
-const client = axios.create({ baseURL: 'https://api.example.com' });
-
-// These share one in-flight request (same url string: '/users/me')
-await Promise.all([
-    requestManager.call(client, 'GET', '/users/me'),
-    requestManager.call(client, 'GET', '/users/me')
-]);
-
-// This is a different key (different url string), even if it hits the same origin
-await requestManager.call(client, 'GET', 'https://api.example.com/users/me');
-```
-
-Keep the `url` argument consistent across call sites (usually the same relative path) so de-duplication works as intended.
+`/users` and `/users/` are different keys. Relative URLs are not normalised against `baseURL` for keying by default—the string you pass is the key segment (enable `resolveBaseURL` for `baseURL`-aware keying).
 
 ### Client identity, not configuration equality
 
@@ -645,6 +641,7 @@ Accepted trade-offs (key design, first-callback wins, in-flight-only) match that
 - Shared promise for all joiners until the request settles
 - Optional `onSuccess` / `onError` hooks (with documented join semantics)
 - Default shared instance **and** constructible isolated managers
+- Opt-in **`baseURL`-aware keying** (`resolveBaseURL`) so relative and absolute URLs for the same resource share one in-flight request
 - TypeScript types, ESM + CJS builds
 - Legacy `RequestManager.call` static helper (deprecated)
 

package/dist/cjs/index.d.ts

@@ -1,3 +1,3 @@
-export type { ActiveRequest, RequestIdentity } from './request-manager/index.js';
+export type { ActiveRequest, RequestIdentity, RequestManagerOptions } from './request-manager/index.js';
 export { RequestManager } from './request-manager/index.js';
 export { default } from './request-manager/index.js';

package/dist/cjs/request-manager/index.d.ts

@@ -1,4 +1,4 @@
 import requestManager, { RequestManager } from './request-manager.js';
-export type { ActiveRequest, RequestIdentity } from './request-manager.js';
+export type { ActiveRequest, RequestIdentity, RequestManagerOptions } from './request-manager.js';
 export { RequestManager };
 export default requestManager;

package/dist/cjs/request-manager/request-manager.d.ts

@@ -7,10 +7,28 @@ type MaybePromise<T> = T | Promise<T>;
 export interface RequestIdentity {
     clientId: number;
     method: string;
+    /** URL string as passed to `call`, or resolved against the client's `baseURL` when `resolveBaseURL` is enabled. */
     url: string;
     params: unknown;
+    paramsSerialized: string;
+    /**
+     * Backward-compatible British spelling of `paramsSerialized`.
+     *
+     * @deprecated Use `paramsSerialized` instead; to be removed in a future major release.
+     */
     paramsSerialised: string;
 }
+/**
+ * Configuration options for a {@link RequestManager} instance.
+ */
+export interface RequestManagerOptions {
+    /**
+     * When enabled, relative URLs are resolved against the client's `baseURL` before keying,
+     * so the same logical resource de-duplicates whether callers address it relatively or
+     * absolutely. Disabled by default to preserve historical exact-string keying.
+     */
+    resolveBaseURL?: boolean;
+}
 /**
  * Active in-flight request entry stored in {@link RequestManager.activeRequests}.
  *
@@ -38,6 +56,13 @@ export declare class RequestManager<T = any> {
     activeRequests: Map<RequestKey, ActiveRequest>;
     private clientIds;
     private nextClientId;
+    private readonly resolveBaseURL;
+    /**
+     * Creates an isolated manager.
+     *
+     * @param {RequestManagerOptions} [options] - Optional instance configuration.
+     */
+    constructor(options?: RequestManagerOptions);
     /**
      * Backward-compatible static API that delegates to the shared singleton instance.
      *
@@ -48,47 +73,70 @@ export declare class RequestManager<T = any> {
      * Executes or retrieves an ongoing HTTP request based on the provided URL, method, payload, and configuration.
      *
      * Requests are de-duplicated when they target the same client instance, method, URL, and `config.params`.
+     * When constructed with `resolveBaseURL`, relative URLs are resolved against the client's `baseURL` for keying.
      * Request bodies and other config fields (headers, timeout, signal, etc.) are not part of the key.
      * If `onSuccess` returns a non-`undefined` value, that value becomes the resolved result.
      *
-     * @param client Axios client used to execute the request.
-     * @param method HTTP method.
-     * @param url Target request URL.
-     * @param data Optional request payload.
-     * @param config Optional Axios request configuration.
-     * @param onSuccess Optional callback invoked on success. Returning a value overrides the resolved response.
-     * @param onError Optional callback for request failures only. If it throws, the original request error is rethrown.
+     * @param {AxiosInstance} client - Axios client used to execute the request.
+     * @param {Method} method - HTTP method.
+     * @param {string} url - Target request URL.
+     * @param {any} [data] - Optional request payload.
+     * @param {AxiosRequestConfig|null} [config] - Optional Axios request configuration.
+     * @param {((result: AxiosResponse<TResponse>) => MaybePromise<TSuccess | undefined>) | null} [onSuccess] -
+     *     Optional callback invoked on success. Returning a value overrides the resolved response.
+     * @param {((error: unknown) => void) | null} [onError] - Optional callback for request failures only.
+     *     If it throws, the original request error is rethrown.
+     * @returns {Promise<AxiosResponse<TResponse> | TSuccess | void>} - The shared promise for
+     * the in-flight request.
+     * @throws {TypeError} - If the client is not an Axios-like instance, the method or URL is
+     * invalid, or config.params is not serializable.
      */
     call<TResponse = T, TSuccess = never>(client: AxiosInstance, method: Method, url: string, data?: any, config?: AxiosRequestConfig | null, onSuccess?: ((result: AxiosResponse<TResponse>) => MaybePromise<TSuccess | undefined>) | null, onError?: ((error: unknown) => void) | null): Promise<AxiosResponse<TResponse> | TSuccess | void>;
     /**
      * Builds the stable human-readable identity for an in-flight request.
      *
-     * @param client Axios client instance used for the request.
-     * @param method HTTP method.
-     * @param url Request URL string as passed to `call`.
-     * @param params Axios `config.params` value, if any.
-     * @returns Identity fields used for hashing and inspection.
+     * @param {AxiosInstance} client - Axios client instance used for the request.
+     * @param {Method} method - HTTP method.
+     * @param {string} url - Request URL string as passed to `call`.
+     * @param {AxiosRequestConfig['params']} params - Axios `config.params` value, if any.
+     * @returns {RequestIdentity} - Identity fields used for hashing and inspection.
      */
     private buildRequestIdentity;
+    /**
+     * Resolves a relative URL against the client's `baseURL` for keying, mirroring Axios's
+     * own `buildFullPath` and `combineURLs` semantics.
+     *
+     * @param {string} url - Request URL string as passed to `call`.
+     * @param {AxiosInstance} client - Axios client whose `defaults.baseURL` is the resolution base.
+     * @returns {string} - The URL string used as the key segment.
+     */
+    private resolveUrlAgainstBase;
+    /**
+     * Determines whether a URL is absolute, matching Axios's `isAbsoluteURL` check.
+     *
+     * @param {string} url - URL string to test.
+     * @returns {boolean} - True when `url` has a scheme or is protocol-relative.
+     */
+    private isAbsoluteUrl;
     /**
      * Hashes a request identity into a fixed-length map key.
      *
-     * @param identity Stable request identity.
-     * @returns Lowercase hex SHA-256 digest of the identity string.
+     * @param {RequestIdentity} identity - Stable request identity.
+     * @returns {string} - Lowercase hex SHA-256 digest of the identity string.
      */
     private hashIdentity;
     /**
-     * Serialises query params into a deterministic string for request keys.
+     * Serializes query params into a deterministic string for request keys.
      *
-     * @param params Axios params value (`undefined`, plain object, array, or `URLSearchParams`).
-     * @returns A stable serialisation, or an empty string when params are absent.
+     * @param {AxiosRequestConfig['params']} params - Axios params value (`undefined`, plain object, array, or `URLSearchParams`).
+     * @returns {string} - A stable serialization, or an empty string when params are absent.
      */
     private serializeParams;
     /**
-     * JSON-like serialisation with sorted object keys so param order does not affect identity.
+     * JSON-like serialization with sorted object keys so param order does not affect identity.
      *
-     * @param value Value to serialise.
-     * @returns Deterministic string form of `value`.
+     * @param {unknown} value - Value to serialize.
+     * @returns {string} - Deterministic string form of `value`.
      */
     private stableStringify;
 }

package/dist/cjs/request-manager/request-manager.js

@@ -17,6 +17,15 @@ class RequestManager {
     activeRequests = new Map();
     clientIds = new WeakMap();
     nextClientId = 1;
+    resolveBaseURL;
+    /**
+     * Creates an isolated manager.
+     *
+     * @param {RequestManagerOptions} [options] - Optional instance configuration.
+     */
+    constructor(options = {}) {
+        this.resolveBaseURL = options.resolveBaseURL === true;
+    }
     /**
      * Backward-compatible static API that delegates to the shared singleton instance.
      *
@@ -29,18 +38,28 @@ class RequestManager {
      * Executes or retrieves an ongoing HTTP request based on the provided URL, method, payload, and configuration.
      *
      * Requests are de-duplicated when they target the same client instance, method, URL, and `config.params`.
+     * When constructed with `resolveBaseURL`, relative URLs are resolved against the client's `baseURL` for keying.
      * Request bodies and other config fields (headers, timeout, signal, etc.) are not part of the key.
      * If `onSuccess` returns a non-`undefined` value, that value becomes the resolved result.
      *
-     * @param client Axios client used to execute the request.
-     * @param method HTTP method.
-     * @param url Target request URL.
-     * @param data Optional request payload.
-     * @param config Optional Axios request configuration.
-     * @param onSuccess Optional callback invoked on success. Returning a value overrides the resolved response.
-     * @param onError Optional callback for request failures only. If it throws, the original request error is rethrown.
+     * @param {AxiosInstance} client - Axios client used to execute the request.
+     * @param {Method} method - HTTP method.
+     * @param {string} url - Target request URL.
+     * @param {any} [data] - Optional request payload.
+     * @param {AxiosRequestConfig|null} [config] - Optional Axios request configuration.
+     * @param {((result: AxiosResponse<TResponse>) => MaybePromise<TSuccess | undefined>) | null} [onSuccess] -
+     *     Optional callback invoked on success. Returning a value overrides the resolved response.
+     * @param {((error: unknown) => void) | null} [onError] - Optional callback for request failures only.
+     *     If it throws, the original request error is rethrown.
+     * @returns {Promise<AxiosResponse<TResponse> | TSuccess | void>} - The shared promise for
+     * the in-flight request.
+     * @throws {TypeError} - If the client is not an Axios-like instance, the method or URL is
+     * invalid, or config.params is not serializable.
      */
     call(client, method, url, data = {}, config = {}, onSuccess, onError) {
+        if (client == null || typeof client.request !== 'function') {
+            return Promise.reject(new TypeError('RequestManager.call requires an Axios client instance'));
+        }
         if (typeof method !== 'string' || method.length === 0) {
             return Promise.reject(new TypeError('RequestManager.call requires a non-empty HTTP method string'));
         }
@@ -49,7 +68,13 @@ class RequestManager {
         }
         data ??= {};
         config ??= {};
-        const identity = this.buildRequestIdentity(client, method, url, config.params);
+        let identity;
+        try {
+            identity = this.buildRequestIdentity(client, method, url, config.params);
+        }
+        catch {
+            return Promise.reject(new TypeError('RequestManager.call requires serializable config.params'));
+        }
         const hash = this.hashIdentity(identity);
         const existing = this.activeRequests.get(hash);
         if (existing) {
@@ -95,11 +120,11 @@ class RequestManager {
     /**
      * Builds the stable human-readable identity for an in-flight request.
      *
-     * @param client Axios client instance used for the request.
-     * @param method HTTP method.
-     * @param url Request URL string as passed to `call`.
-     * @param params Axios `config.params` value, if any.
-     * @returns Identity fields used for hashing and inspection.
+     * @param {AxiosInstance} client - Axios client instance used for the request.
+     * @param {Method} method - HTTP method.
+     * @param {string} url - Request URL string as passed to `call`.
+     * @param {AxiosRequestConfig['params']} params - Axios `config.params` value, if any.
+     * @returns {RequestIdentity} - Identity fields used for hashing and inspection.
      */
     buildRequestIdentity(client, method, url, params) {
         let clientId = this.clientIds.get(client);
@@ -107,31 +132,57 @@ class RequestManager {
             clientId = this.nextClientId++;
             this.clientIds.set(client, clientId);
         }
-        const normalisedMethod = method.toLowerCase();
-        const paramsSerialised = this.serializeParams(params);
+        const normalizedMethod = method.toLowerCase();
+        const urlKey = this.resolveBaseURL ? this.resolveUrlAgainstBase(url, client) : url;
+        const paramsSerialized = this.serializeParams(params);
         return {
             clientId,
-            method: normalisedMethod,
-            url,
+            method: normalizedMethod,
+            url: urlKey,
             params: params ?? null,
-            paramsSerialised
+            paramsSerialized,
+            paramsSerialised: paramsSerialized
         };
     }
+    /**
+     * Resolves a relative URL against the client's `baseURL` for keying, mirroring Axios's
+     * own `buildFullPath` and `combineURLs` semantics.
+     *
+     * @param {string} url - Request URL string as passed to `call`.
+     * @param {AxiosInstance} client - Axios client whose `defaults.baseURL` is the resolution base.
+     * @returns {string} - The URL string used as the key segment.
+     */
+    resolveUrlAgainstBase(url, client) {
+        const baseURL = client.defaults?.baseURL;
+        if (typeof baseURL !== 'string' || baseURL.length === 0 || this.isAbsoluteUrl(url)) {
+            return url;
+        }
+        return baseURL.replace(/\/+$/, '') + '/' + url.replace(/^\/+/, '');
+    }
+    /**
+     * Determines whether a URL is absolute, matching Axios's `isAbsoluteURL` check.
+     *
+     * @param {string} url - URL string to test.
+     * @returns {boolean} - True when `url` has a scheme or is protocol-relative.
+     */
+    isAbsoluteUrl(url) {
+        return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
+    }
     /**
      * Hashes a request identity into a fixed-length map key.
      *
-     * @param identity Stable request identity.
-     * @returns Lowercase hex SHA-256 digest of the identity string.
+     * @param {RequestIdentity} identity - Stable request identity.
+     * @returns {string} - Lowercase hex SHA-256 digest of the identity string.
      */
     hashIdentity(identity) {
-        const material = `${identity.clientId}:${identity.method}:${identity.url}:${identity.paramsSerialised}`;
+        const material = `${identity.clientId}:${identity.method}:${identity.url}:${identity.paramsSerialized}`;
         return (0, sha256_js_1.sha256Hex)(material);
     }
     /**
-     * Serialises query params into a deterministic string for request keys.
+     * Serializes query params into a deterministic string for request keys.
      *
-     * @param params Axios params value (`undefined`, plain object, array, or `URLSearchParams`).
-     * @returns A stable serialisation, or an empty string when params are absent.
+     * @param {AxiosRequestConfig['params']} params - Axios params value (`undefined`, plain object, array, or `URLSearchParams`).
+     * @returns {string} - A stable serialization, or an empty string when params are absent.
      */
     serializeParams(params) {
         if (params == null) {
@@ -153,10 +204,10 @@ class RequestManager {
         return this.stableStringify(params);
     }
     /**
-     * JSON-like serialisation with sorted object keys so param order does not affect identity.
+     * JSON-like serialization with sorted object keys so param order does not affect identity.
      *
-     * @param value Value to serialise.
-     * @returns Deterministic string form of `value`.
+     * @param {unknown} value - Value to serialize.
+     * @returns {string} - Deterministic string form of `value`.
      */
     stableStringify(value) {
         if (value === null || typeof value !== 'object') {

package/dist/esm/index.d.ts

@@ -1,3 +1,3 @@
-export type { ActiveRequest, RequestIdentity } from './request-manager/index.js';
+export type { ActiveRequest, RequestIdentity, RequestManagerOptions } from './request-manager/index.js';
 export { RequestManager } from './request-manager/index.js';
 export { default } from './request-manager/index.js';

package/dist/esm/request-manager/index.d.ts

@@ -1,4 +1,4 @@
 import requestManager, { RequestManager } from './request-manager.js';
-export type { ActiveRequest, RequestIdentity } from './request-manager.js';
+export type { ActiveRequest, RequestIdentity, RequestManagerOptions } from './request-manager.js';
 export { RequestManager };
 export default requestManager;

package/dist/esm/request-manager/request-manager.d.ts

@@ -7,10 +7,28 @@ type MaybePromise<T> = T | Promise<T>;
 export interface RequestIdentity {
     clientId: number;
     method: string;
+    /** URL string as passed to `call`, or resolved against the client's `baseURL` when `resolveBaseURL` is enabled. */
     url: string;
     params: unknown;
+    paramsSerialized: string;
+    /**
+     * Backward-compatible British spelling of `paramsSerialized`.
+     *
+     * @deprecated Use `paramsSerialized` instead; to be removed in a future major release.
+     */
     paramsSerialised: string;
 }
+/**
+ * Configuration options for a {@link RequestManager} instance.
+ */
+export interface RequestManagerOptions {
+    /**
+     * When enabled, relative URLs are resolved against the client's `baseURL` before keying,
+     * so the same logical resource de-duplicates whether callers address it relatively or
+     * absolutely. Disabled by default to preserve historical exact-string keying.
+     */
+    resolveBaseURL?: boolean;
+}
 /**
  * Active in-flight request entry stored in {@link RequestManager.activeRequests}.
  *
@@ -38,6 +56,13 @@ export declare class RequestManager<T = any> {
     activeRequests: Map<RequestKey, ActiveRequest>;
     private clientIds;
     private nextClientId;
+    private readonly resolveBaseURL;
+    /**
+     * Creates an isolated manager.
+     *
+     * @param {RequestManagerOptions} [options] - Optional instance configuration.
+     */
+    constructor(options?: RequestManagerOptions);
     /**
      * Backward-compatible static API that delegates to the shared singleton instance.
      *
@@ -48,47 +73,70 @@ export declare class RequestManager<T = any> {
      * Executes or retrieves an ongoing HTTP request based on the provided URL, method, payload, and configuration.
      *
      * Requests are de-duplicated when they target the same client instance, method, URL, and `config.params`.
+     * When constructed with `resolveBaseURL`, relative URLs are resolved against the client's `baseURL` for keying.
      * Request bodies and other config fields (headers, timeout, signal, etc.) are not part of the key.
      * If `onSuccess` returns a non-`undefined` value, that value becomes the resolved result.
      *
-     * @param client Axios client used to execute the request.
-     * @param method HTTP method.
-     * @param url Target request URL.
-     * @param data Optional request payload.
-     * @param config Optional Axios request configuration.
-     * @param onSuccess Optional callback invoked on success. Returning a value overrides the resolved response.
-     * @param onError Optional callback for request failures only. If it throws, the original request error is rethrown.
+     * @param {AxiosInstance} client - Axios client used to execute the request.
+     * @param {Method} method - HTTP method.
+     * @param {string} url - Target request URL.
+     * @param {any} [data] - Optional request payload.
+     * @param {AxiosRequestConfig|null} [config] - Optional Axios request configuration.
+     * @param {((result: AxiosResponse<TResponse>) => MaybePromise<TSuccess | undefined>) | null} [onSuccess] -
+     *     Optional callback invoked on success. Returning a value overrides the resolved response.
+     * @param {((error: unknown) => void) | null} [onError] - Optional callback for request failures only.
+     *     If it throws, the original request error is rethrown.
+     * @returns {Promise<AxiosResponse<TResponse> | TSuccess | void>} - The shared promise for
+     * the in-flight request.
+     * @throws {TypeError} - If the client is not an Axios-like instance, the method or URL is
+     * invalid, or config.params is not serializable.
      */
     call<TResponse = T, TSuccess = never>(client: AxiosInstance, method: Method, url: string, data?: any, config?: AxiosRequestConfig | null, onSuccess?: ((result: AxiosResponse<TResponse>) => MaybePromise<TSuccess | undefined>) | null, onError?: ((error: unknown) => void) | null): Promise<AxiosResponse<TResponse> | TSuccess | void>;
     /**
      * Builds the stable human-readable identity for an in-flight request.
      *
-     * @param client Axios client instance used for the request.
-     * @param method HTTP method.
-     * @param url Request URL string as passed to `call`.
-     * @param params Axios `config.params` value, if any.
-     * @returns Identity fields used for hashing and inspection.
+     * @param {AxiosInstance} client - Axios client instance used for the request.
+     * @param {Method} method - HTTP method.
+     * @param {string} url - Request URL string as passed to `call`.
+     * @param {AxiosRequestConfig['params']} params - Axios `config.params` value, if any.
+     * @returns {RequestIdentity} - Identity fields used for hashing and inspection.
      */
     private buildRequestIdentity;
+    /**
+     * Resolves a relative URL against the client's `baseURL` for keying, mirroring Axios's
+     * own `buildFullPath` and `combineURLs` semantics.
+     *
+     * @param {string} url - Request URL string as passed to `call`.
+     * @param {AxiosInstance} client - Axios client whose `defaults.baseURL` is the resolution base.
+     * @returns {string} - The URL string used as the key segment.
+     */
+    private resolveUrlAgainstBase;
+    /**
+     * Determines whether a URL is absolute, matching Axios's `isAbsoluteURL` check.
+     *
+     * @param {string} url - URL string to test.
+     * @returns {boolean} - True when `url` has a scheme or is protocol-relative.
+     */
+    private isAbsoluteUrl;
     /**
      * Hashes a request identity into a fixed-length map key.
      *
-     * @param identity Stable request identity.
-     * @returns Lowercase hex SHA-256 digest of the identity string.
+     * @param {RequestIdentity} identity - Stable request identity.
+     * @returns {string} - Lowercase hex SHA-256 digest of the identity string.
      */
     private hashIdentity;
     /**
-     * Serialises query params into a deterministic string for request keys.
+     * Serializes query params into a deterministic string for request keys.
      *
-     * @param params Axios params value (`undefined`, plain object, array, or `URLSearchParams`).
-     * @returns A stable serialisation, or an empty string when params are absent.
+     * @param {AxiosRequestConfig['params']} params - Axios params value (`undefined`, plain object, array, or `URLSearchParams`).
+     * @returns {string} - A stable serialization, or an empty string when params are absent.
      */
     private serializeParams;
     /**
-     * JSON-like serialisation with sorted object keys so param order does not affect identity.
+     * JSON-like serialization with sorted object keys so param order does not affect identity.
      *
-     * @param value Value to serialise.
-     * @returns Deterministic string form of `value`.
+     * @param {unknown} value - Value to serialize.
+     * @returns {string} - Deterministic string form of `value`.
      */
     private stableStringify;
 }

package/dist/esm/request-manager/request-manager.js

@@ -14,6 +14,15 @@ export class RequestManager {
     activeRequests = new Map();
     clientIds = new WeakMap();
     nextClientId = 1;
+    resolveBaseURL;
+    /**
+     * Creates an isolated manager.
+     *
+     * @param {RequestManagerOptions} [options] - Optional instance configuration.
+     */
+    constructor(options = {}) {
+        this.resolveBaseURL = options.resolveBaseURL === true;
+    }
     /**
      * Backward-compatible static API that delegates to the shared singleton instance.
      *
@@ -26,18 +35,28 @@ export class RequestManager {
      * Executes or retrieves an ongoing HTTP request based on the provided URL, method, payload, and configuration.
      *
      * Requests are de-duplicated when they target the same client instance, method, URL, and `config.params`.
+     * When constructed with `resolveBaseURL`, relative URLs are resolved against the client's `baseURL` for keying.
      * Request bodies and other config fields (headers, timeout, signal, etc.) are not part of the key.
      * If `onSuccess` returns a non-`undefined` value, that value becomes the resolved result.
      *
-     * @param client Axios client used to execute the request.
-     * @param method HTTP method.
-     * @param url Target request URL.
-     * @param data Optional request payload.
-     * @param config Optional Axios request configuration.
-     * @param onSuccess Optional callback invoked on success. Returning a value overrides the resolved response.
-     * @param onError Optional callback for request failures only. If it throws, the original request error is rethrown.
+     * @param {AxiosInstance} client - Axios client used to execute the request.
+     * @param {Method} method - HTTP method.
+     * @param {string} url - Target request URL.
+     * @param {any} [data] - Optional request payload.
+     * @param {AxiosRequestConfig|null} [config] - Optional Axios request configuration.
+     * @param {((result: AxiosResponse<TResponse>) => MaybePromise<TSuccess | undefined>) | null} [onSuccess] -
+     *     Optional callback invoked on success. Returning a value overrides the resolved response.
+     * @param {((error: unknown) => void) | null} [onError] - Optional callback for request failures only.
+     *     If it throws, the original request error is rethrown.
+     * @returns {Promise<AxiosResponse<TResponse> | TSuccess | void>} - The shared promise for
+     * the in-flight request.
+     * @throws {TypeError} - If the client is not an Axios-like instance, the method or URL is
+     * invalid, or config.params is not serializable.
      */
     call(client, method, url, data = {}, config = {}, onSuccess, onError) {
+        if (client == null || typeof client.request !== 'function') {
+            return Promise.reject(new TypeError('RequestManager.call requires an Axios client instance'));
+        }
         if (typeof method !== 'string' || method.length === 0) {
             return Promise.reject(new TypeError('RequestManager.call requires a non-empty HTTP method string'));
         }
@@ -46,7 +65,13 @@ export class RequestManager {
         }
         data ??= {};
         config ??= {};
-        const identity = this.buildRequestIdentity(client, method, url, config.params);
+        let identity;
+        try {
+            identity = this.buildRequestIdentity(client, method, url, config.params);
+        }
+        catch {
+            return Promise.reject(new TypeError('RequestManager.call requires serializable config.params'));
+        }
         const hash = this.hashIdentity(identity);
         const existing = this.activeRequests.get(hash);
         if (existing) {
@@ -92,11 +117,11 @@ export class RequestManager {
     /**
      * Builds the stable human-readable identity for an in-flight request.
      *
-     * @param client Axios client instance used for the request.
-     * @param method HTTP method.
-     * @param url Request URL string as passed to `call`.
-     * @param params Axios `config.params` value, if any.
-     * @returns Identity fields used for hashing and inspection.
+     * @param {AxiosInstance} client - Axios client instance used for the request.
+     * @param {Method} method - HTTP method.
+     * @param {string} url - Request URL string as passed to `call`.
+     * @param {AxiosRequestConfig['params']} params - Axios `config.params` value, if any.
+     * @returns {RequestIdentity} - Identity fields used for hashing and inspection.
      */
     buildRequestIdentity(client, method, url, params) {
         let clientId = this.clientIds.get(client);
@@ -104,31 +129,57 @@ export class RequestManager {
             clientId = this.nextClientId++;
             this.clientIds.set(client, clientId);
         }
-        const normalisedMethod = method.toLowerCase();
-        const paramsSerialised = this.serializeParams(params);
+        const normalizedMethod = method.toLowerCase();
+        const urlKey = this.resolveBaseURL ? this.resolveUrlAgainstBase(url, client) : url;
+        const paramsSerialized = this.serializeParams(params);
         return {
             clientId,
-            method: normalisedMethod,
-            url,
+            method: normalizedMethod,
+            url: urlKey,
             params: params ?? null,
-            paramsSerialised
+            paramsSerialized,
+            paramsSerialised: paramsSerialized
         };
     }
+    /**
+     * Resolves a relative URL against the client's `baseURL` for keying, mirroring Axios's
+     * own `buildFullPath` and `combineURLs` semantics.
+     *
+     * @param {string} url - Request URL string as passed to `call`.
+     * @param {AxiosInstance} client - Axios client whose `defaults.baseURL` is the resolution base.
+     * @returns {string} - The URL string used as the key segment.
+     */
+    resolveUrlAgainstBase(url, client) {
+        const baseURL = client.defaults?.baseURL;
+        if (typeof baseURL !== 'string' || baseURL.length === 0 || this.isAbsoluteUrl(url)) {
+            return url;
+        }
+        return baseURL.replace(/\/+$/, '') + '/' + url.replace(/^\/+/, '');
+    }
+    /**
+     * Determines whether a URL is absolute, matching Axios's `isAbsoluteURL` check.
+     *
+     * @param {string} url - URL string to test.
+     * @returns {boolean} - True when `url` has a scheme or is protocol-relative.
+     */
+    isAbsoluteUrl(url) {
+        return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
+    }
     /**
      * Hashes a request identity into a fixed-length map key.
      *
-     * @param identity Stable request identity.
-     * @returns Lowercase hex SHA-256 digest of the identity string.
+     * @param {RequestIdentity} identity - Stable request identity.
+     * @returns {string} - Lowercase hex SHA-256 digest of the identity string.
      */
     hashIdentity(identity) {
-        const material = `${identity.clientId}:${identity.method}:${identity.url}:${identity.paramsSerialised}`;
+        const material = `${identity.clientId}:${identity.method}:${identity.url}:${identity.paramsSerialized}`;
         return sha256Hex(material);
     }
     /**
-     * Serialises query params into a deterministic string for request keys.
+     * Serializes query params into a deterministic string for request keys.
      *
-     * @param params Axios params value (`undefined`, plain object, array, or `URLSearchParams`).
-     * @returns A stable serialisation, or an empty string when params are absent.
+     * @param {AxiosRequestConfig['params']} params - Axios params value (`undefined`, plain object, array, or `URLSearchParams`).
+     * @returns {string} - A stable serialization, or an empty string when params are absent.
      */
     serializeParams(params) {
         if (params == null) {
@@ -150,10 +201,10 @@ export class RequestManager {
         return this.stableStringify(params);
     }
     /**
-     * JSON-like serialisation with sorted object keys so param order does not affect identity.
+     * JSON-like serialization with sorted object keys so param order does not affect identity.
      *
-     * @param value Value to serialise.
-     * @returns Deterministic string form of `value`.
+     * @param {unknown} value - Value to serialize.
+     * @returns {string} - Deterministic string form of `value`.
      */
     stableStringify(value) {
         if (value === null || typeof value !== 'object') {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jaseeey/request-manager",
-    "version": "2.2.2",
+    "version": "2.3.0",
     "description": "De-duplicate concurrent Axios HTTP requests so independent callers share one in-flight promise and response",
     "keywords": [
         "axios",
@@ -53,12 +53,12 @@
         "test": "vitest run --coverage"
     },
     "peerDependencies": {
-        "axios": ">=1"
+        "axios": "^1"
     },
     "devDependencies": {
-        "@vitest/coverage-v8": "^4.1.11",
+        "@vitest/coverage-v8": "^5.0.3",
         "axios": "^1.20.0",
-        "typescript": "^5.9.3",
-        "vitest": "^4.1.11"
+        "typescript": "^7.0.2",
+        "vitest": "^5.0.3"
     }
 }