recker 1.0.2-0 → 1.0.4

package/dist/plugins/cache.js

@@ -1,72 +1,493 @@
 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 cache(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 generateKey = options.keyGenerator || ((req) => {
-        return `${req.method}:${req.url}`;
+    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 key = generateKey(req);
-        if (strategy === 'network-only') {
+        const reqCacheControl = respectCacheControl
+            ? parseRequestCacheControl(req.headers.get('Cache-Control'))
+            : {};
+        if (respectCacheControl && reqCacheControl.noStore) {
             return next(req);
         }
-        const cachedEntry = await storage.get(key);
-        if (cachedEntry) {
-            if (strategy === 'cache-first' || strategy === 'stale-while-revalidate') {
-                const cachedResponse = new Response(cachedEntry.body, {
-                    status: cachedEntry.status,
-                    statusText: cachedEntry.statusText,
-                    headers: cachedEntry.headers,
+        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 && 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'
                 });
-                const reckerResponse = new HttpResponse(cachedResponse);
-                if (strategy === 'stale-while-revalidate') {
-                    (async () => {
-                        try {
-                            const freshResponse = await next(req);
-                            if (freshResponse.ok) {
-                                const text = await freshResponse.text();
-                                const headers = {};
-                                freshResponse.headers.forEach((v, k) => headers[k] = v);
-                                await storage.set(key, {
-                                    status: freshResponse.status,
-                                    statusText: freshResponse.statusText,
-                                    headers: headers,
-                                    body: text,
-                                    timestamp: Date.now(),
-                                }, ttl);
-                            }
+                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) {
+                console.log('[DEBUG EXTREME] Revalidating. Entry:', !!cachedEntry);
+                const conditionalReq = createConditionalRequest(req, cachedEntry);
+                try {
+                    console.log('[DEBUG EXTREME] Calling next(conditionalReq)');
+                    const response = await next(conditionalReq);
+                    console.log('[DEBUG EXTREME] Returned from next. Status:', response.status);
+                    if (response.status === 304) {
+                        console.log('[DEBUG EXTREME] Status is 304. Updating cache.');
+                        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');
+                    }
+                    else {
+                        console.log('[DEBUG EXTREME] Status is NOT 304. Status:', response.status);
+                    }
+                    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);
                         }
-                        catch (err) {
-                            console.error('Background cache revalidation failed', err);
+                    }
+                    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');
                 }
-                return reckerResponse;
-            }
-        }
-        const response = await next(req);
-        if (response.ok) {
-            const clonedResponse = response.raw.clone();
-            const text = await clonedResponse.text();
-            const headers = {};
-            response.headers.forEach((v, k) => headers[k] = v);
-            await storage.set(key, {
-                status: response.status,
-                statusText: response.statusText,
-                headers: headers,
-                body: text,
-                timestamp: Date.now(),
-            }, ttl);
-        }
-        return response;
+                throw error;
+            }
+        }
+        return next(req);
     };
     return (client) => {
         client.use(cacheMiddleware);
     };
 }
+export { parseCacheControl };

package/dist/plugins/circuit-breaker.js

@@ -8,7 +8,7 @@ export class CircuitBreakerError extends Error {
 }
 export function circuitBreaker(options = {}) {
     const threshold = options.threshold || 5;
-    const resetTimeout = options.resetTimeout || 30000;
+    const resetTimeout = options.resetTimeout || 30 * 1000;
     const circuits = new Map();
     const getCircuitKey = (req) => {
         try {

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

@@ -1 +1 @@
-{"version":3,"file":"compression.d.ts","sourceRoot":"","sources":["../../src/plugins/compression.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAMnE,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;AAiI7D,wBAAgB,WAAW,CAAC,OAAO,GAAE,kBAAuB,GAAG,UAAU,CAoExE;AAKD,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,OAAO,GAAG,kBAAkB,GACnC,UAAU,GAAG,IAAI,CAUnB"}
+{"version":3,"file":"compression.d.ts","sourceRoot":"","sources":["../../src/plugins/compression.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAOnE,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;AAsI7D,wBAAgB,WAAW,CAAC,OAAO,GAAE,kBAAuB,GAAG,UAAU,CAmExE;AAKD,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,OAAO,GAAG,kBAAkB,GACnC,UAAU,GAAG,IAAI,CAUnB"}

package/dist/plugins/compression.js

@@ -1,5 +1,6 @@
 import { gzip, deflate, brotliCompress } from 'node:zlib';
 import { promisify } from 'node:util';
+import { ReckerError } from '../core/errors.js';
 const gzipAsync = promisify(gzip);
 const deflateAsync = promisify(deflate);
 const brotliAsync = promisify(brotliCompress);
@@ -71,7 +72,7 @@ async function compress(data, algorithm) {
         case 'br':
             return await brotliAsync(data);
         default:
-            throw new Error(`Unsupported compression algorithm: ${algorithm}`);
+            throw new ReckerError(`Unsupported compression algorithm: ${algorithm}`, undefined, undefined, ['Use one of: gzip, br, deflate.', 'Remove compression setting or switch to a supported algorithm.']);
     }
 }
 export function compression(options = {}) {
@@ -111,8 +112,7 @@ export function compression(options = {}) {
             };
             return next(compressedReq);
         }
-        catch (error) {
-            console.error('Compression failed:', error);
+        catch {
             return next(req);
         }
     };

package/dist/plugins/dedup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dedup.d.ts","sourceRoot":"","sources":["../../src/plugins/dedup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,MAAM,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEtE,MAAM,WAAW,YAAY;IAC3B,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,aAAa,KAAK,MAAM,CAAC;CAC/C;AAED,wBAAgB,KAAK,CAAC,OAAO,GAAE,YAAiB,GAAG,MAAM,CAiExD"}
+{"version":3,"file":"dedup.d.ts","sourceRoot":"","sources":["../../src/plugins/dedup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,MAAM,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEtE,MAAM,WAAW,YAAY;IAC3B,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,aAAa,KAAK,MAAM,CAAC;CAC/C;AAKD,wBAAgB,KAAK,CAAC,OAAO,GAAE,YAAiB,GAAG,MAAM,CAmExD"}

package/dist/plugins/dedup.js

@@ -1,7 +1,8 @@
+const keyBuffer = { method: '', url: '' };
 export function dedup(options = {}) {
     const pendingRequests = new Map();
     const generateKey = options.keyGenerator || ((req) => {
-        return `${req.method}:${req.url}`;
+        return req.method + ':' + req.url;
     });
     const dedupMiddleware = async (req, next) => {
         if (req.method !== 'GET' && req.method !== 'HEAD') {

package/dist/plugins/graphql.d.ts

@@ -1,9 +1,10 @@
-import { Plugin, ReckerResponse } from '../types/index.js';
+import { Plugin, ReckerRequest, ReckerResponse } from '../types/index.js';
 import { Client } from '../core/client.js';
-export declare class GraphQLError extends Error {
+import { ReckerError } from '../core/errors.js';
+export declare class GraphQLError extends ReckerError {
     errors: any[];
     response: ReckerResponse;
-    constructor(errors: any[], response: ReckerResponse);
+    constructor(errors: any[], response: ReckerResponse, request?: ReckerRequest);
 }
 export interface GraphQLOptions {
     throwOnErrors?: boolean;

package/dist/plugins/graphql.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graphql.d.ts","sourceRoot":"","sources":["../../src/plugins/graphql.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAA6B,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACtF,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE3C,qBAAa,YAAa,SAAQ,KAAK;IAClB,MAAM,EAAE,GAAG,EAAE;IAAS,QAAQ,EAAE,cAAc;gBAA9C,MAAM,EAAE,GAAG,EAAE,EAAS,QAAQ,EAAE,cAAc;CAIlE;AAED,MAAM,WAAW,cAAc;IAE7B,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAOD,wBAAgB,aAAa,CAAC,OAAO,GAAE,cAAmB,GAAG,MAAM,CA4BlE;AAQD,wBAAsB,OAAO,CAAC,CAAC,GAAG,GAAG,EACjC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,SAAS,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,EACnC,OAAO,GAAE,GAAQ,GAClB,OAAO,CAAC,CAAC,CAAC,CAIZ"}
+{"version":3,"file":"graphql.d.ts","sourceRoot":"","sources":["../../src/plugins/graphql.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAc,aAAa,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACtF,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,qBAAa,YAAa,SAAQ,WAAW;IACxB,MAAM,EAAE,GAAG,EAAE;IAAS,QAAQ,EAAE,cAAc;gBAA9C,MAAM,EAAE,GAAG,EAAE,EAAS,QAAQ,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,aAAa;CAU3F;AAED,MAAM,WAAW,cAAc;IAE7B,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAOD,wBAAgB,aAAa,CAAC,OAAO,GAAE,cAAmB,GAAG,MAAM,CA4BlE;AAQD,wBAAsB,OAAO,CAAC,CAAC,GAAG,GAAG,EACjC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,SAAS,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,EACnC,OAAO,GAAE,GAAQ,GAClB,OAAO,CAAC,CAAC,CAAC,CAuBZ"}

package/dist/plugins/graphql.js

@@ -1,8 +1,15 @@
-export class GraphQLError extends Error {
+import { ReckerError } from '../core/errors.js';
+export class GraphQLError extends ReckerError {
     errors;
     response;
-    constructor(errors, response) {
-        super(errors[0].message);
+    constructor(errors, response, request) {
+        const message = errors?.[0]?.message || 'GraphQL response contains errors';
+        const suggestions = [
+            'Check the GraphQL query and variables for schema compliance.',
+            'Inspect the GraphQL errors array for details.',
+            'Fix validation errors before retrying; network errors may be retriable.'
+        ];
+        super(message, request, response, suggestions, false);
         this.errors = errors;
         this.response = response;
         this.name = 'GraphQLError';
@@ -33,7 +40,19 @@ export function graphqlPlugin(options = {}) {
     };
 }
 export async function graphql(client, query, variables = {}, options = {}) {
-    const body = { query, variables };
-    const res = await client.post('', body, options).json();
+    const opMatch = query.match(/(query|mutation|subscription)\s+([a-zA-Z0-9_]+)/);
+    const operationName = opMatch ? opMatch[2] : undefined;
+    const payload = { query, variables, operationName };
+    if (options.method === 'GET') {
+        const params = {
+            query,
+            variables: JSON.stringify(variables),
+            ...(operationName && { operationName })
+        };
+        options.params = { ...options.params, ...params };
+        const res = await client.get('', options).json();
+        return res.data;
+    }
+    const res = await client.post('', payload, options).json();
     return res.data;
 }