@jaseeey/request-manager 2.1.4 → 2.2.1

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

@@ -1,3 +1,4 @@
+import { sha256Hex } from './sha256.js';
 /**
  * RequestManager
  *
@@ -7,8 +8,8 @@
  */
 export class RequestManager {
     /**
-     * A Map to store active requests, with each key being a combination of client instance, URL, and HTTP method and
-     * its corresponding value being the Promise of the ongoing HTTP request.
+     * In-flight requests keyed by a short SHA-256 hash of the request identity.
+     * Entry values expose `identity` for debugging plus `original` / `processed` promises.
      */
     activeRequests = new Map();
     clientIds = new WeakMap();
@@ -24,7 +25,8 @@ export class RequestManager {
     /**
      * Executes or retrieves an ongoing HTTP request based on the provided URL, method, payload, and configuration.
      *
-     * Requests are de-duplicated only when they target the same client instance, method, and URL.
+     * Requests are de-duplicated when they target the same client instance, method, URL, and `config.params`.
+     * 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.
@@ -33,50 +35,136 @@ export class RequestManager {
      * @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 invoked on error. If provided, the promise resolves to `void` after handling.
+     * @param onError Optional callback for request failures only. If it throws, the original request error is rethrown.
      */
-    async call(client, method, url, data = {}, config = {}, onSuccess, onError) {
+    call(client, method, url, data = {}, config = {}, onSuccess, onError) {
+        if (typeof method !== 'string' || method.length === 0) {
+            return Promise.reject(new TypeError('RequestManager.call requires a non-empty HTTP method string'));
+        }
+        if (typeof url !== 'string') {
+            return Promise.reject(new TypeError('RequestManager.call requires a URL string'));
+        }
         data ??= {};
         config ??= {};
-        const key = this.buildRequestKey(client, method, url);
-        if (this.activeRequests.has(key)) {
-            return this.activeRequests.get(key).processed;
+        const identity = this.buildRequestIdentity(client, method, url, config.params);
+        const hash = this.hashIdentity(identity);
+        const existing = this.activeRequests.get(hash);
+        if (existing) {
+            return existing.processed;
         }
         const processRequest = async (responsePromise) => {
+            let requestResult;
             try {
-                const requestResult = await responsePromise;
-                const callbackResult = onSuccess && typeof onSuccess === 'function'
-                    ? await onSuccess(requestResult)
-                    : undefined;
-                return callbackResult !== undefined
-                    ? callbackResult
-                    : requestResult;
+                requestResult = await responsePromise;
             }
             catch (err) {
                 if (onError && typeof onError === 'function') {
-                    onError(err);
+                    try {
+                        onError(err);
+                    }
+                    catch {
+                        throw err;
+                    }
                     return;
                 }
                 throw err;
             }
+            if (!(onSuccess && typeof onSuccess === 'function')) {
+                return requestResult;
+            }
+            const callbackResult = await onSuccess(requestResult);
+            return callbackResult !== undefined
+                ? callbackResult
+                : requestResult;
         };
         const requestPromise = client.request({ ...config, method, url, data }).finally(() => {
-            this.activeRequests.delete(key);
+            this.activeRequests.delete(hash);
         });
         const processedPromise = processRequest(requestPromise);
-        this.activeRequests.set(key, { original: requestPromise, processed: processedPromise });
+        this.activeRequests.set(hash, {
+            hash,
+            identity,
+            original: requestPromise,
+            processed: processedPromise
+        });
         return processedPromise;
     }
     /**
-     * Creates a stable in-memory key for de-duplication within this manager instance.
+     * 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.
      */
-    buildRequestKey(client, method, url) {
+    buildRequestIdentity(client, method, url, params) {
         let clientId = this.clientIds.get(client);
         if (!clientId) {
             clientId = this.nextClientId++;
             this.clientIds.set(client, clientId);
         }
-        return `${clientId}:${method.toLowerCase()}:${url}`;
+        const normalisedMethod = method.toLowerCase();
+        const paramsSerialised = this.serializeParams(params);
+        return {
+            clientId,
+            method: normalisedMethod,
+            url,
+            params: params ?? null,
+            paramsSerialised
+        };
+    }
+    /**
+     * 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.
+     */
+    hashIdentity(identity) {
+        const material = `${identity.clientId}:${identity.method}:${identity.url}:${identity.paramsSerialised}`;
+        return sha256Hex(material);
+    }
+    /**
+     * Serialises 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.
+     */
+    serializeParams(params) {
+        if (params == null) {
+            return '';
+        }
+        if (typeof URLSearchParams !== 'undefined' && params instanceof URLSearchParams) {
+            if ([...params.keys()].length === 0) {
+                return '';
+            }
+            const asObject = {};
+            for (const key of [...params.keys()].sort()) {
+                asObject[key] = params.getAll(key);
+            }
+            return this.stableStringify(asObject);
+        }
+        if (typeof params === 'object' && !Array.isArray(params) && Object.keys(params).length === 0) {
+            return '';
+        }
+        return this.stableStringify(params);
+    }
+    /**
+     * JSON-like serialisation with sorted object keys so param order does not affect identity.
+     *
+     * @param value Value to serialise.
+     * @returns Deterministic string form of `value`.
+     */
+    stableStringify(value) {
+        if (value === null || typeof value !== 'object') {
+            return JSON.stringify(value);
+        }
+        if (Array.isArray(value)) {
+            return `[${value.map(entry => this.stableStringify(entry)).join(',')}]`;
+        }
+        const record = value;
+        const keys = Object.keys(record).sort();
+        return `{${keys.map(key => `${JSON.stringify(key)}:${this.stableStringify(record[key])}`).join(',')}}`;
     }
 }
 const requestManager = new RequestManager();

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

@@ -0,0 +1,14 @@
+/**
+ * Synchronous SHA-256 hex digest for browser and Node without async WebCrypto.
+ *
+ * @param message UTF-8 string to hash.
+ * @returns Lowercase hex digest.
+ */
+export declare function sha256Hex(message: string): string;
+/**
+ * Encodes a string as UTF-8 bytes.
+ *
+ * @param message String to encode.
+ * @returns UTF-8 byte array.
+ */
+export declare function utf8ToBytes(message: string): Uint8Array;

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

@@ -0,0 +1,102 @@
+/**
+ * Synchronous SHA-256 hex digest for browser and Node without async WebCrypto.
+ *
+ * @param message UTF-8 string to hash.
+ * @returns Lowercase hex digest.
+ */
+export function sha256Hex(message) {
+    const bytes = utf8ToBytes(message);
+    const bitLength = bytes.length * 8;
+    const withOne = new Uint8Array(((bytes.length + 9 + 63) & ~63));
+    withOne.set(bytes);
+    withOne[bytes.length] = 0x80;
+    const view = new DataView(withOne.buffer);
+    view.setUint32(withOne.length - 8, Math.floor(bitLength / 0x100000000), false);
+    view.setUint32(withOne.length - 4, bitLength >>> 0, false);
+    let h0 = 0x6a09e667;
+    let h1 = 0xbb67ae85;
+    let h2 = 0x3c6ef372;
+    let h3 = 0xa54ff53a;
+    let h4 = 0x510e527f;
+    let h5 = 0x9b05688c;
+    let h6 = 0x1f83d9ab;
+    let h7 = 0x5be0cd19;
+    const w = new Int32Array(64);
+    const k = SHA256_K;
+    for (let offset = 0; offset < withOne.length; offset += 64) {
+        for (let i = 0; i < 16; i++) {
+            w[i] = view.getInt32(offset + i * 4, false);
+        }
+        for (let i = 16; i < 64; i++) {
+            const s0 = rightRotate(w[i - 15], 7) ^ rightRotate(w[i - 15], 18) ^ (w[i - 15] >>> 3);
+            const s1 = rightRotate(w[i - 2], 17) ^ rightRotate(w[i - 2], 19) ^ (w[i - 2] >>> 10);
+            w[i] = (w[i - 16] + s0 + w[i - 7] + s1) | 0;
+        }
+        let a = h0;
+        let b = h1;
+        let c = h2;
+        let d = h3;
+        let e = h4;
+        let f = h5;
+        let g = h6;
+        let h = h7;
+        for (let i = 0; i < 64; i++) {
+            const S1 = rightRotate(e, 6) ^ rightRotate(e, 11) ^ rightRotate(e, 25);
+            const ch = (e & f) ^ (~e & g);
+            const temp1 = (h + S1 + ch + k[i] + w[i]) | 0;
+            const S0 = rightRotate(a, 2) ^ rightRotate(a, 13) ^ rightRotate(a, 22);
+            const maj = (a & b) ^ (a & c) ^ (b & c);
+            const temp2 = (S0 + maj) | 0;
+            h = g;
+            g = f;
+            f = e;
+            e = (d + temp1) | 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (temp1 + temp2) | 0;
+        }
+        h0 = (h0 + a) | 0;
+        h1 = (h1 + b) | 0;
+        h2 = (h2 + c) | 0;
+        h3 = (h3 + d) | 0;
+        h4 = (h4 + e) | 0;
+        h5 = (h5 + f) | 0;
+        h6 = (h6 + g) | 0;
+        h7 = (h7 + h) | 0;
+    }
+    return [h0, h1, h2, h3, h4, h5, h6, h7].map(wordToHex).join('');
+}
+function rightRotate(value, amount) {
+    return (value >>> amount) | (value << (32 - amount));
+}
+function wordToHex(value) {
+    return (value >>> 0).toString(16).padStart(8, '0');
+}
+/**
+ * Encodes a string as UTF-8 bytes.
+ *
+ * @param message String to encode.
+ * @returns UTF-8 byte array.
+ */
+export function utf8ToBytes(message) {
+    if (typeof TextEncoder !== 'undefined') {
+        return new TextEncoder().encode(message);
+    }
+    const encoded = unescape(encodeURIComponent(message));
+    const bytes = new Uint8Array(encoded.length);
+    for (let i = 0; i < encoded.length; i++) {
+        bytes[i] = encoded.charCodeAt(i);
+    }
+    return bytes;
+}
+const SHA256_K = new Int32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+]);

package/package.json

@@ -1,36 +1,29 @@
 {
     "name": "@jaseeey/request-manager",
-    "version": "2.1.4",
-    "description": "A library to prevent multiple API requests when called simultaneously",
+    "version": "2.2.1",
+    "description": "De-duplicate concurrent Axios HTTP requests so independent callers share one in-flight promise and response",
+    "keywords": [
+        "axios",
+        "http",
+        "request",
+        "dedupe",
+        "de-duplicate",
+        "inflight",
+        "promise",
+        "typescript"
+    ],
     "license": "MIT",
     "author": "Jason Ilicic <me@jasey.io>",
+    "homepage": "https://github.com/jaseeey/request-manager#readme",
     "repository": {
         "type": "git",
-        "url": "git+ssh://git@github.com/jaseeey/request-manager.git"
+        "url": "git+https://github.com/jaseeey/request-manager.git"
     },
     "bugs": {
         "url": "https://github.com/jaseeey/request-manager/issues"
     },
-    "homepage": "https://github.com/jaseeey/request-manager#readme",
-    "files": [
-        "dist"
-    ],
-    "scripts": {
-        "prebuild": "rm -rf dist",
-        "build:esm": "tsc -p tsconfig.esm.json && echo '{\"type\": \"module\"}' > dist/esm/package.json",
-        "build:cjs": "tsc -p tsconfig.cjs.json && echo '{\"type\": \"commonjs\"}' > dist/cjs/package.json",
-        "build": "npm run build:esm && npm run build:cjs",
-        "prepack": "npm run build",
-        "test": "vitest run --coverage"
-    },
-    "dependencies": {
-        "axios": "^1.16.0"
-    },
-    "devDependencies": {
-        "@vitest/coverage-v8": "^4.1.4",
-        "braces": "^3.0.3",
-        "typescript": "^5.9.3",
-        "vitest": "^4.1.4"
+    "engines": {
+        "node": ">=18"
     },
     "main": "./dist/cjs/index.js",
     "module": "./dist/esm/index.js",
@@ -46,5 +39,26 @@
             "require": "./dist/cjs/request-manager/index.js",
             "import": "./dist/esm/request-manager/index.js"
         }
+    },
+    "files": [
+        "dist"
+    ],
+    "sideEffects": false,
+    "scripts": {
+        "prebuild": "rm -rf dist",
+        "build": "npm run build:esm && npm run build:cjs",
+        "build:esm": "tsc -p tsconfig.esm.json && echo '{\"type\": \"module\"}' > dist/esm/package.json",
+        "build:cjs": "tsc -p tsconfig.cjs.json && echo '{\"type\": \"commonjs\"}' > dist/cjs/package.json",
+        "prepack": "npm run build",
+        "test": "vitest run --coverage"
+    },
+    "peerDependencies": {
+        "axios": ">=1"
+    },
+    "devDependencies": {
+        "@vitest/coverage-v8": "^4.1.10",
+        "axios": "^1.18.1",
+        "typescript": "^5.9.3",
+        "vitest": "^4.1.10"
     }
 }