reqforge 0.8.0 → 0.10.0

package/README.md

@@ -11,16 +11,34 @@ npm install reqforge
 ## Quick Start
 
 ```javascript
-const { config, request, retry } = require('reqforge');
-
-// Make a request with automatic retry
-retry.withRetry(() => {
-  return request.get('/users')
-    .then(res => res.json());
-}, { maxRetries: 3, delay: 1000 })
+const { request, interceptor } = require('reqforge');
+
+// Add a request interceptor
+const reqInterceptor = interceptor.createRequestInterceptor();
+reqInterceptor.use((config) => {
+  console.log('Request:', config.url);
+  return config;
+});
+
+// Make a request
+request.get('/users')
+  .then(res => res.json())
   .then(data => console.log(data));
 ```
 
+## Interceptors
+
+The `interceptor` module provides request and response interception:
+
+- `createRequestInterceptor()` - Create request interceptor manager
+- `createResponseInterceptor()` - Create response interceptor manager
+
+### InterceptorManager Methods
+
+- `use(fulfilled, rejected)` - Add interceptor handler
+- `eject(id)` - Remove interceptor handler
+- `clear()` - Clear all handlers
+
 ## Retry Mechanism
 
 The `retry` module provides:
@@ -28,15 +46,6 @@ The `retry` module provides:
 - `withRetry(fn, options)` - Execute function with automatic retry
 - `calculateBackoff(attempt, baseDelay, maxDelay)` - Calculate exponential backoff delay
 
-### Retry Options
-
-| Option | Default | Description |
-|--------|---------|-------------|
-| `maxRetries` | 3 | Maximum number of retry attempts |
-| `delay` | 1000 | Initial delay in milliseconds |
-| `backoff` | 2 | Backoff multiplier |
-| `shouldRetry` | `() => true` | Function to determine if retry should occur |
-
 ## Error Handling
 
 The `errors` module provides:
@@ -47,7 +56,6 @@ The `errors` module provides:
 - `AuthError` - Authentication failures
 - `ValidationError` - Validation errors
 - `ErrorCodes` - Error code constants
-- `createErrorFromResponse(response)` - Create error from response
 
 ## Authentication
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reqforge",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "A lightweight, flexible HTTP client library with request interception, automatic retry, and logging capabilities, designed for modern web applications.",
   "main": "src/index.js",
   "scripts": {

package/src/cache.js

@@ -0,0 +1,100 @@
+/**
+ * Cache module for ReqForge
+ * @module cache
+ */
+
+/**
+ * Simple in-memory cache with TTL support
+ */
+class MemoryCache {
+  constructor(options = {}) {
+    this.store = new Map();
+    this.defaultTTL = options.defaultTTL || 60000;
+  }
+
+  /**
+   * Get value from cache
+   * @param {string} key - Cache key
+   * @returns {*|null} Cached value or null
+   */
+  get(key) {
+    const entry = this.store.get(key);
+    if (!entry) return null;
+
+    if (Date.now() > entry.expiry) {
+      this.store.delete(key);
+      return null;
+    }
+
+    return entry.value;
+  }
+
+  /**
+   * Set value in cache
+   * @param {string} key - Cache key
+   * @param {*} value - Value to cache
+   * @param {number} ttl - Time to live in ms
+   */
+  set(key, value, ttl) {
+    this.store.set(key, {
+      value,
+      expiry: Date.now() + (ttl || this.defaultTTL)
+    });
+  }
+
+  /**
+   * Check if key exists and is not expired
+   * @param {string} key - Cache key
+   * @returns {boolean} True if valid
+   */
+  has(key) {
+    return this.get(key) !== null;
+  }
+
+  /**
+   * Delete key from cache
+   * @param {string} key - Cache key
+   */
+  delete(key) {
+    this.store.delete(key);
+  }
+
+  /**
+   * Clear all cached entries
+   */
+  clear() {
+    this.store.clear();
+  }
+
+  /**
+   * Get cache size
+   * @returns {number} Number of entries
+   */
+  size() {
+    let count = 0;
+    this.store.forEach((entry, key) => {
+      if (Date.now() <= entry.expiry) {
+        count++;
+      } else {
+        this.store.delete(key);
+      }
+    });
+    return count;
+  }
+}
+
+/**
+ * Create cache key from URL and params
+ * @param {string} url - Request URL
+ * @param {Object} params - Request params
+ * @returns {string} Cache key
+ */
+function createCacheKey(url, params = {}) {
+  const normalized = { url, ...params };
+  return JSON.stringify(normalized);
+}
+
+module.exports = {
+  MemoryCache,
+  createCacheKey
+};

package/src/index.js

@@ -10,6 +10,8 @@ const Logger = require('./logger');
 const auth = require('./auth');
 const errors = require('./errors');
 const retry = require('./retry');
+const interceptor = require('./interceptor');
+const cache = require('./cache');
 
 module.exports = {
   config,
@@ -18,5 +20,7 @@ module.exports = {
   Logger,
   auth,
   errors,
-  retry
+  retry,
+  interceptor,
+  cache
 };

package/src/interceptor.js

@@ -0,0 +1,88 @@
+/**
+ * Interceptor module for ReqForge
+ * @module interceptor
+ */
+
+/**
+ * Interceptor manager for request and response hooks
+ */
+class InterceptorManager {
+  constructor() {
+    this.handlers = [];
+  }
+
+  /**
+   * Add an interceptor handler
+   * @param {Function} fulfilled - Handler for fulfilled promise
+   * @param {Function} rejected - Handler for rejected promise
+   * @returns {number} Handler ID
+   */
+  use(fulfilled, rejected) {
+    this.handlers.push({
+      fulfilled,
+      rejected,
+      id: this.handlers.length
+    });
+    return this.handlers.length - 1;
+  }
+
+  /**
+   * Remove an interceptor handler
+   * @param {number} id - Handler ID
+   */
+  eject(id) {
+    if (this.handlers[id]) {
+      this.handlers[id] = null;
+    }
+  }
+
+  /**
+   * Execute all handlers
+   * @param {*} data - Data to pass through handlers
+   * @returns {Promise} Processed data
+   */
+  forEach(data) {
+    const chain = [Promise.resolve(data)];
+    this.handlers.forEach(handler => {
+      if (handler) {
+        chain.push(handler.fulfilled, handler.rejected);
+      }
+    });
+    let promise = Promise.resolve(data);
+    this.handlers.forEach(handler => {
+      if (handler) {
+        promise = promise.then(handler.fulfilled, handler.rejected);
+      }
+    });
+    return promise;
+  }
+
+  /**
+   * Clear all handlers
+   */
+  clear() {
+    this.handlers = [];
+  }
+}
+
+/**
+ * Create request interceptor
+ * @returns {InterceptorManager} Request interceptor
+ */
+function createRequestInterceptor() {
+  return new InterceptorManager();
+}
+
+/**
+ * Create response interceptor
+ * @returns {InterceptorManager} Response interceptor
+ */
+function createResponseInterceptor() {
+  return new InterceptorManager();
+}
+
+module.exports = {
+  InterceptorManager,
+  createRequestInterceptor,
+  createResponseInterceptor
+};