recker 1.0.2-0

package/dist/plugins/graphql.js

@@ -0,0 +1,39 @@
+export class GraphQLError extends Error {
+    errors;
+    response;
+    constructor(errors, response) {
+        super(errors[0].message);
+        this.errors = errors;
+        this.response = response;
+        this.name = 'GraphQLError';
+    }
+}
+export function graphqlPlugin(options = {}) {
+    const throwOnErrors = options.throwOnErrors !== false;
+    const middleware = async (req, next) => {
+        const res = await next(req);
+        const contentType = res.headers.get('content-type');
+        if (throwOnErrors && contentType && contentType.includes('application/json')) {
+            const clone = res.clone();
+            try {
+                const body = await clone.json();
+                if (body && Array.isArray(body.errors) && body.errors.length > 0) {
+                    throw new GraphQLError(body.errors, res);
+                }
+            }
+            catch (err) {
+                if (err instanceof GraphQLError)
+                    throw err;
+            }
+        }
+        return res;
+    };
+    return (client) => {
+        client.use(middleware);
+    };
+}
+export async function graphql(client, query, variables = {}, options = {}) {
+    const body = { query, variables };
+    const res = await client.post('', body, options).json();
+    return res.data;
+}

package/dist/plugins/har-player.d.ts

@@ -0,0 +1,7 @@
+import { Plugin } from '../types/index.js';
+export interface HarPlayerOptions {
+    path: string;
+    strict?: boolean;
+}
+export declare function harPlayer(options: HarPlayerOptions): Plugin;
+//# sourceMappingURL=har-player.d.ts.map

package/dist/plugins/har-player.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"har-player.d.ts","sourceRoot":"","sources":["../../src/plugins/har-player.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAA6C,MAAM,mBAAmB,CAAC;AAItF,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IAEb,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAgBD,wBAAgB,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,MAAM,CAqE3D"}

package/dist/plugins/har-player.js

@@ -0,0 +1,53 @@
+import { readFileSync } from 'node:fs';
+import { HttpResponse } from '../core/response.js';
+export function harPlayer(options) {
+    let entries = [];
+    try {
+        const content = readFileSync(options.path, 'utf-8');
+        const har = JSON.parse(content);
+        entries = har.log.entries;
+    }
+    catch (err) {
+        console.warn(`[Recker] Failed to load HAR file: ${options.path}`, err);
+    }
+    const matchEntry = (req, entry) => {
+        if (req.method !== entry.request.method)
+            return false;
+        if (req.url !== entry.request.url)
+            return false;
+        if (entry.request.postData?.text && req.body) {
+            if (String(req.body) !== entry.request.postData.text) {
+                try {
+                    const reqJson = JSON.parse(String(req.body));
+                    const entryJson = JSON.parse(entry.request.postData.text);
+                    if (JSON.stringify(reqJson) !== JSON.stringify(entryJson))
+                        return false;
+                }
+                catch {
+                    return false;
+                }
+            }
+        }
+        return true;
+    };
+    const middleware = async (req, next) => {
+        const entry = entries.find(e => matchEntry(req, e));
+        if (entry) {
+            const headers = new Headers();
+            entry.response.headers.forEach(h => headers.append(h.name, h.value));
+            const nativeRes = new Response(entry.response.content.text, {
+                status: entry.response.status,
+                statusText: entry.response.statusText,
+                headers: headers
+            });
+            return new HttpResponse(nativeRes);
+        }
+        if (options.strict) {
+            throw new Error(`[Recker HAR Player] No matching recording found for ${req.method} ${req.url}`);
+        }
+        return next(req);
+    };
+    return (client) => {
+        client.use(middleware);
+    };
+}

package/dist/plugins/har-recorder.d.ts

@@ -0,0 +1,7 @@
+import { Plugin } from '../types/index.js';
+export interface HarOptions {
+    path?: string;
+    onEntry?: (entry: any) => void;
+}
+export declare function harRecorder(options?: HarOptions): Plugin;
+//# sourceMappingURL=har-recorder.d.ts.map

package/dist/plugins/har-recorder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"har-recorder.d.ts","sourceRoot":"","sources":["../../src/plugins/har-recorder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAiC,MAAM,mBAAmB,CAAC;AAG1E,MAAM,WAAW,UAAU;IACzB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;CAChC;AAED,wBAAgB,WAAW,CAAC,OAAO,GAAE,UAAe,GAAG,MAAM,CA2E5D"}

