recker 1.0.26 → 1.0.27

package/dist/browser/plugins/auth.d.ts

@@ -0,0 +1 @@
+export * from './auth/index.js';

package/dist/browser/plugins/auth.js

@@ -0,0 +1 @@
+export * from './auth/index.js';

package/dist/browser/plugins/cache.d.ts

@@ -0,0 +1,15 @@
+import { CacheStorage, CacheStrategy, Plugin, ReckerRequest, CacheEntry } from '../types/index.js';
+export interface CacheOptions {
+    storage?: CacheStorage;
+    strategy?: CacheStrategy;
+    ttl?: number;
+    methods?: string[];
+    keyGenerator?: (req: ReckerRequest) => string;
+    respectCacheControl?: boolean;
+    respectVary?: boolean;
+    maxStale?: number;
+    forceRevalidate?: boolean;
+}
+declare function parseCacheControl(header: string | null): Partial<CacheEntry>;
+export declare function cachePlugin(options?: CacheOptions): Plugin;
+export { parseCacheControl };

package/dist/browser/plugins/cache.js

@@ -0,0 +1,486 @@
+import { HttpResponse } from '../core/response.js';
+import { HttpRequest } from '../core/request.js';
+import { MemoryStorage } from '../cache/memory-storage.js';
+import { createHash } from 'node:crypto';
+function parseRequestCacheControl(header) {
+    if (!header)
+        return {};
+    const result = {};
+    const directives = header.toLowerCase().split(',').map(d => d.trim());
+    for (const directive of directives) {
+        if (directive.startsWith('max-age=')) {
+            result.maxAge = parseInt(directive.slice(8), 10);
+        }
+        else if (directive.startsWith('min-fresh=')) {
+            result.minFresh = parseInt(directive.slice(10), 10);
+        }
+        else if (directive.startsWith('max-stale')) {
+            const equals = directive.indexOf('=');
+            if (equals !== -1) {
+                result.maxStale = parseInt(directive.slice(equals + 1), 10);
+            }
+            else {
+                result.maxStale = Infinity;
+            }
+        }
+        else if (directive === 'only-if-cached') {
+            result.onlyIfCached = true;
+        }
+        else if (directive === 'no-cache') {
+            result.noCache = true;
+        }
+        else if (directive === 'no-store') {
+            result.noStore = true;
+        }
+    }
+    return result;
+}
+function parseCacheControl(header) {
+    if (!header)
+        return {};
+    const result = {};
+    const directives = header.toLowerCase().split(',').map(d => d.trim());
+    for (const directive of directives) {
+        if (directive.startsWith('max-age=')) {
+            result.maxAge = parseInt(directive.slice(8), 10);
+        }
+        else if (directive.startsWith('s-maxage=')) {
+            result.sMaxAge = parseInt(directive.slice(9), 10);
+        }
+        else if (directive.startsWith('stale-while-revalidate=')) {
+            result.staleWhileRevalidate = parseInt(directive.slice(23), 10);
+        }
+        else if (directive.startsWith('stale-if-error=')) {
+            result.staleIfError = parseInt(directive.slice(15), 10);
+        }
+        else if (directive === 'no-cache') {
+            result.noCache = true;
+        }
+        else if (directive === 'no-store') {
+            result.noStore = true;
+        }
+        else if (directive === 'must-revalidate') {
+            result.mustRevalidate = true;
+        }
+        else if (directive === 'private') {
+            result.isPrivate = true;
+        }
+        else if (directive === 'public') {
+            result.isPublic = true;
+        }
+    }
+    return result;
+}
+function isFresh(entry, now) {
+    const age = (now - entry.timestamp) / 1000;
+    if (entry.sMaxAge !== undefined) {
+        return age < entry.sMaxAge;
+    }
+    if (entry.maxAge !== undefined) {
+        return age < entry.maxAge;
+    }
+    if (entry.expires !== undefined) {
+        return now < entry.expires;
+    }
+    if (entry.lastModified) {
+        const lastModifiedTime = new Date(entry.lastModified).getTime();
+        if (!isNaN(lastModifiedTime)) {
+            const dateTime = entry.headers['date']
+                ? new Date(entry.headers['date']).getTime()
+                : entry.timestamp;
+            if (!isNaN(dateTime) && dateTime > lastModifiedTime) {
+                const timeSinceModified = (dateTime - lastModifiedTime) / 1000;
+                const heuristicFreshness = timeSinceModified * 0.1;
+                return age < heuristicFreshness;
+            }
+        }
+    }
+    return false;
+}
+function satisfiesRequestDirectives(entry, now, reqDirectives) {
+    const age = (now - entry.timestamp) / 1000;
+    const responseMaxAge = entry.sMaxAge ?? entry.maxAge ?? Infinity;
+    const currentFreshness = responseMaxAge - age;
+    const fresh = isFresh(entry, now);
+    if (reqDirectives.maxAge !== undefined && age > reqDirectives.maxAge) {
+        return { allowed: false, reason: 'exceeds-request-max-age' };
+    }
+    if (reqDirectives.minFresh !== undefined) {
+        if (!fresh || currentFreshness < reqDirectives.minFresh) {
+            return { allowed: false, reason: 'insufficient-freshness' };
+        }
+    }
+    if (reqDirectives.onlyIfCached) {
+        return { allowed: true };
+    }
+    if (!fresh && reqDirectives.maxStale === undefined) {
+        return { allowed: false, reason: 'stale-not-acceptable' };
+    }
+    if (!fresh && reqDirectives.maxStale !== undefined) {
+        const staleness = age - responseMaxAge;
+        if (reqDirectives.maxStale !== Infinity && staleness > reqDirectives.maxStale) {
+            return { allowed: false, reason: 'exceeds-max-stale' };
+        }
+    }
+    return { allowed: true };
+}
+function canServeStale(entry, now) {
+    if (!entry.staleWhileRevalidate)
+        return false;
+    const age = (now - entry.timestamp) / 1000;
+    const maxAge = entry.sMaxAge ?? entry.maxAge ?? 0;
+    const staleTime = age - maxAge;
+    return staleTime < entry.staleWhileRevalidate;
+}
+function createConditionalRequest(req, entry) {
+    const conditionalHeaders = new Headers(req.headers);
+    if (entry.etag) {
+        conditionalHeaders.set('If-None-Match', entry.etag);
+    }
+    if (entry.lastModified) {
+        conditionalHeaders.set('If-Modified-Since', entry.lastModified);
+    }
+    return new HttpRequest(req.url, {
+        method: req.method,
+        headers: conditionalHeaders,
+        body: req.body,
+        signal: req.signal,
+        throwHttpErrors: false,
+        timeout: req.timeout,
+        onUploadProgress: req.onUploadProgress,
+        onDownloadProgress: req.onDownloadProgress,
+        maxResponseSize: req.maxResponseSize
+    });
+}
+async function storeCacheEntry(storage, baseKey, req, entry, ttl, keyGenerator) {
+    if (entry.vary) {
+        const varyKey = keyGenerator(req, entry.vary);
+        await storage.set(varyKey, entry, ttl);
+        const varyMarker = {
+            ...entry,
+            body: '',
+        };
+        await storage.set(baseKey, varyMarker, ttl);
+    }
+    else {
+        await storage.set(baseKey, entry, ttl);
+    }
+}
+async function createCacheEntry(response, body, now) {
+    const headers = {};
+    response.headers.forEach((v, k) => { headers[k] = v; });
+    const cacheControl = parseCacheControl(response.headers.get('Cache-Control'));
+    let expires;
+    const expiresHeader = response.headers.get('Expires');
+    if (expiresHeader) {
+        const expiresDate = new Date(expiresHeader);
+        if (!isNaN(expiresDate.getTime())) {
+            expires = expiresDate.getTime();
+        }
+    }
+    return {
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+        body,
+        timestamp: now,
+        etag: response.headers.get('ETag') || undefined,
+        lastModified: response.headers.get('Last-Modified') || undefined,
+        vary: response.headers.get('Vary') || undefined,
+        expires,
+        ...cacheControl
+    };
+}
+function createCachedResponse(entry, cacheStatus) {
+    const headers = new Headers(entry.headers);
+    headers.set('X-Cache', cacheStatus);
+    headers.set('X-Cache-Age', String(Math.floor((Date.now() - entry.timestamp) / 1000)));
+    if (cacheStatus === 'stale' || cacheStatus === 'stale-error') {
+        const warningCode = cacheStatus === 'stale' ? 110 : 111;
+        const warningText = cacheStatus === 'stale' ? 'Response is Stale' : 'Revalidation Failed';
+        const existingWarning = headers.get('Warning');
+        if (existingWarning) {
+            headers.set('Warning', `${existingWarning}, ${warningCode} - "${warningText}"`);
+        }
+        else {
+            headers.set('Warning', `${warningCode} - "${warningText}"`);
+        }
+    }
+    const response = new Response(entry.body, {
+        status: entry.status,
+        statusText: entry.statusText,
+        headers
+    });
+    const httpResponse = new HttpResponse(response);
+    return httpResponse;
+}
+export function cachePlugin(options = {}) {
+    const storage = options.storage || new MemoryStorage();
+    const strategy = options.strategy || 'cache-first';
+    const ttl = options.ttl || 60 * 1000;
+    const methods = options.methods || ['GET'];
+    const respectCacheControl = options.respectCacheControl !== false;
+    const forceRevalidate = options.forceRevalidate === true;
+    const generateKey = options.keyGenerator || ((req, varyHeaders) => {
+        let key = `${req.method}:${req.url}`;
+        if (req.method !== 'GET' && req.method !== 'HEAD' && req.body) {
+            try {
+                const bodyStr = typeof req.body === 'string'
+                    ? req.body
+                    : (req.body instanceof Buffer ? req.body.toString() : JSON.stringify(req.body));
+                if (bodyStr) {
+                    const hash = createHash('sha256').update(bodyStr).digest('hex').substring(0, 16);
+                    key += `:${hash}`;
+                }
+            }
+            catch {
+            }
+        }
+        if (varyHeaders && options.respectVary !== false) {
+            const varyHeaderNames = varyHeaders.split(',').map(h => h.trim().toLowerCase());
+            const varyParts = [];
+            for (const headerName of varyHeaderNames) {
+                if (headerName === '*') {
+                    return `${key}:vary-*:${Date.now()}`;
+                }
+                const headerValue = req.headers.get(headerName);
+                if (headerValue) {
+                    varyParts.push(`${headerName}=${headerValue}`);
+                }
+            }
+            if (varyParts.length > 0) {
+                key += `:vary:${varyParts.join('|')}`;
+            }
+        }
+        return key;
+    });
+    const cacheMiddleware = async (req, next) => {
+        const unsafeMethods = [
+            'POST', 'PUT', 'PATCH', 'DELETE',
+            'PROPPATCH', 'MKCOL', 'COPY', 'MOVE', 'LOCK', 'UNLOCK',
+            'LINK', 'UNLINK', 'PURGE'
+        ];
+        if (unsafeMethods.includes(req.method)) {
+            const response = await next(req);
+            if (response.ok) {
+                await storage.delete(`GET:${req.url}`);
+                await storage.delete(`HEAD:${req.url}`);
+            }
+            return response;
+        }
+        if (!methods.includes(req.method)) {
+            return next(req);
+        }
+        const reqCacheControl = respectCacheControl
+            ? parseRequestCacheControl(req.headers.get('Cache-Control'))
+            : {};
+        if (respectCacheControl && reqCacheControl.noStore) {
+            return next(req);
+        }
+        if (respectCacheControl) {
+            const reqPragma = req.headers.get('Pragma');
+            if (reqPragma?.includes('no-cache')) {
+                return next(req);
+            }
+        }
+        const baseKey = generateKey(req);
+        let key = baseKey;
+        const now = Date.now();
+        let cachedEntry;
+        if (options.respectVary !== false) {
+            const baseEntry = await storage.get(baseKey);
+            if (baseEntry?.vary) {
+                key = generateKey(req, baseEntry.vary);
+                cachedEntry = await storage.get(key);
+            }
+            else if (baseEntry?.body) {
+                cachedEntry = baseEntry;
+            }
+            else {
+                cachedEntry = undefined;
+            }
+        }
+        else {
+            cachedEntry = await storage.get(key);
+        }
+        if (reqCacheControl.onlyIfCached) {
+            if (!cachedEntry) {
+                const response = new Response(null, {
+                    status: 504,
+                    statusText: 'Gateway Timeout'
+                });
+                return new HttpResponse(response);
+            }
+            const satisfaction = satisfiesRequestDirectives(cachedEntry, now, reqCacheControl);
+            if (!satisfaction.allowed) {
+                const response = new Response(null, {
+                    status: 504,
+                    statusText: 'Gateway Timeout'
+                });
+                return new HttpResponse(response);
+            }
+            return createCachedResponse(cachedEntry, isFresh(cachedEntry, now) ? 'hit' : 'stale');
+        }
+        const hasRequestDirectives = Object.keys(reqCacheControl).length > 0;
+        if (cachedEntry && respectCacheControl && hasRequestDirectives && strategy === 'network-first') {
+            const satisfaction = satisfiesRequestDirectives(cachedEntry, now, reqCacheControl);
+            if (!satisfaction.allowed) {
+                cachedEntry = undefined;
+            }
+        }
+        if (strategy === 'network-only') {
+            const response = await next(req);
+            if (response.ok && respectCacheControl) {
+                const cacheControl = parseCacheControl(response.headers.get('Cache-Control'));
+                if (!cacheControl.noStore) {
+                    const clonedResponse = response.raw.clone();
+                    const body = await clonedResponse.text();
+                    const entry = await createCacheEntry(response, body, now);
+                    const entryTtl = (entry.sMaxAge ?? entry.maxAge ?? ttl / 1000) * 1000;
+                    await storeCacheEntry(storage, baseKey, req, entry, entryTtl, generateKey);
+                }
+            }
+            return response;
+        }
+        if (strategy === 'rfc-compliant' || strategy === 'revalidate') {
+            if (cachedEntry) {
+                const fresh = isFresh(cachedEntry, now);
+                const satisfaction = satisfiesRequestDirectives(cachedEntry, now, reqCacheControl);
+                const hasValidators = cachedEntry.etag || cachedEntry.lastModified;
+                if (!satisfaction.allowed && !hasValidators) {
+                    cachedEntry = undefined;
+                }
+                else if (fresh && !forceRevalidate && !cachedEntry.noCache && !reqCacheControl.noCache) {
+                    return createCachedResponse(cachedEntry, 'hit');
+                }
+                else if (!fresh && reqCacheControl.maxStale !== undefined && !forceRevalidate && !reqCacheControl.noCache) {
+                    return createCachedResponse(cachedEntry, 'stale');
+                }
+            }
+            if (cachedEntry) {
+                const conditionalReq = createConditionalRequest(req, cachedEntry);
+                try {
+                    const response = await next(conditionalReq);
+                    if (response.status === 304) {
+                        const updatedEntry = {
+                            ...cachedEntry,
+                            timestamp: now,
+                            etag: response.headers.get('ETag') || cachedEntry.etag,
+                            lastModified: response.headers.get('Last-Modified') || cachedEntry.lastModified,
+                        };
+                        const freshnessTtl = (updatedEntry.sMaxAge ?? updatedEntry.maxAge ?? ttl / 1000) * 1000;
+                        const storageTtl = Math.max(freshnessTtl, ttl);
+                        await storage.set(key, updatedEntry, storageTtl);
+                        return createCachedResponse(updatedEntry, 'revalidated');
+                    }
+                    if (response.ok) {
+                        const cacheControl = parseCacheControl(response.headers.get('Cache-Control'));
+                        if (!cacheControl.noStore) {
+                            const clonedResponse = response.raw.clone();
+                            const body = await clonedResponse.text();
+                            const entry = await createCacheEntry(response, body, now);
+                            const freshnessTtl = (entry.sMaxAge ?? entry.maxAge ?? ttl / 1000) * 1000;
+                            const storageTtl = Math.max(freshnessTtl, ttl);
+                            await storeCacheEntry(storage, baseKey, req, entry, storageTtl, generateKey);
+                        }
+                    }
+                    return response;
+                }
+                catch (error) {
+                    if (cachedEntry.staleIfError && canServeStale(cachedEntry, now)) {
+                        return createCachedResponse(cachedEntry, 'stale-error');
+                    }
+                    throw error;
+                }
+            }
+            const response = await next(req);
+            if (response.ok) {
+                const cacheControl = parseCacheControl(response.headers.get('Cache-Control'));
+                if (!cacheControl.noStore) {
+                    const clonedResponse = response.raw.clone();
+                    const body = await clonedResponse.text();
+                    const entry = await createCacheEntry(response, body, now);
+                    const freshnessTtl = (entry.sMaxAge ?? entry.maxAge ?? ttl / 1000) * 1000;
+                    const storageTtl = Math.max(freshnessTtl, ttl);
+                    await storeCacheEntry(storage, baseKey, req, entry, storageTtl, generateKey);
+                }
+            }
+            return response;
+        }
+        if (strategy === 'cache-first') {
+            if (cachedEntry) {
+                return createCachedResponse(cachedEntry, 'hit');
+            }
+            const response = await next(req);
+            if (response.ok) {
+                const clonedResponse = response.raw.clone();
+                const body = await clonedResponse.text();
+                const entry = await createCacheEntry(response, body, now);
+                await storeCacheEntry(storage, baseKey, req, entry, ttl, generateKey);
+            }
+            return response;
+        }
+        if (strategy === 'stale-while-revalidate') {
+            if (cachedEntry) {
+                const cachedResponse = createCachedResponse(cachedEntry, 'stale');
+                (async () => {
+                    try {
+                        const conditionalReq = createConditionalRequest(req, cachedEntry);
+                        const freshResponse = await next(conditionalReq);
+                        if (freshResponse.status === 304) {
+                            const updatedEntry = {
+                                ...cachedEntry,
+                                timestamp: Date.now()
+                            };
+                            await storage.set(key, updatedEntry, ttl);
+                        }
+                        else if (freshResponse.ok) {
+                            const clonedResponse = freshResponse.raw.clone();
+                            const body = await clonedResponse.text();
+                            const entry = await createCacheEntry(freshResponse, body, Date.now());
+                            const freshnessTtl = (entry.sMaxAge ?? entry.maxAge ?? ttl / 1000) * 1000;
+                            const storageTtl = Math.max(freshnessTtl, ttl);
+                            await storeCacheEntry(storage, baseKey, req, entry, storageTtl, generateKey);
+                        }
+                    }
+                    catch {
+                    }
+                })();
+                return cachedResponse;
+            }
+            const response = await next(req);
+            if (response.ok) {
+                const clonedResponse = response.raw.clone();
+                const body = await clonedResponse.text();
+                const entry = await createCacheEntry(response, body, now);
+                await storeCacheEntry(storage, baseKey, req, entry, ttl, generateKey);
+            }
+            return response;
+        }
+        if (strategy === 'network-first') {
+            try {
+                const response = await next(req);
+                if (response.ok) {
+                    const clonedResponse = response.raw.clone();
+                    const body = await clonedResponse.text();
+                    const entry = await createCacheEntry(response, body, now);
+                    const freshnessTtl = (entry.sMaxAge ?? entry.maxAge ?? ttl / 1000) * 1000;
+                    const storageTtl = Math.max(freshnessTtl, ttl);
+                    await storeCacheEntry(storage, baseKey, req, entry, storageTtl, generateKey);
+                }
+                return response;
+            }
+            catch (error) {
+                if (cachedEntry) {
+                    return createCachedResponse(cachedEntry, 'stale-error');
+                }
+                throw error;
+            }
+        }
+        return next(req);
+    };
+    return (client) => {
+        client.use(cacheMiddleware);
+    };
+}
+export { parseCacheControl };

