reqforge 0.6.0 → 0.8.0

package/README.md

@@ -11,22 +11,44 @@ npm install reqforge
 ## Quick Start
 
 ```javascript
-const { config, utils, request, Logger, auth } = require('reqforge');
+const { config, request, retry } = require('reqforge');
 
-// Get the base URL for API requests
-const baseURL = config.getBaseURL();
-console.log(baseURL); // https://api.example.com/v1
-
-// Login
-auth.login('username', 'password')
-  .then(data => console.log('Logged in:', data.token));
-
-// Make a GET request
-request.get('/users')
-  .then(res => res.json())
+// Make a request with automatic retry
+retry.withRetry(() => {
+  return request.get('/users')
+    .then(res => res.json());
+}, { maxRetries: 3, delay: 1000 })
   .then(data => console.log(data));
 ```
 
+## Retry Mechanism
+
+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:
+
+- `ReqForgeError` - Base error class
+- `NetworkError` - Network request failures
+- `TimeoutError` - Request timeout errors
+- `AuthError` - Authentication failures
+- `ValidationError` - Validation errors
+- `ErrorCodes` - Error code constants
+- `createErrorFromResponse(response)` - Create error from response
+
 ## Authentication
 
 The `auth` module provides:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reqforge",
-  "version": "0.6.0",
+  "version": "0.8.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/errors.js

@@ -0,0 +1,97 @@
+/**
+ * Error handling module for ReqForge
+ * @module errors
+ */
+
+/**
+ * Base error class for ReqForge
+ */
+class ReqForgeError extends Error {
+  constructor(message, code) {
+    super(message);
+    this.name = 'ReqForgeError';
+    this.code = code;
+  }
+}
+
+/**
+ * Network error
+ */
+class NetworkError extends ReqForgeError {
+  constructor(message = 'Network request failed') {
+    super(message, 'NETWORK_ERROR');
+    this.name = 'NetworkError';
+  }
+}
+
+/**
+ * Timeout error
+ */
+class TimeoutError extends ReqForgeError {
+  constructor(message = 'Request timeout') {
+    super(message, 'TIMEOUT_ERROR');
+    this.name = 'TimeoutError';
+  }
+}
+
+/**
+ * Authentication error
+ */
+class AuthError extends ReqForgeError {
+  constructor(message = 'Authentication failed') {
+    super(message, 'AUTH_ERROR');
+    this.name = 'AuthError';
+  }
+}
+
+/**
+ * Validation error
+ */
+class ValidationError extends ReqForgeError {
+  constructor(message = 'Validation failed') {
+    super(message, 'VALIDATION_ERROR');
+    this.name = 'ValidationError';
+  }
+}
+
+/**
+ * Error codes
+ */
+const ErrorCodes = {
+  NETWORK_ERROR: 'NETWORK_ERROR',
+  TIMEOUT_ERROR: 'TIMEOUT_ERROR',
+  AUTH_ERROR: 'AUTH_ERROR',
+  VALIDATION_ERROR: 'VALIDATION_ERROR',
+  UNKNOWN_ERROR: 'UNKNOWN_ERROR'
+};
+
+/**
+ * Create error from response
+ * @param {Response} response - Fetch response
+ * @returns {ReqForgeError} Appropriate error instance
+ */
+function createErrorFromResponse(response) {
+  if (response.status === 401) {
+    return new AuthError('Unauthorized');
+  }
+  if (response.status === 403) {
+    return new AuthError('Forbidden');
+  }
+  if (response.status === 404) {
+    return new NetworkError('Resource not found');
+  }
+  if (response.status >= 500) {
+    return new NetworkError('Server error');
+  }
+  return new ReqForgeError('Request failed', 'REQUEST_ERROR');
+}
+
+module.exports = {
+  ReqForgeError,
+  NetworkError,
+  TimeoutError,
+  AuthError,
+  ValidationError,
+  ErrorCodes,
+  createErrorFromResponse
+};

package/src/index.js

@@ -8,11 +8,15 @@ const utils = require('./utils');
 const request = require('./request');
 const Logger = require('./logger');
 const auth = require('./auth');
+const errors = require('./errors');
+const retry = require('./retry');
 
 module.exports = {
   config,
   utils,
   request,
   Logger,
-  auth
+  auth,
+  errors,
+  retry
 };

package/src/retry.js

@@ -0,0 +1,56 @@
+/**
+ * Retry mechanism module for ReqForge
+ * @module retry
+ */
+
+/**
+ * Execute function with retry
+ * @param {Function} fn - Function to execute
+ * @param {Object} options - Retry options
+ * @returns {Promise} Result of the function
+ */
+async function withRetry(fn, options = {}) {
+  const {
+    maxRetries = 3,
+    delay = 1000,
+    backoff = 2,
+    shouldRetry = () => true
+  } = options;
+
+  let lastError;
+  let currentDelay = delay;
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+
+      if (attempt === maxRetries || !shouldRetry(error)) {
+        throw error;
+      }
+
+      await new Promise(resolve => setTimeout(resolve, currentDelay));
+      currentDelay *= backoff;
+    }
+  }
+
+  throw lastError;
+}
+
+/**
+ * Calculate exponential backoff delay
+ * @param {number} attempt - Current attempt number
+ * @param {number} baseDelay - Base delay in ms
+ * @param {number} maxDelay - Maximum delay in ms
+ * @returns {number} Delay in ms
+ */
+function calculateBackoff(attempt, baseDelay = 1000, maxDelay = 30000) {
+  const delay = baseDelay * Math.pow(2, attempt);
+  return Math.min(delay, maxDelay);
+}
+
+module.exports = {
+  withRetry,
+  calculateBackoff
+};