package/dist/plugins/har-recorder.js

@@ -0,0 +1,67 @@
+import { writeFileSync } from 'node:fs';
+export function harRecorder(options = {}) {
+    const entries = [];
+    const startTime = new Date().toISOString();
+    return (client) => {
+        const requestMap = new WeakMap();
+        client.beforeRequest((req) => {
+            requestMap.set(req, { start: Date.now(), req });
+        });
+        client.afterResponse(async (req, res) => {
+            const meta = requestMap.get(req);
+            if (!meta)
+                return;
+            const time = Date.now() - meta.start;
+            const entry = {
+                startedDateTime: new Date(meta.start).toISOString(),
+                time: time,
+                request: {
+                    method: req.method,
+                    url: req.url,
+                    httpVersion: "HTTP/1.1",
+                    cookies: [],
+                    headers: [...req.headers].map(([name, value]) => ({ name, value })),
+                    queryString: [],
+                    headersSize: -1,
+                    bodySize: -1
+                },
+                response: {
+                    status: res.status,
+                    statusText: res.statusText,
+                    httpVersion: "HTTP/1.1",
+                    cookies: [],
+                    headers: [...res.headers].map(([name, value]) => ({ name, value })),
+                    content: {
+                        size: -1,
+                        mimeType: res.headers.get('content-type') || '',
+                        text: ''
+                    },
+                    redirectURL: "",
+                    headersSize: -1,
+                    bodySize: -1
+                },
+                cache: {},
+                timings: {
+                    send: 0,
+                    wait: res.timings?.firstByte || 0,
+                    receive: 0
+                }
+            };
+            entries.push(entry);
+            if (options.onEntry) {
+                options.onEntry(entry);
+            }
+            if (options.path) {
+                const har = {
+                    log: {
+                        version: "1.2",
+                        creator: { name: "Recker", version: "1.0.0" },
+                        pages: [],
+                        entries: entries
+                    }
+                };
+                writeFileSync(options.path, JSON.stringify(har, null, 2));
+            }
+        });
+    };
+}

package/dist/plugins/logger.d.ts

@@ -0,0 +1,11 @@
+import { Plugin, ReckerRequest } from '../types/index.js';
+export interface LoggerOptions {
+    log?: (message: string) => void;
+    logError?: (message: string, error: any) => void;
+    showHeaders?: boolean;
+    showBody?: boolean;
+    colors?: boolean;
+}
+export declare function logger(options?: LoggerOptions): Plugin;
+export declare function toCurl(req: ReckerRequest): string;
+//# sourceMappingURL=logger.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/plugins/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,aAAa,EAAkB,MAAM,mBAAmB,CAAC;AAE1E,MAAM,WAAW,aAAa;IAC5B,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;IACjD,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAcD,wBAAgB,MAAM,CAAC,OAAO,GAAE,aAAkB,GAAG,MAAM,CAkD1D;AAED,wBAAgB,MAAM,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CA4BjD"}

package/dist/plugins/logger.js