package/dist/browser/plugins/circuit-breaker.d.ts

@@ -0,0 +1,13 @@
+import { Plugin, ReckerResponse } from '../types/index.js';
+export interface CircuitBreakerOptions {
+    threshold?: number;
+    resetTimeout?: number;
+    shouldTrip?: (error: any, response?: ReckerResponse) => boolean;
+    onStateChange?: (state: CircuitState, service: string) => void;
+}
+export type CircuitState = 'CLOSED' | 'OPEN' | 'HALF_OPEN';
+export declare class CircuitBreakerError extends Error {
+    service: string;
+    constructor(service: string);
+}
+export declare function circuitBreakerPlugin(options?: CircuitBreakerOptions): Plugin;

package/dist/browser/plugins/circuit-breaker.js

@@ -0,0 +1,100 @@
+export class CircuitBreakerError extends Error {
+    service;
+    constructor(service) {
+        super(`Circuit breaker is OPEN for ${service}`);
+        this.service = service;
+        this.name = 'CircuitBreakerError';
+    }
+}
+export function circuitBreakerPlugin(options = {}) {
+    const threshold = options.threshold || 5;
+    const resetTimeout = options.resetTimeout || 30 * 1000;
+    const circuits = new Map();
+    const getCircuitKey = (req) => {
+        try {
+            return new URL(req.url).hostname;
+        }
+        catch {
+            return 'unknown';
+        }
+    };
+    const shouldTrip = options.shouldTrip || ((err, res) => {
+        if (res)
+            return res.status >= 500;
+        return true;
+    });
+    return (client) => {
+        client.beforeRequest((req) => {
+            const key = getCircuitKey(req);
+            let stats = circuits.get(key);
+            if (!stats) {
+                stats = { failures: 0, lastFailureTime: 0, state: 'CLOSED' };
+                circuits.set(key, stats);
+            }
+            if (stats.state === 'OPEN') {
+                const now = Date.now();
+                if (now - stats.lastFailureTime > resetTimeout) {
+                    stats.state = 'HALF_OPEN';
+                    if (options.onStateChange)
+                        options.onStateChange('HALF_OPEN', key);
+                }
+                else {
+                    throw new CircuitBreakerError(key);
+                }
+            }
+        });
+        client.afterResponse((req, res) => {
+            const key = getCircuitKey(req);
+            const stats = circuits.get(key);
+            if (!stats)
+                return;
+            const isFailure = shouldTrip(null, res);
+            if (isFailure) {
+                handleFailure(stats, key);
+            }
+            else {
+                handleSuccess(stats, key);
+            }
+        });
+        client.onError((err, req) => {
+            if (err instanceof CircuitBreakerError) {
+                throw err;
+            }
+            const key = getCircuitKey(req);
+            const stats = circuits.get(key);
+            if (!stats)
+                return;
+            const isFailure = shouldTrip(err, undefined);
+            if (isFailure) {
+                handleFailure(stats, key);
+            }
+        });
+        function handleSuccess(stats, key) {
+            if (stats.state === 'HALF_OPEN') {
+                stats.state = 'CLOSED';
+                stats.failures = 0;
+                if (options.onStateChange)
+                    options.onStateChange('CLOSED', key);
+            }
+            else if (stats.state === 'CLOSED') {
+                stats.failures = 0;
+            }
+        }
+        function handleFailure(stats, key) {
+            stats.failures++;
+            stats.lastFailureTime = Date.now();
+            if (stats.state === 'HALF_OPEN') {
+                stats.state = 'OPEN';
+                if (options.onStateChange)
+                    options.onStateChange('OPEN', key);
+            }
+            else if (stats.state === 'CLOSED') {
+                if (stats.failures >= threshold) {
+                    stats.state = 'OPEN';
+                    if (options.onStateChange)
+                        options.onStateChange('OPEN', key);
+                }
+            }
+        }
+    };
+}

package/dist/browser/plugins/compression.d.ts

@@ -0,0 +1,4 @@
+import { Middleware, CompressionOptions } from '../types/index.js';
+export type CompressionAlgorithm = 'gzip' | 'deflate' | 'br';
+export declare function compression(options?: CompressionOptions): Middleware;
+export declare function createCompressionMiddleware(config: boolean | CompressionOptions): Middleware | null;