@jaseeey/request-manager 1.0.0 → 2.0.0

package/README.md

@@ -1,8 +1,6 @@
 # RequestManager
 
-## Overview
-
-RequestManager is a JavaScript library designed to manage and regulate HTTP requests efficiently. It ensures that multiple requests to the same URL with the same method are not made concurrently, thus preventing duplicate requests. When a request to a specific URL and method is in progress, subsequent requests to the same URL and method will return the same promise.
+RequestManager is a TypeScript-based library designed to manage and regulate HTTP requests efficiently. It ensures that multiple requests to the same URL with the same method are not made concurrently, thus preventing duplicate requests. When a request to a specific URL and method is in progress, subsequent requests to the same URL and method will return the same promise.
 
 ## Background and Scope
 
@@ -17,8 +15,17 @@ Should you wish to extend the behaviour, or modify it for your own purposes, the
 ## Features
 
 - Prevents duplicate simultaneous requests to the same URL and method.
-- Supports optional onSuccess and onError callbacks for regulated response handling.
-- Easy integration with any project that uses HTTP requests via Axios.
+- Supports TypeScript for improved type safety and developer experience.
+- Allows for optional onSuccess and onError callbacks to handle responses.
+- Generates both CommonJS (CJS) and ECMAScript Module (ESM) distributions for broad compatibility.
+
+## Installation
+
+To install RequestManager, use the following npm command:
+
+```bash
+npm install @jaseeey/request-manager
+```
 
 ## Usage
 
@@ -27,15 +34,15 @@ Here's a basic example of how to use the RequestManager library:
 ### With Callbacks
 
 ```javascript
-import RequestManager from '@jaseeey/request-manager';
+import { RequestManager } from '@jaseeey/request-manager';
 
 const client = axios.create();
 const url = 'https://example.com';
 const method = 'GET';
 
-RequestManager.call(client, method, url).then(res => {
+RequestManager.call(client, method, url, null, null, res => {
     // Handle your response here, any processing will only be run once.
-}).catch(err => {
+}, err => {
     // Handle your error here
 });
 ```