@@ -0,0 +1,72 @@
+const ANSI = {
+    RESET: "\x1b[0m",
+    BOLD: "\x1b[1m",
+    DIM: "\x1b[2m",
+    RED: "\x1b[31m",
+    GREEN: "\x1b[32m",
+    YELLOW: "\x1b[33m",
+    BLUE: "\x1b[34m",
+    MAGENTA: "\x1b[35m",
+    CYAN: "\x1b[36m",
+};
+export function logger(options = {}) {
+    const log = options.log || console.log;
+    const logError = options.logError || console.error;
+    const showHeaders = options.showHeaders || false;
+    const showBody = options.showBody || false;
+    const useColors = options.colors !== false;
+    const c = (color, text) => useColors ? `${ANSI[color]}${text}${ANSI.RESET}` : text;
+    const timers = new WeakMap();
+    return (client) => {
+        client.beforeRequest((req) => {
+            timers.set(req, performance.now());
+            const method = c('BLUE', req.method.padEnd(7));
+            const url = c('CYAN', req.url);
+            log(`${c('BOLD', '-->')} ${method} ${url}`);
+            if (showHeaders) {
+                req.headers.forEach((v, k) => log(`    ${c('DIM', k)}: ${v}`));
+            }
+            if (showBody && req.body) {
+                log(`    ${c('DIM', 'Body')}: ${typeof req.body === 'string' ? req.body : '[Object/Stream]'}`);
+            }
+        });
+        client.afterResponse((req, res) => {
+            const start = timers.get(req);
+            const duration = start ? (performance.now() - start).toFixed(0) + 'ms' : '?';
+            const statusColor = res.ok ? 'GREEN' : 'RED';
+            const status = c(statusColor, String(res.status));
+            const statusText = c(statusColor, res.statusText);
+            log(`${c('BOLD', '<--')} ${c('BLUE', req.method.padEnd(7))} ${c('CYAN', req.url)} ${status} ${statusText} ${c('YELLOW', duration)}`);
+            if (showHeaders) {
+                res.headers.forEach((v, k) => log(`    ${c('DIM', k)}: ${v}`));
+            }
+        });
+        client.onError((err, req) => {
+            const start = timers.get(req);
+            const duration = start ? (performance.now() - start).toFixed(0) + 'ms' : '?';
+            logError(`${c('RED', '!!!')} ${c('BLUE', req.method)} ${c('CYAN', req.url)} ${c('RED', err.message)} ${c('YELLOW', duration)}`, err);
+        });
+    };
+}
+export function toCurl(req) {
+    const parts = ['curl'];
+    if (req.method !== 'GET') {
+        parts.push(`-X ${req.method}`);
+    }
+    parts.push(`'${req.url}'`);
+    req.headers.forEach((value, key) => {
+        parts.push(`-H '${key}: ${value}'`);
+    });
+    if (req.body) {
+        if (typeof req.body === 'string') {
+            parts.push(`-d '${req.body}'`);
+        }
+        else if (req.body instanceof URLSearchParams) {
+            parts.push(`-d '${req.body.toString()}'`);
+        }
+        else {
+            parts.push(`-d '[Body]'`);
+        }
+    }
+    return parts.join(' ');
+}

package/dist/plugins/pagination.d.ts

@@ -0,0 +1,17 @@
+import { ReckerResponse, PageResult } from '../types/index.js';
+interface IClient {
+    request(url: string, options?: any): Promise<ReckerResponse>;
+}
+export interface PaginationOptions<T = any> {
+    getItems?: (data: any) => T[];
+    getNextUrl?: (response: ReckerResponse, data: any, currentUrl: string) => string | null;
+    maxPages?: number;
+    pageParam?: string;
+    limitParam?: string;
+    resultsPath?: string;
+    nextCursorPath?: string;
+}
+export declare function streamPages<T = any>(client: IClient, url: string, requestOptions?: any, paginationOptions?: PaginationOptions): AsyncGenerator<PageResult<T>>;
+export declare function paginate<T>(client: IClient, url: string, requestOptions?: any, paginationOptions?: PaginationOptions<T>): AsyncGenerator<T>;
+export {};
+//# sourceMappingURL=pagination.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pagination.d.ts","sourceRoot":"","sources":["../../src/plugins/pagination.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,cAAc,EAAiB,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAG7F,UAAU,OAAO;IACb,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;CAChE;AAED,MAAM,WAAW,iBAAiB,CAAC,CAAC,GAAG,GAAG;IACxC,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,CAAC,EAAE,CAAC;IAC9B,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,cAAc,EAAE,IAAI,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;IACxF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAKD,wBAAuB,WAAW,CAAC,CAAC,GAAG,GAAG,EACxC,MAAM,EAAE,OAAO,EACf,GAAG,EAAE,MAAM,EACX,cAAc,GAAE,GAAQ,EACxB,iBAAiB,GAAE,iBAAsB,GACxC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CA8F/B;AAED,wBAAuB,QAAQ,CAAC,CAAC,EAC/B,MAAM,EAAE,OAAO,EACf,GAAG,EAAE,MAAM,EACX,cAAc,GAAE,GAAQ,EACxB,iBAAiB,GAAE,iBAAiB,CAAC,CAAC,CAAM,GAC3C,cAAc,CAAC,CAAC,CAAC,CAuBnB"}

package/dist/plugins/pagination.js

