create-request 0.0.1-beta.6 → 0.0.1-beta.8

package/dist/library/index.esm.js

@@ -78,6 +78,20 @@ var BodyType;
     BodyType["STRING"] = "string";
     BodyType["BINARY"] = "binary";
 })(BodyType || (BodyType = {}));
+/**
+ * Referrer policies for fetch requests
+ */
+var ReferrerPolicy;
+(function (ReferrerPolicy) {
+    ReferrerPolicy["ORIGIN"] = "origin";
+    ReferrerPolicy["UNSAFE_URL"] = "unsafe-url";
+    ReferrerPolicy["SAME_ORIGIN"] = "same-origin";
+    ReferrerPolicy["NO_REFERRER"] = "no-referrer";
+    ReferrerPolicy["STRICT_ORIGIN"] = "strict-origin";
+    ReferrerPolicy["ORIGIN_WHEN_CROSS_ORIGIN"] = "origin-when-cross-origin";
+    ReferrerPolicy["NO_REFERRER_WHEN_DOWNGRADE"] = "no-referrer-when-downgrade";
+    ReferrerPolicy["STRICT_ORIGIN_WHEN_CROSS_ORIGIN"] = "strict-origin-when-cross-origin";
+})(ReferrerPolicy || (ReferrerPolicy = {}));
 
 class RequestError extends Error {
     constructor(message, url, method, options = {}) {
@@ -233,6 +247,331 @@ class ResponseWrapper {
     }
 }
 
+/**
+ * Parse size strings like "10MB" into bytes
+ * @param size Size as number or string with units
+ */
+function parseSize(size) {
+    var _a;
+    if (typeof size === "number")
+        return size;
+    const match = size.match(/^(\d+(?:\.\d+)?)\s*(KB|MB|GB)?$/i);
+    if (!match)
+        return 0;
+    const num = parseFloat(match[1]);
+    const unit = (_a = match[2]) === null || _a === void 0 ? void 0 : _a.toUpperCase();
+    switch (unit) {
+        case "KB":
+            return num * 1024;
+        case "MB":
+            return num * 1024 * 1024;
+        case "GB":
+            return num * 1024 * 1024 * 1024;
+        default:
+            return num;
+    }
+}
+/**
+ * Create a memory storage provider using Map
+ */
+function createMemoryStorage() {
+    const store = new Map();
+    return {
+        get(key) {
+            return store.get(key) || null;
+        },
+        set(key, value) {
+            store.set(key, value);
+        },
+        has(key) {
+            return store.has(key);
+        },
+        delete(key) {
+            store.delete(key);
+        },
+        clear() {
+            store.clear();
+        },
+    };
+}
+/**
+ * Create a localStorage-based storage provider
+ */
+function createLocalStorageStorage() {
+    return {
+        get(key) {
+            if (typeof localStorage === "undefined")
+                return null;
+            return localStorage.getItem(key);
+        },
+        set(key, value) {
+            if (typeof localStorage === "undefined")
+                return;
+            try {
+                localStorage.setItem(key, value);
+            }
+            catch (e) {
+                // Handle quota exceeded errors
+                console.warn("Cache storage quota exceeded, clearing cache");
+                void this.clear();
+                try {
+                    localStorage.setItem(key, value);
+                }
+                catch (e) {
+                    console.error("Failed to set cache item even after clearing cache");
+                }
+            }
+        },
+        has(key) {
+            if (typeof localStorage === "undefined")
+                return false;
+            return localStorage.getItem(key) !== null;
+        },
+        delete(key) {
+            if (typeof localStorage === "undefined")
+                return;
+            localStorage.removeItem(key);
+        },
+        clear() {
+            if (typeof localStorage === "undefined")
+                return;
+            localStorage.clear();
+        },
+    };
+}
+/**
+ * Create a sessionStorage-based storage provider
+ */
+function createSessionStorageStorage() {
+    return {
+        get(key) {
+            if (typeof sessionStorage === "undefined")
+                return null;
+            return sessionStorage.getItem(key);
+        },
+        set(key, value) {
+            if (typeof sessionStorage === "undefined")
+                return;
+            try {
+                sessionStorage.setItem(key, value);
+            }
+            catch (e) {
+                // Handle quota exceeded errors
+                console.warn("Cache storage quota exceeded, clearing cache");
+                void this.clear();
+                try {
+                    sessionStorage.setItem(key, value);
+                }
+                catch (e) {
+                    console.error("Failed to set cache item even after clearing cache");
+                }
+            }
+        },
+        has(key) {
+            if (typeof sessionStorage === "undefined")
+                return false;
+            return sessionStorage.getItem(key) !== null;
+        },
+        delete(key) {
+            if (typeof sessionStorage === "undefined")
+                return;
+            sessionStorage.removeItem(key);
+        },
+        clear() {
+            if (typeof sessionStorage === "undefined")
+                return;
+            sessionStorage.clear();
+        },
+    };
+}
+/**
+ * Create a storage provider from a cache options object
+ */
+function createStorageProvider(options) {
+    const { storage } = options || {};
+    if (!storage) {
+        // Default to memory storage
+        return createMemoryStorage();
+    }
+    // Check if storage is already a StorageProvider
+    if (typeof storage.get === "function" && typeof storage.set === "function") {
+        return storage;
+    }
+    // Check if it's localStorage or sessionStorage
+    if (storage === localStorage) {
+        return createLocalStorageStorage();
+    }
+    if (storage === sessionStorage) {
+        return createSessionStorageStorage();
+    }
+    // Check if it's a Map
+    if (storage instanceof Map) {
+        return {
+            get(key) {
+                return storage.get(key) || null;
+            },
+            set(key, value, _ttl) {
+                storage.set(key, value);
+            },
+            has(key) {
+                return storage.has(key);
+            },
+            delete(key) {
+                storage.delete(key);
+            },
+            clear() {
+                storage.clear();
+            },
+        };
+    }
+    // Default to memory storage
+    console.warn("Unsupported storage type, falling back to memory storage");
+    return createMemoryStorage();
+}
+
+/**
+ * Cache manager that handles storage operations
+ */
+class CacheManager {
+    constructor(options = {}) {
+        this.entryCount = 0;
+        this.totalSize = 0;
+        this.options = options;
+        this.storage = createStorageProvider(options);
+    }
+    /**
+     * Generate a cache key based on request details
+     */
+    generateKey(url, method, headers, body) {
+        // Use custom key generator if provided
+        if (this.options.keyGenerator) {
+            const customKey = this.options.keyGenerator(url, method, headers, body);
+            return this.options.keyPrefix ? `${this.options.keyPrefix}:${customKey}` : customKey;
+        }
+        // Default key generation
+        let key = `${method}:${url}`;
+        // Add vary headers to key if specified
+        if (this.options.varyByHeaders && headers) {
+            const varyHeaders = {};
+            this.options.varyByHeaders.forEach(header => {
+                const normalizedHeader = header.toLowerCase();
+                // Find the header in case-insensitive way
+                Object.keys(headers).forEach(h => {
+                    if (h.toLowerCase() === normalizedHeader) {
+                        varyHeaders[normalizedHeader] = headers[h];
+                    }
+                });
+            });
+            if (Object.keys(varyHeaders).length > 0) {
+                key += `:${JSON.stringify(varyHeaders)}`;
+            }
+        }
+        // Include body in cache key for non-GET requests if it's a simple value
+        if (method !== "GET" && body !== undefined && body !== null) {
+            try {
+                if (typeof body === "string" || typeof body === "number" || typeof body === "boolean") {
+                    key += `:${String(body)}`;
+                }
+                else if (typeof body === "object") {
+                    key += `:${JSON.stringify(body)}`;
+                }
+            }
+            catch (e) {
+                console.warn("Failed to stringify request body for cache key");
+            }
+        }
+        // Add prefix if specified
+        return this.options.keyPrefix ? `${this.options.keyPrefix}:${key}` : key;
+    }
+    /**
+     * Get a value from cache
+     */
+    async get(key) {
+        const value = await Promise.resolve(this.storage.get(key));
+        if (!value)
+            return null;
+        try {
+            const entry = JSON.parse(value);
+            // Check if the entry has expired
+            if (entry.expiry && entry.expiry < Date.now()) {
+                await Promise.resolve(this.storage.delete(key));
+                return null;
+            }
+            return entry;
+        }
+        catch (e) {
+            // If we can't parse the cached value, remove it
+            await Promise.resolve(this.storage.delete(key));
+            return null;
+        }
+    }
+    /**
+     * Set a value in cache
+     */
+    async set(key, value, headers) {
+        const now = Date.now();
+        const ttl = this.options.ttl;
+        const entry = {
+            value,
+            timestamp: now,
+            expiry: ttl ? now + ttl : null,
+            headers,
+        };
+        const serialized = JSON.stringify(entry);
+        // Check size constraints if applicable
+        if (this.options.maxSize) {
+            const maxBytes = parseSize(this.options.maxSize);
+            const entrySize = new TextEncoder().encode(serialized).length;
+            // If a single entry exceeds the max size, reject it without clearing the cache
+            if (entrySize > maxBytes) {
+                console.warn(`Cache entry size (${entrySize} bytes) exceeds maximum cache size (${maxBytes} bytes)`);
+                return;
+            }
+            // Only clear if adding this entry would exceed the total limit
+            if (this.totalSize + entrySize > maxBytes) {
+                // Simple strategy: clear everything
+                // A more sophisticated strategy would remove oldest entries first
+                await Promise.resolve(this.storage.clear());
+                this.totalSize = 0;
+                this.entryCount = 0;
+            }
+            this.totalSize += entrySize;
+        }
+        // Check max entries constraint
+        if (this.options.maxEntries) {
+            this.entryCount++;
+            if (this.entryCount > this.options.maxEntries) {
+                // Simple strategy: clear everything
+                // A more sophisticated strategy would use LRU cache
+                await Promise.resolve(this.storage.clear());
+                this.entryCount = 1;
+            }
+        }
+        // Pass ttl to storage provider if available
+        await Promise.resolve(this.storage.set(key, serialized, ttl));
+    }
+    /**
+     * Check if a key exists in the cache
+     */
+    async has(key) {
+        return Promise.resolve(this.storage.has(key));
+    }
+    /**
+     * Delete a key from the cache
+     */
+    async delete(key) {
+        return Promise.resolve(this.storage.delete(key));
+    }
+    /**
+     * Clear the entire cache
+     */
+    async clear() {
+        this.entryCount = 0;
+        this.totalSize = 0;
+        return Promise.resolve(this.storage.clear());
+    }
+}
+
 /**
  * Global configuration for create-request
  */
@@ -446,6 +785,7 @@ class BaseRequest {
         };
         this.queryParams = new URLSearchParams();
         this.autoApplyCsrfProtection = true;
+        this.cacheEnabled = false;
     }
     withHeaders(headers) {
         this.requestOptions.headers = {
@@ -497,6 +837,15 @@ class BaseRequest {
         this.requestOptions.referrer = referrer;
         return this;
     }
+    /**
+     * Sets the referrer policy for the request
+     * @param policy - The referrer policy to use
+     * @returns The instance for chaining
+     */
+    withReferrerPolicy(policy) {
+        this.requestOptions.referrerPolicy = policy;
+        return this;
+    }
     /**
      * Sets the redirect policy for the request
      * @param redirect - Can be 'follow', 'error', or 'manual'
@@ -603,6 +952,12 @@ class BaseRequest {
      * Works in both browser and Node.js environments
      */
     encodeBase64(str) {
+        // Modern approach using TextEncoder (available in both modern browsers and Node.js)
+        if (typeof TextEncoder !== "undefined" && typeof btoa === "function") {
+            const encoder = new TextEncoder();
+            const bytes = encoder.encode(str);
+            return btoa(String.fromCharCode.apply(null, [...new Uint8Array(bytes)]));
+        }
         // Browser environment
         if (typeof btoa === "function")
             return btoa(str);
@@ -708,6 +1063,16 @@ class BaseRequest {
             "X-Requested-With": "XMLHttpRequest",
         });
     }
+    /**
+     * Enables caching for the request with the specified options
+     * @param options The cache configuration options
+     * @returns The instance for chaining
+     */
+    withCache(options = {}) {
+        this.cacheEnabled = true;
+        this.cacheManager = new CacheManager(options);
+        return this;
+    }
     /**
      * Send the request to the specified URL
      * @param url The URL to send the request to
@@ -757,8 +1122,15 @@ class BaseRequest {
             ...this.requestOptions,
             method: this.method,
         };
-        // Create the base promise
-        const basePromise = !this.requestOptions.retries ? this.executeRequest(url, fetchOptions) : this.executeWithRetries(url, fetchOptions);
+        // Create the base promise - handle caching if enabled
+        let basePromise;
+        if (this.cacheEnabled && this.cacheManager) {
+            const cacheKey = this.cacheManager.generateKey(url, this.method, this.requestOptions.headers, this.requestOptions.body);
+            basePromise = this.executeWithCache(url, fetchOptions, cacheKey);
+        }
+        else {
+            basePromise = !this.requestOptions.retries ? this.executeRequest(url, fetchOptions) : this.executeWithRetries(url, fetchOptions);
+        }
         const responsePromise = basePromise;
         // Attach convenience methods that begin processing immediately
         responsePromise.getJson = async () => {
@@ -776,6 +1148,25 @@ class BaseRequest {
         responsePromise.getBody = async () => {
             return basePromise.then(response => response.getBody());
         };
+        responsePromise.getData = async (selector) => {
+            try {
+                const data = await basePromise.then(response => response.getJson());
+                // If no selector is provided, return the raw JSON data
+                if (!selector)
+                    return data;
+                // Apply the selector if provided
+                return selector(data);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    // If selector fails, enhance the error with the original data
+                    const enhancedError = new Error(`Data selector failed: ${error.message}. Original data: ${JSON.stringify(await basePromise.then(response => response.getJson()), null, 2)}`);
+                    enhancedError.stack = error.stack;
+                    throw enhancedError;
+                }
+                throw error;
+            }
+        };
         return responsePromise;
     }
     /**
@@ -897,6 +1288,48 @@ class BaseRequest {
             }
         }
     }
+    /**
+     * Executes a request using cache when possible
+     * @param url The formatted URL to send the request to
+     * @param fetchOptions The fetch options to use
+     * @param cacheKey The cache key for this request
+     */
+    async executeWithCache(url, fetchOptions, cacheKey) {
+        // Try to get from cache first
+        if (this.cacheManager) {
+            const cachedEntry = await this.cacheManager.get(cacheKey);
+            if (cachedEntry) {
+                // Create a synthetic Response object from cached data
+                const cachedResponse = new Response(JSON.stringify(cachedEntry.value), {
+                    status: 200,
+                    headers: new Headers(cachedEntry.headers || {}),
+                });
+                return new ResponseWrapper(cachedResponse);
+            }
+        }
+        // Not in cache, make the actual request
+        const response = await (!this.requestOptions.retries ? this.executeRequest(url, fetchOptions) : this.executeWithRetries(url, fetchOptions));
+        // Cache the successful response if caching is enabled
+        // Only cache successful responses
+        if (response.ok && this.cacheManager) {
+            // Clone the response so we don't consume it
+            try {
+                const responseData = await response.getJson();
+                // Extract headers to store in cache
+                const headers = {};
+                response.headers.forEach((value, key) => {
+                    headers[key] = value;
+                });
+                // Store in cache
+                await this.cacheManager.set(cacheKey, responseData, headers);
+            }
+            catch (error) {
+                // Failed to cache, but we can still return the response
+                console.warn("Failed to cache response:", error);
+            }
+        }
+        return response;
+    }
 }
 
 /**
@@ -1062,4 +1495,4 @@ const create = {
     config: Config.getInstance(),
 };
 
-export { CacheMode, CookieUtils, CredentialsPolicy, DeleteRequest, GetRequest, HeadRequest, HttpMethod, OptionsRequest, PatchRequest, PostRequest, PutRequest, RedirectMode, RequestError, RequestMode, RequestPriority, ResponseWrapper, SameSitePolicy, create as default };
+export { CacheManager, CacheMode, CookieUtils, CredentialsPolicy, DeleteRequest, GetRequest, HeadRequest, HttpMethod, OptionsRequest, PatchRequest, PostRequest, PutRequest, RedirectMode, RequestError, RequestMode, RequestPriority, ResponseWrapper, SameSitePolicy, createLocalStorageStorage, createMemoryStorage, createSessionStorageStorage, create as default };