@@ -43,7 +50,7 @@ RequestManager.call(client, method, url).then(res => {
 ### Without Callbacks
 
 ```javascript
-import RequestManager from '@jaseeey/request-manager';
+import { RequestManager } from '@jaseeey/request-manager';
 
 const client = axios.create();
 const url = 'https://example.com';

package/dist/cjs/index.d.ts

@@ -0,0 +1,2 @@
+import RequestManager from './request-manager/request-manager';
+export { RequestManager };

package/dist/cjs/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestManager = void 0;
+const request_manager_1 = __importDefault(require("./request-manager/request-manager"));
+exports.RequestManager = request_manager_1.default;

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

@@ -0,0 +1,2 @@
+import RequestManager from './request-manager';
+export { RequestManager };

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

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestManager = void 0;
+const request_manager_1 = __importDefault(require("./request-manager"));
+exports.RequestManager = request_manager_1.default;

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

@@ -0,0 +1,29 @@
+import { AxiosInstance, AxiosRequestConfig, AxiosResponse, Method } from 'axios';
+type RequestKey = string;
+interface RequestPromise<T = any> {
+    original: Promise<AxiosResponse<T, any>>;
+    processed: Promise<AxiosResponse<T, any> | void>;
+}
+/**
+ * RequestManager
+ *
+ * Manages and regulates HTTP requests to ensure that multiple requests to the same URL and method are not made
+ * concurrently. When a request to a specific URL and method is in progress, subsequent requests to the same URL and
+ * method will return the same promise, preventing duplicate requests.
+ */
+declare class RequestManager<T = any> {
+    /**
+     * A Map to store active requests, with each key being a combination of URL and HTTP method and its corresponding
+     * value being the Promise of the ongoing HTTP request.
+     */
+    activeRequests: Map<RequestKey, RequestPromise<T>>;
+    /**
+     * Executes or retrieves an ongoing HTTP request based on the provided URL, method, payload, and configuration. It
+     * de-duplicates requests to the same URL with the same method by returning a previously stored promise if available.
+     * Upon completion of the request, it optionally invokes an onSuccess callback if the request is successful, or an
+     * onFailure callback if the request fails.
+     */
+    call(client: AxiosInstance, method: Method, url: string, data?: any, config?: AxiosRequestConfig | null, onSuccess?: ((result: AxiosResponse) => void) | null, onError?: ((error: any) => void) | null): Promise<AxiosResponse | void>;
+}
+declare const _default: RequestManager<any>;
+export default _default;

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * RequestManager
+ *
+ * Manages and regulates HTTP requests to ensure that multiple requests to the same URL and method are not made
+ * concurrently. When a request to a specific URL and method is in progress, subsequent requests to the same URL and
+ * method will return the same promise, preventing duplicate requests.
+ */
+class RequestManager {
+    /**
+     * A Map to store active requests, with each key being a combination of URL and HTTP method and its corresponding
+     * value being the Promise of the ongoing HTTP request.
+     */
+    activeRequests = new Map();
+    /**
+     * Executes or retrieves an ongoing HTTP request based on the provided URL, method, payload, and configuration. It
+     * de-duplicates requests to the same URL with the same method by returning a previously stored promise if available.
+     * Upon completion of the request, it optionally invokes an onSuccess callback if the request is successful, or an
+     * onFailure callback if the request fails.
+     */
+    async call(client, method, url, data = {}, config = {}, onSuccess, onError) {
+        data ??= {};
+        config ??= {};
+        const key = `${method.toLowerCase()}:${url}`;
+        if (this.activeRequests.has(key)) {
+            return this.activeRequests.get(key).processed;
+        }
+        const processRequest = async (responsePromise) => {
+            try {
+                const requestResult = await responsePromise;
+                const callbackResult = onSuccess && typeof onSuccess === 'function'
+                    ? onSuccess(requestResult)
+                    : undefined;
+                return callbackResult !== undefined
+                    ? callbackResult
+                    : requestResult;
+            }
+            catch (err) {
+                if (onError && typeof onError === 'function') {
+                    onError(err);
+                    return;
+                }
+                throw err;
+            }
+        };
+        const requestPromise = client.request({ ...config, method, url, data }).finally(() => {
+            this.activeRequests.delete(key);
+        });
+        const processedPromise = processRequest(requestPromise);
+        this.activeRequests.set(key, { original: requestPromise, processed: processedPromise });
+        return processedPromise;
+    }
+}
+exports.default = new RequestManager();

package/dist/esm/index.d.ts

@@ -0,0 +1,2 @@
+import RequestManager from './request-manager/request-manager';
+export { RequestManager };

package/dist/esm/index.js

@@ -0,0 +1,2 @@
+import RequestManager from './request-manager/request-manager';
+export { RequestManager };

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

@@ -0,0 +1,2 @@
+import RequestManager from './request-manager';
+export { RequestManager };

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

@@ -0,0 +1,2 @@
+import RequestManager from './request-manager';
+export { RequestManager };

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

@@ -0,0 +1,29 @@
+import { AxiosInstance, AxiosRequestConfig, AxiosResponse, Method } from 'axios';
+type RequestKey = string;
+interface RequestPromise<T = any> {
+    original: Promise<AxiosResponse<T, any>>;
+    processed: Promise<AxiosResponse<T, any> | void>;
+}
+/**
+ * RequestManager
+ *
+ * Manages and regulates HTTP requests to ensure that multiple requests to the same URL and method are not made
+ * concurrently. When a request to a specific URL and method is in progress, subsequent requests to the same URL and
+ * method will return the same promise, preventing duplicate requests.
+ */
+declare class RequestManager<T = any> {
+    /**
+     * A Map to store active requests, with each key being a combination of URL and HTTP method and its corresponding
+     * value being the Promise of the ongoing HTTP request.
+     */
+    activeRequests: Map<RequestKey, RequestPromise<T>>;
+    /**
+     * Executes or retrieves an ongoing HTTP request based on the provided URL, method, payload, and configuration. It
+     * de-duplicates requests to the same URL with the same method by returning a previously stored promise if available.
+     * Upon completion of the request, it optionally invokes an onSuccess callback if the request is successful, or an
+     * onFailure callback if the request fails.
+     */
+    call(client: AxiosInstance, method: Method, url: string, data?: any, config?: AxiosRequestConfig | null, onSuccess?: ((result: AxiosResponse) => void) | null, onError?: ((error: any) => void) | null): Promise<AxiosResponse | void>;
+}
+declare const _default: RequestManager<any>;
+export default _default;

package/{request-manager.js → dist/esm/request-manager/request-manager.js}

@@ -6,31 +6,18 @@
  * method will return the same promise, preventing duplicate requests.
  */
 class RequestManager {
-
     /**
      * A Map to store active requests, with each key being a combination of URL and HTTP method and its corresponding
      * value being the Promise of the ongoing HTTP request.
-     *
-     * @type {Map<string, Promise>}
      */
     activeRequests = new Map();
-
     /**
      * Executes or retrieves an ongoing HTTP request based on the provided URL, method, payload, and configuration. It
      * de-duplicates requests to the same URL with the same method by returning a previously stored promise if available.
      * Upon completion of the request, it optionally invokes an onSuccess callback if the request is successful, or an
      * onFailure callback if the request fails.
-     *
-     * @param {AxiosInstance} client
-     * @param {string} method
-     * @param {string} url
-     * @param {Object|null} [data=null]
-     * @param {Object|null} [config=null]
-     * @param {Function|null} [onSuccess=null]
-     * @param {Function|null} [onError=null]
-     * @returns {Promise}
      */
-    async call(client, method, url, data = null, config = null, onSuccess = null, onError = null) {
+    async call(client, method, url, data = {}, config = {}, onSuccess, onError) {
         data ??= {};
         config ??= {};
         const key = `${method.toLowerCase()}:${url}`;
@@ -63,5 +50,4 @@ class RequestManager {
         return processedPromise;
     }
 }
-
 export default new RequestManager();

package/package.json

@@ -1,24 +1,44 @@
 {
-  "name": "@jaseeey/request-manager",
-  "type": "module",
-  "version": "1.0.0",
-  "description": "A library to prevent multiple API requests when called simultaneously",
-  "main": "request-manager.js",
-  "license": "MIT",
-  "author": "Jason Ilicic <me@jasey.io>",
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/jaseeey/request-manager.git"
-  },
-  "bugs": {
-    "url": "https://github.com/jaseeey/request-manager/issues"
-  },
-  "homepage": "https://github.com/jaseeey/request-manager#readme",
-  "scripts": {
-    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
-  },
-  "devDependencies": {
-    "@jest/globals": "^29.7.0",
-    "jest": "^29.7.0"
-  }
+    "name": "@jaseeey/request-manager",
+    "version": "2.0.0",
+    "description": "A library to prevent multiple API requests when called simultaneously",
+    "license": "MIT",
+    "author": "Jason Ilicic <me@jasey.io>",
+    "repository": {
+        "type": "git",
+        "url": "git+ssh://git@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": {
+        "build:esm": "tsc -p tsconfig.esm.json",
+        "build:cjs": "tsc -p tsconfig.cjs.json",
+        "build": "npm run build:esm && npm run build:cjs",
+        "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
+    },
+    "dependencies": {
+        "axios": "^1.6.8"
+    },
+    "devDependencies": {
+        "@jest/globals": "^29.7.0",
+        "@types/axios": "^0.14.0",
+        "@types/jest": "^29.5.12",
+        "jest": "^29.7.0",
+        "ts-jest": "^29.1.2",
+        "typescript": "^5.4.3"
+    },
+    "main": "./dist/cjs/index.js",
+    "module": "./dist/esm/index.js",
+    "types": "./dist/esm/index.d.ts",
+    "exports": {
+        ".": {
+            "require": "./dist/cjs/index.js",
+            "import": "./dist/esm/index.js"
+        }
+    }
 }

package/index.js

@@ -1,3 +0,0 @@
-import RequestManager from './request-manager.js';
-
-export { RequestManager };

package/jest.config.mjs

@@ -1,9 +0,0 @@
-export default {
-    clearMocks: true,
-    collectCoverage: true,
-    coverageDirectory: 'coverage',
-    coverageProvider: 'v8',
-    setupFiles: [],
-    testEnvironment: 'node',
-    transform: {}
-};

package/test/request-manager.spec.js

@@ -1,97 +0,0 @@
-import RequestManager from '../request-manager.js';
-import { afterEach, beforeEach, describe, expect, jest, test } from '@jest/globals';
-
-describe('RequestManager', () => {
-
-    let mockClient;
-
-    const mockURL1 = 'https://example.com';
-    const mockURL2 = 'https://example2.com';
-    const mockResponse1 = { data: 'response' };
-    const mockResponse2 = { data: 'response2' };
-
-    beforeEach(() => {
-        const mockRequests = new Map([
-            [ mockURL1, mockResponse1 ],
-            [ mockURL2, mockResponse2 ]
-        ]);
-        mockClient = {
-            request: jest.fn().mockImplementation(({ url }) => {
-                if (mockRequests.has(url)) {
-                    return Promise.resolve(mockRequests.get(url));
-                }
-                return Promise.reject(new Error('Mock URL not registered'));
-            })
-        };
-    });
-
-    afterEach(() => {
-        RequestManager.activeRequests.clear();
-    });
-
-    test('prevents duplicate simultaneous requests', async () => {
-        const [ firstResponse, secondResponse, thirdResponse ] = await Promise.all([
-            RequestManager.call(mockClient, 'GET', mockURL1),
-            RequestManager.call(mockClient, 'GET', mockURL1),
-            RequestManager.call(mockClient, 'GET', mockURL1)
-        ]);
-        expect(mockClient.request).toHaveBeenCalledTimes(1);
-        expect(firstResponse).toBe(secondResponse);
-        expect(firstResponse).toBe(thirdResponse);
-        expect(RequestManager.activeRequests.has(`post:${ mockURL1 }`)).toBeFalsy();
-    });
-
-    test('handles different requests independently', async () => {
-        const [ firstResponse, secondResponse, thirdResponse ] = await Promise.all([
-            RequestManager.call(mockClient, 'GET', mockURL1),
-            RequestManager.call(mockClient, 'GET', mockURL2),
-            RequestManager.call(mockClient, 'GET', mockURL2)
-        ])
-        expect(firstResponse).toBe(mockResponse1);
-        expect(secondResponse).toBe(mockResponse2);
-        expect(secondResponse).toBe(thirdResponse);
-        expect(mockClient.request).toHaveBeenCalledTimes(2);
-    });
-
-    test('calls onSuccess callback on successful request', async () => {
-        const onSuccessCb = jest.fn();
-        await RequestManager.call(mockClient, 'GET', mockURL1, null, null, onSuccessCb);
-        expect(onSuccessCb).toHaveBeenCalledWith(mockResponse1);
-    });
-
-    test('calls onError callback on request failure', async () => {
-        const error = new Error('Request failed');
-        mockClient.request.mockRejectedValueOnce(error);
-        const onErrorCb = jest.fn();
-        await RequestManager.call(mockClient, 'GET', mockURL1, null, null, null, onErrorCb);
-        expect(onErrorCb).toHaveBeenCalledWith(error);
-    });
-
-    test('returns the response when no callbacks are provided', async () => {
-        const result = await RequestManager.call(mockClient, 'GET', mockURL1);
-        expect(result).toBe(mockResponse1);
-    });
-
-    test('throws an error when the request fails and no onError callback is provided', async () => {
-        const error = new Error('Request failed');
-        mockClient.request.mockRejectedValueOnce(error);
-        await expect(RequestManager.call(mockClient, 'GET', mockURL1)).rejects.toThrow(error);
-    });
-
-    test('allows a new request after the previous one completes', async () => {
-        await RequestManager.call(mockClient, 'GET', mockURL1);
-        mockClient.request.mockClear();
-        await RequestManager.call(mockClient, 'GET', mockURL1);
-        expect(mockClient.request).toHaveBeenCalledTimes(1);
-    });
-
-    test('handles requests with case-insensitive method', async () => {
-        const [ firstResponse, secondResponse ] = await Promise.all([
-            RequestManager.call(mockClient, 'gET', mockURL1),
-            RequestManager.call(mockClient, 'gEt', mockURL1)
-        ])
-        expect(firstResponse).toBe(mockResponse1);
-        expect(secondResponse).toBe(secondResponse);
-        expect(mockClient.request).toHaveBeenCalledTimes(1);
-    });
-});