@@ -0,0 +1,105 @@
+export async function* streamPages(client, url, requestOptions = {}, paginationOptions = {}) {
+    let currentUrl = url;
+    let pageCount = 1;
+    const maxPages = paginationOptions.maxPages || Infinity;
+    while (currentUrl && pageCount <= maxPages) {
+        const response = await client.request(currentUrl, { ...requestOptions, method: 'GET' });
+        const data = await response.json();
+        yield {
+            data,
+            response,
+            pageNumber: pageCount
+        };
+        pageCount++;
+        if (paginationOptions.getNextUrl) {
+            currentUrl = paginationOptions.getNextUrl(response, data, currentUrl);
+            continue;
+        }
+        if (paginationOptions.nextCursorPath) {
+            const parts = paginationOptions.nextCursorPath.split('.');
+            let cursor = data;
+            for (const part of parts) {
+                if (cursor && typeof cursor === 'object') {
+                    cursor = cursor[part];
+                }
+                else {
+                    cursor = undefined;
+                    break;
+                }
+            }
+            if (cursor) {
+                const cursorParamName = paginationOptions.pageParam || 'cursor';
+                const isAbsolute = currentUrl.startsWith('http');
+                const urlObj = new URL(isAbsolute ? currentUrl : `http://dummy-base${currentUrl.startsWith('/') ? '' : '/'}${currentUrl}`);
+                urlObj.searchParams.set(cursorParamName, String(cursor));
+                if (isAbsolute) {
+                    currentUrl = urlObj.toString();
+                }
+                else {
+                    currentUrl = urlObj.pathname + urlObj.search;
+                }
+            }
+            else {
+                currentUrl = null;
+            }
+            continue;
+        }
+        if (paginationOptions.pageParam) {
+            const isAbsolute = currentUrl.startsWith('http');
+            const urlObj = new URL(isAbsolute ? currentUrl : `http://dummy-base${currentUrl.startsWith('/') ? '' : '/'}${currentUrl}`);
+            const paramName = paginationOptions.pageParam;
+            const currentVal = parseInt(urlObj.searchParams.get(paramName) || String(pageCount - 1), 10);
+            let isEmpty = false;
+            if (Array.isArray(data) && data.length === 0)
+                isEmpty = true;
+            if (data && Array.isArray(data.data) && data.data.length === 0)
+                isEmpty = true;
+            if (data && Array.isArray(data.items) && data.items.length === 0)
+                isEmpty = true;
+            if (isEmpty) {
+                currentUrl = null;
+            }
+            else {
+                const nextPage = (isNaN(currentVal) ? 1 : currentVal) + 1;
+                urlObj.searchParams.set(paramName, String(nextPage));
+                currentUrl = isAbsolute ? urlObj.toString() : (urlObj.pathname + urlObj.search);
+            }
+            continue;
+        }
+        const linkHeader = response.headers.get('link');
+        if (linkHeader) {
+            const match = linkHeader.match(/<([^>]+)>;\s*rel="next"/);
+            currentUrl = match ? match[1] : null;
+        }
+        else {
+            currentUrl = null;
+        }
+    }
+}
+export async function* paginate(client, url, requestOptions = {}, paginationOptions = {}) {
+    for await (const page of streamPages(client, url, requestOptions, paginationOptions)) {
+        const data = page.data;
+        let items = [];
+        if (paginationOptions.getItems) {
+            items = paginationOptions.getItems(data);
+        }
+        else if (paginationOptions.resultsPath) {
+            items = paginationOptions.resultsPath.split('.').reduce((o, i) => o?.[i], data) || [];
+        }
+        else if (Array.isArray(data)) {
+            items = data;
+        }
+        else if (data && Array.isArray(data.data)) {
+            items = data.data;
+        }
+        else if (data && Array.isArray(data.items)) {
+            items = data.items;
+        }
+        else {
+            items = [data];
+        }
+        for (const item of items) {
+            yield item;
+        }
+    }
+}

package/dist/plugins/proxy-rotator.d.ts

@@ -0,0 +1,8 @@
+import { Plugin } from '../types/index.js';
+export interface ProxyRotatorOptions {
+    proxies: string[];
+    strategy?: 'round-robin' | 'random';
+    failover?: boolean;
+}
+export declare function proxyRotator(options: ProxyRotatorOptions): Plugin;
+//# sourceMappingURL=proxy-rotator.d.ts.map

package/dist/plugins/proxy-rotator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy-rotator.d.ts","sourceRoot":"","sources":["../../src/plugins/proxy-rotator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAiB,MAAM,mBAAmB,CAAC;AAG1D,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,CAAC,EAAE,aAAa,GAAG,QAAQ,CAAC;IAEpC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,MAAM,CAoDjE"}

package/dist/plugins/proxy-rotator.js

