reqforge 0.9.0 → 0.11.0

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "reqforge",
-  "version": "0.9.0",
+  "version": "0.11.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",
+  "types": "types/index.d.ts",
   "scripts": {
     "test": "echo \"No tests yet\" && exit 0"
   },

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

@@ -11,6 +11,7 @@ const auth = require('./auth');
 const errors = require('./errors');
 const retry = require('./retry');
 const interceptor = require('./interceptor');
+const cache = require('./cache');
 
 module.exports = {
   config,
@@ -20,5 +21,6 @@ module.exports = {
   auth,
   errors,
   retry,
-  interceptor
+  interceptor,
+  cache
 };

package/types/index.d.ts

@@ -0,0 +1,118 @@
+declare module 'reqforge' {
+  // Config
+  export const config: {
+    getBaseURL(): string;
+    API_VERSION: string;
+    defaultConfig: RequestConfig;
+    mergeConfig(customConfig?: Partial<RequestConfig>): RequestConfig;
+  };
+
+  // Request
+  export const request: {
+    sendRequest(endpoint: string, data?: any, options?: RequestOptions): Promise<Response>;
+    get(endpoint: string, options?: RequestOptions): Promise<Response>;
+    post(endpoint: string, data?: any, options?: RequestOptions): Promise<Response>;
+    put(endpoint: string, data?: any, options?: RequestOptions): Promise<Response>;
+    del(endpoint: string, options?: RequestOptions): Promise<Response>;
+  };
+
+  // Logger
+  export class Logger {
+    constructor(prefix?: string);
+    log(message: string): void;
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+  }
+
+  // Auth
+  export const auth: {
+    login(username: string, password: string): Promise<any>;
+    logout(): Promise<void>;
+    getToken(): string | null;
+    setToken(token: string): void;
+    isAuthenticated(): boolean;
+  };
+
+  // Errors
+  export const errors: {
+    ReqForgeError: typeof ReqForgeError;
+    NetworkError: typeof NetworkError;
+    TimeoutError: typeof TimeoutError;
+    AuthError: typeof AuthError;
+    ValidationError: typeof ValidationError;
+    ErrorCodes: ErrorCodes;
+    createErrorFromResponse(response: Response): ReqForgeError;
+  };
+
+  // Retry
+  export const retry: {
+    withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+    calculateBackoff(attempt: number, baseDelay?: number, maxDelay?: number): number;
+  };
+
+  // Interceptor
+  export const interceptor: {
+    createRequestInterceptor(): InterceptorManager;
+    createResponseInterceptor(): InterceptorManager;
+  };
+
+  // Cache
+  export const cache: {
+    MemoryCache: typeof MemoryCache;
+    createCacheKey(url: string, params?: Record<string, any>): string;
+  };
+
+  // Types
+  interface RequestConfig {
+    baseURL: string;
+    timeout: number;
+    headers: Record<string, string>;
+  }
+
+  interface RequestOptions {
+    method?: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+  }
+
+  interface RetryOptions {
+    maxRetries?: number;
+    delay?: number;
+    backoff?: number;
+    shouldRetry?: (error: Error) => boolean;
+  }
+
+  class ReqForgeError extends Error {
+    code: string;
+  }
+
+  class NetworkError extends ReqForgeError {}
+  class TimeoutError extends ReqForgeError {}
+  class AuthError extends ReqForgeError {}
+  class ValidationError extends ReqForgeError {}
+
+  interface ErrorCodes {
+    NETWORK_ERROR: string;
+    TIMEOUT_ERROR: string;
+    AUTH_ERROR: string;
+    VALIDATION_ERROR: string;
+    UNKNOWN_ERROR: string;
+  }
+
+  class InterceptorManager {
+    use(fulfilled: (data: any) => any, rejected?: (error: Error) => any): number;
+    eject(id: number): void;
+    clear(): void;
+  }
+
+  class MemoryCache {
+    constructor(options?: { defaultTTL?: number });
+    get(key: string): any | null;
+    set(key: string, value: any, ttl?: number): void;
+    has(key: string): boolean;
+    delete(key: string): void;
+    clear(): void;
+    size(): number;
+  }
+}