recker 1.0.2-0

package/dist/core/client.js

@@ -0,0 +1,475 @@
+import { HttpRequest } from './request.js';
+import { UndiciTransport } from '../transport/undici.js';
+import { RequestPromise } from './request-promise.js';
+import { HttpError } from '../core/errors.js';
+import { getLogger } from '../utils/logger.js';
+import { processBody } from '../utils/body.js';
+import { AgentManager } from '../utils/agent-manager.js';
+import { RequestPool } from '../utils/request-pool.js';
+import { normalizeConcurrency } from '../utils/concurrency.js';
+import { getDefaultUserAgent } from '../utils/user-agent.js';
+import { paginate, streamPages } from '../plugins/pagination.js';
+import { retry } from '../plugins/retry.js';
+import { cache } from '../plugins/cache.js';
+import { dedup } from '../plugins/dedup.js';
+import { createXSRFMiddleware } from '../plugins/xsrf.js';
+import { createCompressionMiddleware } from '../plugins/compression.js';
+import { MemoryStorage } from '../cache/memory-storage.js';
+import { FileStorage } from '../cache/file-storage.js';
+import { RequestRunner } from '../runner/request-runner.js';
+import { ReckerWebSocket } from '../websocket/client.js';
+import { whois as performWhois, isDomainAvailable } from '../utils/whois.js';
+export class Client {
+    baseUrl;
+    middlewares;
+    hooks;
+    transport;
+    defaultHeaders;
+    defaultParams;
+    paginationConfig;
+    handler;
+    logger;
+    debugEnabled;
+    agentManager;
+    concurrencyConfig;
+    requestPool;
+    constructor(options = {}) {
+        this.baseUrl = options.baseUrl || '';
+        this.middlewares = options.middlewares || [];
+        this.hooks = {
+            beforeRequest: options.hooks?.beforeRequest || [],
+            afterResponse: options.hooks?.afterResponse || [],
+            onError: options.hooks?.onError || [],
+            onRetry: options.hooks?.onRetry || [],
+            onUrlResolved: options.hooks?.onUrlResolved || [],
+        };
+        this.defaultHeaders = {
+            'User-Agent': getDefaultUserAgent(),
+            ...(options.headers || {})
+        };
+        this.defaultParams = options.defaults?.params || {};
+        this.paginationConfig = options.pagination;
+        this.debugEnabled = options.debug === true;
+        if (this.debugEnabled) {
+            this.logger = getLogger();
+        }
+        this.concurrencyConfig = normalizeConcurrency({
+            concurrency: options.concurrency,
+            http2: options.http2
+        });
+        if (options.transport) {
+            this.transport = options.transport;
+        }
+        else if (this.baseUrl) {
+            let http2Options;
+            if (options.http2) {
+                if (typeof options.http2 === 'boolean') {
+                    http2Options = { enabled: options.http2 };
+                }
+                else {
+                    http2Options = options.http2;
+                }
+            }
+            this.agentManager = new AgentManager(this.concurrencyConfig.agent);
+            this.transport = new UndiciTransport(this.baseUrl, {
+                proxy: options.proxy,
+                http2: http2Options,
+                dns: options.dns,
+                agent: this.agentManager
+            });
+        }
+        else {
+            throw new Error('baseUrl is required for default UndiciTransport, or provide a custom transport.');
+        }
+        if (options.retry) {
+            retry(options.retry)(this);
+        }
+        if (this.concurrencyConfig.max < Infinity || this.concurrencyConfig.requestsPerInterval < Infinity) {
+            this.requestPool = new RequestPool({
+                concurrency: this.concurrencyConfig.max,
+                requestsPerInterval: this.concurrencyConfig.requestsPerInterval,
+                interval: this.concurrencyConfig.interval
+            });
+            this.middlewares.unshift(this.requestPool.asMiddleware());
+            if (this.debugEnabled) {
+                console.log(`[Recker] Global concurrency limit: ${this.concurrencyConfig.max} concurrent requests`);
+            }
+        }
+        else {
+            if (this.debugEnabled) {
+                console.log('[Recker] No global concurrency limit (allows unlimited parallel batches)');
+            }
+        }
+        if (options.dedup) {
+            dedup(options.dedup)(this);
+        }
+        if (options.cache) {
+            let storage;
+            if (options.cache.storage) {
+                storage = options.cache.storage;
+            }
+            else if (options.cache.driver === 'file') {
+                storage = new FileStorage(options.cache.fileStoragePath);
+            }
+            else {
+                storage = new MemoryStorage();
+            }
+            cache({
+                ...options.cache,
+                storage
+            })(this);
+        }
+        if (options.plugins) {
+            options.plugins.forEach((plugin) => plugin(this));
+        }
+        if (options.compression) {
+            const compressionMiddleware = createCompressionMiddleware(options.compression);
+            if (compressionMiddleware) {
+                this.middlewares.push(compressionMiddleware);
+            }
+        }
+        if (options.xsrf) {
+            const xsrfMiddleware = createXSRFMiddleware(options.xsrf);
+            if (xsrfMiddleware) {
+                this.middlewares.push(xsrfMiddleware);
+            }
+        }
+        if (this.debugEnabled && this.logger) {
+            this.middlewares.unshift(this.createLoggingMiddleware(this.logger));
+        }
+        this.middlewares.push(this.httpErrorMiddleware);
+        this.handler = this.composeMiddlewares();
+    }
+    createLoggingMiddleware(logger) {
+        return async (req, next) => {
+            const startTime = Date.now();
+            logger.logRequest(req);
+            try {
+                const response = await next(req);
+                logger.logResponse(req, response, startTime);
+                return response;
+            }
+            catch (error) {
+                logger.logError(req, error);
+                throw error;
+            }
+        };
+    }
+    composeMiddlewares() {
+        const chain = [...this.middlewares];
+        const transportDispatch = this.transport.dispatch.bind(this.transport);
+        if (this.hooks.beforeRequest?.length || this.hooks.afterResponse?.length) {
+            chain.unshift(this.hooksMiddleware);
+        }
+        if (chain.length === 0) {
+            return transportDispatch;
+        }
+        return chain.reduceRight((next, middleware) => {
+            return (req) => middleware(req, next);
+        }, transportDispatch);
+    }
+    hooksMiddleware = async (req, next) => {
+        let modifiedReq = req;
+        if (this.hooks.beforeRequest && this.hooks.beforeRequest.length > 0) {
+            for (const hook of this.hooks.beforeRequest) {
+                const result = await hook(modifiedReq);
+                if (result) {
+                    modifiedReq = result;
+                }
+            }
+        }
+        try {
+            let response = await next(modifiedReq);
+            if (this.hooks.afterResponse && this.hooks.afterResponse.length > 0) {
+                for (const hook of this.hooks.afterResponse) {
+                    const result = await hook(modifiedReq, response);
+                    if (result) {
+                        response = result;
+                    }
+                }
+            }
+            return response;
+        }
+        catch (error) {
+            if (this.hooks.onError && this.hooks.onError.length > 0) {
+                for (const hook of this.hooks.onError) {
+                    const result = await hook(error, modifiedReq);
+                    if (result) {
+                        return result;
+                    }
+                }
+            }
+            throw error;
+        }
+    };
+    httpErrorMiddleware = async (req, next) => {
+        const response = await next(req);
+        if (req.throwHttpErrors !== false && !response.ok) {
+            throw new HttpError(response, req);
+        }
+        return response;
+    };
+    use(middleware) {
+        this.middlewares.push(middleware);
+        this.handler = this.composeMiddlewares();
+        return this;
+    }
+    beforeRequest(hook) {
+        if (!this.hooks.beforeRequest) {
+            this.hooks.beforeRequest = [];
+        }
+        this.hooks.beforeRequest.push(hook);
+        this.handler = this.composeMiddlewares();
+        return this;
+    }
+    afterResponse(hook) {
+        if (!this.hooks.afterResponse) {
+            this.hooks.afterResponse = [];
+        }
+        this.hooks.afterResponse.push(hook);
+        this.handler = this.composeMiddlewares();
+        return this;
+    }
+    onError(hook) {
+        if (!this.hooks.onError) {
+            this.hooks.onError = [];
+        }
+        this.hooks.onError.push(hook);
+        this.handler = this.composeMiddlewares();
+        return this;
+    }
+    buildUrl(path, requestParams) {
+        const hasRequestParams = requestParams && Object.keys(requestParams).length > 0;
+        const hasDefaultParams = Object.keys(this.defaultParams).length > 0;
+        if (!hasRequestParams && !hasDefaultParams) {
+            if (this.baseUrl && !path.startsWith('http')) {
+                return new URL(path, this.baseUrl).toString();
+            }
+            return path;
+        }
+        let finalPath = path;
+        const mergedParams = { ...this.defaultParams, ...requestParams };
+        const usedParams = new Set();
+        if (finalPath.includes(':')) {
+            finalPath = finalPath.replace(/:([a-zA-Z0-9_]+)/g, (match, paramName) => {
+                if (mergedParams && paramName in mergedParams) {
+                    usedParams.add(paramName);
+                    return String(mergedParams[paramName]);
+                }
+                throw new Error(`Missing required path parameter: ${paramName}`);
+            });
+        }
+        let finalUrl = finalPath;
+        if (this.baseUrl && !finalPath.startsWith('http://') && !finalPath.startsWith('https://')) {
+            finalUrl = new URL(finalPath, this.baseUrl).toString();
+        }
+        else if (!this.baseUrl && !finalPath.startsWith('http://') && !finalPath.startsWith('https://')) {
+            throw new Error('Relative path provided without a baseUrl or explicit transport.');
+        }
+        const remainingKeys = Object.keys(mergedParams).filter((k) => !usedParams.has(k));
+        if (remainingKeys.length > 0) {
+            const urlObj = new URL(finalUrl);
+            remainingKeys.forEach((key) => {
+                urlObj.searchParams.append(key, String(mergedParams[key]));
+            });
+            return urlObj.toString();
+        }
+        return finalUrl;
+    }
+    request(path, options = {}) {
+        const url = this.buildUrl(path, options.params);
+        let mergedHeaders = this.defaultHeaders;
+        if (options.headers) {
+            mergedHeaders = new Headers(this.defaultHeaders);
+            new Headers(options.headers).forEach((value, key) => mergedHeaders.append(key, value));
+        }
+        else if (!(mergedHeaders instanceof Headers)) {
+            mergedHeaders = new Headers(mergedHeaders);
+        }
+        const controller = new AbortController();
+        let signal = controller.signal;
+        let timeoutId;
+        let externalAbortCleanup;
+        if (options.signal) {
+            const externalSignal = options.signal;
+            const abortHandler = () => controller.abort(externalSignal.reason);
+            if (externalSignal.aborted) {
+                abortHandler();
+            }
+            else {
+                externalSignal.addEventListener('abort', abortHandler, { once: true });
+                externalAbortCleanup = () => externalSignal.removeEventListener('abort', abortHandler);
+            }
+        }
+        if (options.timeout) {
+            timeoutId = setTimeout(() => controller.abort(new Error('Request timed out')), options.timeout);
+        }
+        const req = new HttpRequest(url, {
+            ...options,
+            headers: mergedHeaders,
+            signal,
+        });
+        const responsePromise = this.handler(req);
+        if (timeoutId || externalAbortCleanup) {
+            responsePromise.finally(() => {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                externalAbortCleanup?.();
+            });
+        }
+        return new RequestPromise(responsePromise, controller);
+    }
+    get(path, options = {}) {
+        return this.request(path, { ...options, method: 'GET' });
+    }
+    async batch(requests, options = {}) {
+        const mapResponse = options.mapResponse ?? ((res) => res);
+        const batchConcurrency = options.concurrency ?? this.concurrencyConfig.runner.concurrency;
+        const runner = new RequestRunner({
+            concurrency: batchConcurrency,
+            retries: this.concurrencyConfig.runner.retries,
+            retryDelay: this.concurrencyConfig.runner.retryDelay
+        });
+        const runnerResult = await runner.run(requests, async (item) => {
+            const res = await this.request(item.path, item.options);
+            return mapResponse(res);
+        });
+        return runnerResult;
+    }
+    multi(requests, options = {}) {
+        return this.batch(requests, options);
+    }
+    requestWithBody(method, path, body, options = {}) {
+        const { body: processedBody, contentType } = processBody(body);
+        const headers = new Headers(options.headers);
+        if (contentType && !headers.has('Content-Type')) {
+            headers.set('Content-Type', contentType);
+        }
+        return this.request(path, { ...options, method, body: processedBody, headers });
+    }
+    post(path, body, options = {}) {
+        return this.requestWithBody('POST', path, body, options);
+    }
+    put(path, body, options = {}) {
+        return this.requestWithBody('PUT', path, body, options);
+    }
+    patch(path, body, options = {}) {
+        return this.requestWithBody('PATCH', path, body, options);
+    }
+    delete(path, options = {}) {
+        return this.request(path, { ...options, method: 'DELETE' });
+    }
+    head(path, options = {}) {
+        return this.request(path, { ...options, method: 'HEAD' });
+    }
+    options(path, options = {}) {
+        return this.request(path, { ...options, method: 'OPTIONS' });
+    }
+    trace(path, options = {}) {
+        return this.request(path, { ...options, method: 'TRACE' });
+    }
+    connect(path, options = {}) {
+        return this.request(path, { ...options, method: 'CONNECT' });
+    }
+    purge(path, options = {}) {
+        return this.request(path, { ...options, method: 'PURGE' });
+    }
+    propfind(path, body, options = {}) {
+        return this.requestWithBody('PROPFIND', path, body, options);
+    }
+    proppatch(path, body, options = {}) {
+        return this.requestWithBody('PROPPATCH', path, body, options);
+    }
+    mkcol(path, options = {}) {
+        return this.request(path, { ...options, method: 'MKCOL' });
+    }
+    copy(path, options = {}) {
+        return this.request(path, { ...options, method: 'COPY' });
+    }
+    move(path, options = {}) {
+        return this.request(path, { ...options, method: 'MOVE' });
+    }
+    lock(path, body, options = {}) {
+        return this.requestWithBody('LOCK', path, body, options);
+    }
+    unlock(path, options = {}) {
+        return this.request(path, { ...options, method: 'UNLOCK' });
+    }
+    link(path, body, options = {}) {
+        return this.requestWithBody('LINK', path, body, options);
+    }
+    unlink(path, body, options = {}) {
+        return this.requestWithBody('UNLINK', path, body, options);
+    }
+    paginate(path, options = {}) {
+        const { getItems, getNextUrl, maxPages, pageParam, limitParam, resultsPath, nextCursorPath, ...reqOptions } = options;
+        const paginationOpts = {
+            getItems,
+            getNextUrl,
+            maxPages,
+            pageParam: pageParam || this.paginationConfig?.pageParam,
+            limitParam: limitParam || this.paginationConfig?.limitParam,
+            resultsPath: resultsPath || this.paginationConfig?.resultsPath,
+            nextCursorPath: nextCursorPath || this.paginationConfig?.nextCursorPath,
+        };
+        return paginate(this, path, reqOptions, paginationOpts);
+    }
+    pages(path, options = {}) {
+        const { getNextUrl, maxPages, pageParam, limitParam, resultsPath, nextCursorPath, ...reqOptions } = options;
+        const paginationOpts = {
+            getNextUrl,
+            maxPages,
+            pageParam: pageParam || this.paginationConfig?.pageParam,
+            limitParam: limitParam || this.paginationConfig?.limitParam,
+            nextCursorPath: nextCursorPath || this.paginationConfig?.nextCursorPath,
+        };
+        return streamPages(this, path, reqOptions, paginationOpts);
+    }
+    page(path, pageNumber, options = {}) {
+        const pageParam = options.pageParam || this.paginationConfig?.pageParam || 'page';
+        const url = new URL(path.startsWith('http') ? path : `http://base${path}`);
+        const params = { ...options.params, [pageParam]: pageNumber };
+        return this.request(path, { ...options, params });
+    }
+    async getAll(path, options = {}) {
+        const items = [];
+        for await (const item of this.paginate(path, options)) {
+            items.push(item);
+        }
+        return items;
+    }
+    websocket(path, options = {}) {
+        let wsUrl;
+        if (path.startsWith('ws://') || path.startsWith('wss://')) {
+            wsUrl = path;
+        }
+        else if (this.baseUrl) {
+            const base = this.baseUrl.replace(/^http/, 'ws');
+            wsUrl = new URL(path, base).toString();
+        }
+        else {
+            throw new Error('WebSocket requires either a full ws:// URL or a baseUrl');
+        }
+        const headersObj = {};
+        if (this.defaultHeaders) {
+            const headers = new Headers(this.defaultHeaders);
+            headers.forEach((value, key) => {
+                headersObj[key] = value;
+            });
+        }
+        const finalHeaders = { ...headersObj, ...options.headers };
+        return new ReckerWebSocket(wsUrl, { ...options, headers: finalHeaders });
+    }
+    ws(path, options = {}) {
+        return this.websocket(path, options);
+    }
+    async whois(query, options) {
+        return performWhois(query, options);
+    }
+    async isDomainAvailable(domain, options) {
+        return isDomainAvailable(domain, options);
+    }
+}
+export function createClient(options = {}) {
+    return new Client(options);
+}