@@ -0,0 +1,35 @@
+import { ProxyAgent } from 'undici';
+export function proxyRotator(options) {
+    const proxies = options.proxies.map(url => ({
+        url,
+        agent: new ProxyAgent(url),
+        failures: 0
+    }));
+    let index = 0;
+    const getNextProxy = () => {
+        if (proxies.length === 0)
+            return null;
+        let selected;
+        if (options.strategy === 'random') {
+            selected = proxies[Math.floor(Math.random() * proxies.length)];
+        }
+        else {
+            selected = proxies[index];
+            index = (index + 1) % proxies.length;
+        }
+        return selected;
+    };
+    return (client) => {
+        client.beforeRequest((req) => {
+            const proxy = getNextProxy();
+            if (proxy) {
+                req._dispatcher = proxy.agent;
+                req._proxyUrl = proxy.url;
+            }
+        });
+        client.onError((err, req) => {
+            if (options.failover && req._proxyUrl) {
+            }
+        });
+    };
+}

package/dist/plugins/rate-limit.d.ts

@@ -0,0 +1,8 @@
+import { Plugin } from '../types/index.js';
+export interface RateLimitOptions {
+    concurrency?: number;
+    requestsPerInterval?: number;
+    interval?: number;
+}
+export declare function rateLimit(options: RateLimitOptions): Plugin;
+//# sourceMappingURL=rate-limit.d.ts.map

package/dist/plugins/rate-limit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limit.d.ts","sourceRoot":"","sources":["../../src/plugins/rate-limit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAOvD,MAAM,WAAW,gBAAgB;IAK/B,WAAW,CAAC,EAAE,MAAM,CAAC;IAIrB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAI7B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAiBD,wBAAgB,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,MAAM,CAqE3D"}

package/dist/plugins/rate-limit.js

@@ -0,0 +1,57 @@
+export function rateLimit(options) {
+    const concurrency = options.concurrency || Infinity;
+    const limit = options.requestsPerInterval || Infinity;
+    const interval = options.interval || 1000;
+    let activeCount = 0;
+    const queue = [];
+    let tokens = limit;
+    let lastRefill = Date.now();
+    const refillTokens = () => {
+        const now = Date.now();
+        const timePassed = now - lastRefill;
+        if (timePassed >= interval) {
+            const intervalsPassed = Math.floor(timePassed / interval);
+            tokens = Math.min(limit, tokens + (intervalsPassed * limit));
+            lastRefill = now;
+        }
+    };
+    const processQueue = () => {
+        if (queue.length === 0)
+            return;
+        refillTokens();
+        while (queue.length > 0 && activeCount < concurrency && tokens > 0) {
+            const next = queue.shift();
+            if (next) {
+                activeCount++;
+                tokens--;
+                next();
+            }
+        }
+        if (queue.length > 0 && tokens <= 0 && limit !== Infinity) {
+            const timeToWait = interval - (Date.now() - lastRefill);
+            setTimeout(processQueue, Math.max(0, timeToWait));
+        }
+    };
+    const rateLimitMiddleware = (req, next) => {
+        return new Promise((resolve, reject) => {
+            const run = async () => {
+                try {
+                    const res = await next(req);
+                    resolve(res);
+                }
+                catch (err) {
+                    reject(err);
+                }
+                finally {
+                    activeCount--;
+                    processQueue();
+                }
+            };
+            queue.push(run);
+            processQueue();
+        });
+    };
+    return (client) => {
+        client.use(rateLimitMiddleware);
+    };
+}

package/dist/plugins/retry.d.ts

@@ -0,0 +1,14 @@
+import { Plugin } from '../types/index.js';
+export type BackoffStrategy = 'linear' | 'exponential' | 'decorrelated';
+export interface RetryOptions {
+    maxAttempts?: number;
+    delay?: number;
+    maxDelay?: number;
+    backoff?: BackoffStrategy;
+    jitter?: boolean;
+    statusCodes?: number[];
+    shouldRetry?: (error: unknown) => boolean;
+    onRetry?: (attempt: number, error: unknown, delay: number) => void;
+}
+export declare function retry(options?: RetryOptions): Plugin;
+//# sourceMappingURL=retry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../src/plugins/retry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAGvD,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG,aAAa,GAAG,cAAc,CAAC;AAExE,MAAM,WAAW,YAAY;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;IAC1C,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACpE;AAgDD,wBAAgB,KAAK,CAAC,OAAO,GAAE,YAAiB,GAAG,MAAM,CAgFxD"}

package/dist/plugins/retry.js

@@ -0,0 +1,92 @@
+import { HttpError, NetworkError, TimeoutError } from '../core/errors.js';
+function calculateDelay(attempt, baseDelay, maxDelay, strategy, useJitter) {
+    let calculatedDelay;
+    switch (strategy) {
+        case 'linear':
+            calculatedDelay = baseDelay * attempt;
+            break;
+        case 'exponential':
+            calculatedDelay = Math.pow(2, attempt - 1) * baseDelay;
+            break;
+        case 'decorrelated':
+            const prevDelay = attempt === 1 ? baseDelay : Math.pow(2, attempt - 2) * baseDelay;
+            calculatedDelay = Math.random() * (prevDelay * 3 - baseDelay) + baseDelay;
+            break;
+        default:
+            calculatedDelay = baseDelay * attempt;
+    }
+    calculatedDelay = Math.min(calculatedDelay, maxDelay);
+    if (useJitter) {
+        const jitterRange = calculatedDelay * 0.25;
+        const jitterAmount = (Math.random() * jitterRange * 2) - jitterRange;
+        calculatedDelay += jitterAmount;
+    }
+    return Math.max(0, Math.floor(calculatedDelay));
+}
+export function retry(options = {}) {
+    const maxAttempts = options.maxAttempts || 3;
+    const baseDelay = options.delay || 1000;
+    const maxDelay = options.maxDelay || 30_000;
+    const backoffStrategy = options.backoff || 'exponential';
+    const useJitter = options.jitter !== false;
+    const statusCodes = options.statusCodes || [408, 429, 500, 502, 503, 504];
+    const onRetry = options.onRetry;
+    const defaultShouldRetry = (error) => {
+        if (error instanceof NetworkError)
+            return true;
+        if (error instanceof TimeoutError)
+            return true;
+        if (error instanceof HttpError) {
+            return statusCodes.includes(error.status);
+        }
+        if (error && typeof error === 'object' && 'code' in error) {
+            const code = error.code;
+            return code === 'ECONNRESET' || code === 'ETIMEDOUT' || code === 'ENOTFOUND';
+        }
+        return false;
+    };
+    const shouldRetry = options.shouldRetry || defaultShouldRetry;
+    return (client) => {
+        const middleware = async (req, next) => {
+            let attempt = 0;
+            while (true) {
+                try {
+                    attempt++;
+                    const res = await next(req);
+                    if (attempt < maxAttempts && !res.ok && statusCodes.includes(res.status)) {
+                        const delayMs = calculateDelay(attempt, baseDelay, maxDelay, backoffStrategy, useJitter);
+                        const err = new HttpError(res, req);
+                        if (onRetry) {
+                            onRetry(attempt, err, delayMs);
+                        }
+                        if (client.hooks && client.hooks.onRetry) {
+                            for (const hook of client.hooks.onRetry) {
+                                await hook(err, attempt, delayMs, req);
+                            }
+                        }
+                        await new Promise(resolve => setTimeout(resolve, delayMs));
+                        continue;
+                    }
+                    return res;
+                }
+                catch (error) {
+                    if (attempt < maxAttempts && shouldRetry(error)) {
+                        const delayMs = calculateDelay(attempt, baseDelay, maxDelay, backoffStrategy, useJitter);
+                        if (onRetry) {
+                            onRetry(attempt, error, delayMs);
+                        }
+                        if (client.hooks && client.hooks.onRetry) {
+                            for (const hook of client.hooks.onRetry) {
+                                await hook(error, attempt, delayMs, req);
+                            }
+                        }
+                        await new Promise(resolve => setTimeout(resolve, delayMs));
+                        continue;
+                    }
+                    throw error;
+                }
+            }
+        };
+        client.use(middleware);
+    };
+}

package/dist/plugins/server-timing.d.ts

@@ -0,0 +1,8 @@
+import { Plugin } from '../types/index.js';
+export interface ServerTiming {
+    name: string;
+    duration?: number;
+    description?: string;
+}
+export declare function serverTiming(): Plugin;
+//# sourceMappingURL=server-timing.d.ts.map

package/dist/plugins/server-timing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-timing.d.ts","sourceRoot":"","sources":["../../src/plugins/server-timing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAiC,MAAM,mBAAmB,CAAC;AAE1E,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,YAAY,IAAI,MAAM,CAyBrC"}