package/dist/core/errors.d.ts

@@ -0,0 +1,19 @@
+import { ReckerRequest, ReckerResponse } from '../types/index.js';
+export declare class ReckerError extends Error {
+    request?: ReckerRequest;
+    response?: ReckerResponse;
+    constructor(message: string, request?: ReckerRequest, response?: ReckerResponse);
+}
+export declare class HttpError extends ReckerError {
+    status: number;
+    statusText: string;
+    constructor(response: ReckerResponse, request?: ReckerRequest);
+}
+export declare class TimeoutError extends ReckerError {
+    constructor(request?: ReckerRequest);
+}
+export declare class NetworkError extends ReckerError {
+    code?: string;
+    constructor(message: string, code?: string, request?: ReckerRequest);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/core/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/core/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAElE,qBAAa,WAAY,SAAQ,KAAK;IACpC,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,QAAQ,CAAC,EAAE,cAAc,CAAC;gBAEd,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,EAAE,QAAQ,CAAC,EAAE,cAAc;CAMhF;AAED,qBAAa,SAAU,SAAQ,WAAW;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;gBAEP,QAAQ,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,aAAa;CAM9D;AAED,qBAAa,YAAa,SAAQ,WAAW;gBAC/B,OAAO,CAAC,EAAE,aAAa;CAIpC;AAED,qBAAa,YAAa,SAAQ,WAAW;IAC3C,IAAI,CAAC,EAAE,MAAM,CAAC;gBAEF,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa;CAKpE"}

package/dist/core/errors.js

@@ -0,0 +1,34 @@
+export class ReckerError extends Error {
+    request;
+    response;
+    constructor(message, request, response) {
+        super(message);
+        this.name = 'ReckerError';
+        this.request = request;
+        this.response = response;
+    }
+}
+export class HttpError extends ReckerError {
+    status;
+    statusText;
+    constructor(response, request) {
+        super(`Request failed with status code ${response.status} ${response.statusText}`, request, response);
+        this.name = 'HttpError';
+        this.status = response.status;
+        this.statusText = response.statusText;
+    }
+}
+export class TimeoutError extends ReckerError {
+    constructor(request) {
+        super('Request timed out', request);
+        this.name = 'TimeoutError';
+    }
+}
+export class NetworkError extends ReckerError {
+    code;
+    constructor(message, code, request) {
+        super(message, request);
+        this.name = 'NetworkError';
+        this.code = code;
+    }
+}

package/dist/core/request-promise.d.ts

@@ -0,0 +1,24 @@
+import { ReckerResponse, SSEEvent, ProgressEvent } from '../types/index.js';
+import { ZodSchema } from 'zod';
+export declare class RequestPromise<T = unknown> implements Promise<ReckerResponse<T>> {
+    private promise;
+    private abortController?;
+    constructor(promise: Promise<ReckerResponse<T>>, abortController?: AbortController);
+    get [Symbol.toStringTag](): string;
+    then<TResult1 = ReckerResponse<T>, TResult2 = never>(onfulfilled?: ((value: ReckerResponse<T>) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<ReckerResponse<T> | TResult>;
+    finally(onfinally?: (() => void) | null): Promise<ReckerResponse<T>>;
+    cancel(): void;
+    json<R = T>(): Promise<R>;
+    text(): Promise<string>;
+    cleanText(): Promise<string>;
+    blob(): Promise<Blob>;
+    read(): Promise<ReadableStream<Uint8Array> | null>;
+    write(path: string): Promise<void>;
+    parse<R>(schema: ZodSchema<R>): Promise<R>;
+    safe(): Promise<[boolean, Error | null, T | undefined]>;
+    sse(): AsyncGenerator<SSEEvent>;
+    download(): AsyncGenerator<ProgressEvent>;
+    [Symbol.asyncIterator](): AsyncGenerator<Uint8Array>;
+}
+//# sourceMappingURL=request-promise.d.ts.map

package/dist/core/request-promise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-promise.d.ts","sourceRoot":"","sources":["../../src/core/request-promise.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAC5E,OAAO,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AAMhC,qBAAa,cAAc,CAAC,CAAC,GAAG,OAAO,CAAE,YAAW,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAC5E,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,eAAe,CAAC,CAAkB;gBAE9B,OAAO,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,EAAE,eAAe,CAAC,EAAE,eAAe;IAKlF,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,WAEvB;IAED,IAAI,CAAC,QAAQ,GAAG,cAAc,CAAC,CAAC,CAAC,EAAE,QAAQ,GAAG,KAAK,EACjD,WAAW,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,KAAK,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC,GAAG,IAAI,EACrF,UAAU,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,GAAG,KAAK,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC,GAAG,IAAI,GACtE,OAAO,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAI/B,KAAK,CAAC,OAAO,GAAG,KAAK,EACnB,UAAU,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI,GACpE,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;IAIvC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAKpE,MAAM,IAAI,IAAI;IAMR,IAAI,CAAC,CAAC,GAAG,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC;IAKzB,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC;IAKvB,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC;IAK5B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAKrB,IAAI,IAAI,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC;IAKlD,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAalC,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAK1C,IAAI,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,KAAK,GAAG,IAAI,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC;IAKtD,GAAG,IAAI,cAAc,CAAC,QAAQ,CAAC;IAK/B,QAAQ,IAAI,cAAc,CAAC,aAAa,CAAC;IAKzC,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,cAAc,CAAC,UAAU,CAAC;CAI5D"}

package/dist/core/request-promise.js

@@ -0,0 +1,77 @@
+import { createWriteStream } from 'node:fs';
+import { pipeline } from 'node:stream/promises';
+import { Readable } from 'node:stream';
+import { tryFn } from '../utils/try-fn.js';
+export class RequestPromise {
+    promise;
+    abortController;
+    constructor(promise, abortController) {
+        this.promise = promise;
+        this.abortController = abortController;
+    }
+    get [Symbol.toStringTag]() {
+        return 'RequestPromise';
+    }
+    then(onfulfilled, onrejected) {
+        return this.promise.then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.promise.catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.promise.finally(onfinally);
+    }
+    cancel() {
+        if (this.abortController) {
+            this.abortController.abort();
+        }
+    }
+    async json() {
+        const response = await this.promise;
+        return response.json();
+    }
+    async text() {
+        const response = await this.promise;
+        return response.text();
+    }
+    async cleanText() {
+        const response = await this.promise;
+        return response.cleanText();
+    }
+    async blob() {
+        const response = await this.promise;
+        return response.blob();
+    }
+    async read() {
+        const response = await this.promise;
+        return response.read();
+    }
+    async write(path) {
+        const response = await this.promise;
+        const body = response.read();
+        if (!body)
+            throw new Error('Response has no body');
+        const nodeStream = Readable.fromWeb(body);
+        const fileStream = createWriteStream(path);
+        await pipeline(nodeStream, fileStream);
+    }
+    async parse(schema) {
+        const data = await this.json();
+        return schema.parse(data);
+    }
+    async safe() {
+        return tryFn(() => this.json());
+    }
+    async *sse() {
+        const response = await this.promise;
+        yield* response.sse();
+    }
+    async *download() {
+        const response = await this.promise;
+        yield* response.download();
+    }
+    async *[Symbol.asyncIterator]() {
+        const response = await this.promise;
+        yield* response;
+    }
+}

package/dist/core/request.d.ts

@@ -0,0 +1,15 @@
+import { Method, ReckerRequest, RequestOptions, ProgressCallback } from '../types/index.js';
+export declare class HttpRequest implements ReckerRequest {
+    readonly url: string;
+    readonly method: Method;
+    readonly headers: Headers;
+    readonly body: BodyInit | null;
+    readonly signal?: AbortSignal;
+    readonly throwHttpErrors?: boolean;
+    readonly onUploadProgress?: ProgressCallback;
+    readonly onDownloadProgress?: ProgressCallback;
+    constructor(url: string, options?: RequestOptions);
+    withHeader(name: string, value: string): ReckerRequest;
+    withBody(body: BodyInit): ReckerRequest;
+}
+//# sourceMappingURL=request.d.ts.map

package/dist/core/request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../../src/core/request.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE5F,qBAAa,WAAY,YAAW,aAAa;IAC/C,SAAgB,GAAG,EAAE,MAAM,CAAC;IAC5B,SAAgB,MAAM,EAAE,MAAM,CAAC;IAC/B,SAAgB,OAAO,EAAE,OAAO,CAAC;IACjC,SAAgB,IAAI,EAAE,QAAQ,GAAG,IAAI,CAAC;IACtC,SAAgB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrC,SAAgB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1C,SAAgB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpD,SAAgB,kBAAkB,CAAC,EAAE,gBAAgB,CAAC;gBAE1C,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,cAAmB;IAWrD,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,aAAa;IActD,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,aAAa;CAWxC"}