recker 1.0.4 → 1.0.6

package/dist/testing/mock-udp-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-udp-server.d.ts","sourceRoot":"","sources":["../../src/testing/mock-udp-server.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,MAAM,YAAY,CAAC;AAC/B,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,MAAM,WAAW,oBAAoB;IAKnC,IAAI,CAAC,EAAE,MAAM,CAAC;IAMd,IAAI,CAAC,EAAE,MAAM,CAAC;IAMd,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAMvB,IAAI,CAAC,EAAE,OAAO,CAAC;IAMf,KAAK,CAAC,EAAE,MAAM,CAAC;IAMf,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,KAAK,CAAC,UAAU,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;CACnB;AAKD,qBAAa,aAAc,SAAQ,YAAY;IAC7C,OAAO,CAAC,MAAM,CAA6B;IAC3C,OAAO,CAAC,OAAO,CAAiC;IAChD,OAAO,CAAC,SAAS,CAA8F;IAC/G,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,iBAAiB,CAAyB;IAClD,OAAO,CAAC,QAAQ,CAAkB;gBAEtB,OAAO,GAAE,oBAAyB;IAgB9C,IAAI,IAAI,IAAI,MAAM,CAEjB;IAKD,IAAI,OAAO,IAAI,MAAM,CAEpB;IAKD,IAAI,SAAS,IAAI,OAAO,CAEvB;IAKD,IAAI,gBAAgB,IAAI,eAAe,EAAE,CAExC;IAKD,IAAI,YAAY,IAAI,MAAM,CAEzB;IAKK,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA2DtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAkB3B,WAAW,CACT,OAAO,EAAE,MAAM,GAAG,MAAM,EACxB,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,UAAU,KAAK,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC,GAC7F,IAAI;IAkBP,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAO7B,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAO/B,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAO/B,aAAa,IAAI,IAAI;IAOrB,cAAc,IAAI,IAAI;IAOtB,KAAK,IAAI,IAAI;IAWb,OAAO,CAAC,WAAW;IAyBb,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,MAAoB,GAAG,OAAO,CAAC,IAAI,CAAC;IAqBzF,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,MAAa,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;WAgB3E,MAAM,CAAC,OAAO,GAAE,oBAAyB,GAAG,OAAO,CAAC,aAAa,CAAC;CAKhF;AAKD,wBAAsB,mBAAmB,CACvC,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,EAC3C,OAAO,CAAC,EAAE,oBAAoB,GAC7B,OAAO,CAAC,aAAa,CAAC,CAYxB"}

package/dist/testing/mock-udp-server.js

@@ -0,0 +1,188 @@
+import dgram from 'node:dgram';
+import { EventEmitter } from 'node:events';
+export class MockUDPServer extends EventEmitter {
+    socket = null;
+    options;
+    responses = new Map();
+    _port = 0;
+    _receivedMessages = [];
+    _started = false;
+    constructor(options = {}) {
+        super();
+        this.options = {
+            port: 0,
+            host: '127.0.0.1',
+            type: 'udp4',
+            echo: true,
+            delay: 0,
+            dropRate: 0,
+            ...options,
+        };
+    }
+    get port() {
+        return this._port;
+    }
+    get address() {
+        return this.options.host;
+    }
+    get isRunning() {
+        return this._started;
+    }
+    get receivedMessages() {
+        return [...this._receivedMessages];
+    }
+    get messageCount() {
+        return this._receivedMessages.length;
+    }
+    async start() {
+        if (this._started) {
+            throw new Error('Server already started');
+        }
+        this.socket = dgram.createSocket(this.options.type);
+        this.socket.on('message', async (msg, rinfo) => {
+            this._receivedMessages.push({
+                data: msg,
+                rinfo,
+                timestamp: Date.now(),
+            });
+            this.emit('message', msg, rinfo);
+            if (this.options.dropRate > 0 && Math.random() < this.options.dropRate) {
+                this.emit('dropped', msg, rinfo);
+                return;
+            }
+            if (this.options.delay > 0) {
+                await new Promise((resolve) => setTimeout(resolve, this.options.delay));
+            }
+            const response = this.getResponse(msg, rinfo);
+            if (response) {
+                this.socket.send(response, rinfo.port, rinfo.address, (err) => {
+                    if (err) {
+                        this.emit('error', err);
+                    }
+                    else {
+                        this.emit('sent', response, rinfo);
+                    }
+                });
+            }
+        });
+        this.socket.on('error', (err) => {
+            this.emit('error', err);
+        });
+        return new Promise((resolve) => {
+            this.socket.bind(this.options.port, this.options.host, () => {
+                const addr = this.socket.address();
+                this._port = typeof addr === 'string' ? 0 : addr.port;
+                this._started = true;
+                this.emit('listening', this._port);
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        if (!this._started || !this.socket) {
+            return;
+        }
+        return new Promise((resolve) => {
+            this.socket.close(() => {
+                this._started = false;
+                this.socket = null;
+                this.emit('close');
+                resolve();
+            });
+        });
+    }
+    setResponse(pattern, response) {
+        const key = pattern instanceof RegExp ? pattern.source : pattern;
+        const handler = typeof response === 'function'
+            ? (msg, rinfo) => {
+                const result = response(msg, rinfo);
+                if (result === null)
+                    return null;
+                return typeof result === 'string' ? Buffer.from(result) : result;
+            }
+            : typeof response === 'string'
+                ? Buffer.from(response)
+                : response;
+        this.responses.set(key, handler);
+    }
+    setDelay(delay) {
+        this.options.delay = delay;
+    }
+    setDropRate(rate) {
+        this.options.dropRate = Math.max(0, Math.min(1, rate));
+    }
+    setEcho(enabled) {
+        this.options.echo = enabled;
+    }
+    clearMessages() {
+        this._receivedMessages = [];
+    }
+    clearResponses() {
+        this.responses.clear();
+    }
+    reset() {
+        this.clearMessages();
+        this.clearResponses();
+        this.options.delay = 0;
+        this.options.dropRate = 0;
+        this.options.echo = true;
+    }
+    getResponse(msg, rinfo) {
+        const msgStr = msg.toString();
+        for (const [pattern, response] of this.responses) {
+            const regex = new RegExp(pattern);
+            if (regex.test(msgStr)) {
+                if (typeof response === 'function') {
+                    return response(msg, rinfo);
+                }
+                return response;
+            }
+        }
+        if (this.options.echo) {
+            return msg;
+        }
+        return null;
+    }
+    async sendTo(data, port, address = '127.0.0.1') {
+        if (!this.socket || !this._started) {
+            throw new Error('Server not started');
+        }
+        const buffer = typeof data === 'string' ? Buffer.from(data) : data;
+        return new Promise((resolve, reject) => {
+            this.socket.send(buffer, port, address, (err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    async waitForMessages(count, timeout = 5000) {
+        const startTime = Date.now();
+        while (this._receivedMessages.length < count) {
+            if (Date.now() - startTime > timeout) {
+                throw new Error(`Timeout waiting for ${count} messages (received ${this._receivedMessages.length})`);
+            }
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+        return this._receivedMessages.slice(0, count);
+    }
+    static async create(options = {}) {
+        const server = new MockUDPServer(options);
+        await server.start();
+        return server;
+    }
+}
+export async function createMockUDPServer(responses, options) {
+    const server = new MockUDPServer(options);
+    if (responses) {
+        for (const [pattern, response] of Object.entries(responses)) {
+            server.setResponse(pattern, response);
+        }
+        server.setEcho(false);
+    }
+    await server.start();
+    return server;
+}

package/dist/transport/base-udp.d.ts

@@ -0,0 +1,36 @@
+import dgram from 'node:dgram';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import type { ReckerRequest, ReckerResponse } from '../types/index.js';
+import type { BaseUDPTransportOptions, UDPTimings, UDPConnection } from '../types/udp.js';
+export interface UDPRequestContext {
+    startTime: number;
+    queuedTime?: number;
+    sendTime?: number;
+    receiveTime?: number;
+    retransmissions: number;
+    localAddress?: string;
+    localPort?: number;
+    remoteAddress?: string;
+    remotePort?: number;
+}
+export declare const udpRequestStorage: AsyncLocalStorage<UDPRequestContext>;
+export declare const DEFAULT_UDP_OPTIONS: Required<BaseUDPTransportOptions>;
+export declare abstract class BaseUDPTransport {
+    protected options: Required<BaseUDPTransportOptions>;
+    constructor(options?: BaseUDPTransportOptions);
+    abstract dispatch(req: ReckerRequest): Promise<ReckerResponse>;
+    protected createSocket(type?: 'udp4' | 'udp6'): dgram.Socket;
+    protected sendWithRetry(socket: dgram.Socket, data: Buffer, port: number, address: string, signal?: AbortSignal): Promise<Buffer>;
+    protected sendOnce(socket: dgram.Socket, data: Buffer, port: number, address: string, signal?: AbortSignal): Promise<Buffer>;
+    protected collectTimings(): UDPTimings;
+    protected collectConnection(socket: dgram.Socket): UDPConnection;
+    protected parseUrl(url: string): {
+        host: string;
+        port: number;
+        path: string;
+    };
+    protected validatePacketSize(data: Buffer): void;
+    protected sleep(ms: number): Promise<void>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=base-udp.d.ts.map

package/dist/transport/base-udp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-udp.d.ts","sourceRoot":"","sources":["../../src/transport/base-udp.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,MAAM,YAAY,CAAC;AAC/B,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACvE,OAAO,KAAK,EACV,uBAAuB,EACvB,UAAU,EACV,aAAa,EACd,MAAM,iBAAiB,CAAC;AAMzB,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAKD,eAAO,MAAM,iBAAiB,sCAA6C,CAAC;AAK5E,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,uBAAuB,CAOjE,CAAC;AAKF,8BAAsB,gBAAgB;IACpC,SAAS,CAAC,OAAO,EAAE,QAAQ,CAAC,uBAAuB,CAAC,CAAC;gBAEzC,OAAO,GAAE,uBAA4B;IAUjD,QAAQ,CAAC,QAAQ,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;IAK9D,SAAS,CAAC,YAAY,CAAC,IAAI,GAAE,MAAM,GAAG,MAAe,GAAG,KAAK,CAAC,MAAM;cAiBpD,aAAa,CAC3B,MAAM,EAAE,KAAK,CAAC,MAAM,EACpB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,MAAM,CAAC;IAsClB,SAAS,CAAC,QAAQ,CAChB,MAAM,EAAE,KAAK,CAAC,MAAM,EACpB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,MAAM,CAAC;IAmFlB,SAAS,CAAC,cAAc,IAAI,UAAU;IAwCtC,SAAS,CAAC,iBAAiB,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,GAAG,aAAa;IAgBhE,SAAS,CAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE;IAqB7E,SAAS,CAAC,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAWhD,SAAS,CAAC,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAOpC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B"}

package/dist/transport/base-udp.js

@@ -0,0 +1,188 @@
+import dgram from 'node:dgram';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { TimeoutError, NetworkError } from '../core/errors.js';
+export const udpRequestStorage = new AsyncLocalStorage();
+export const DEFAULT_UDP_OPTIONS = {
+    timeout: 5000,
+    retransmissions: 3,
+    maxPacketSize: 65507,
+    observability: true,
+    localAddress: '',
+    localPort: 0,
+};
+export class BaseUDPTransport {
+    options;
+    constructor(options = {}) {
+        this.options = {
+            ...DEFAULT_UDP_OPTIONS,
+            ...options,
+        };
+    }
+    createSocket(type = 'udp4') {
+        const socket = dgram.createSocket({
+            type,
+            reuseAddr: true,
+        });
+        if (this.options.localAddress || this.options.localPort) {
+            socket.bind(this.options.localPort, this.options.localAddress || undefined);
+        }
+        return socket;
+    }
+    async sendWithRetry(socket, data, port, address, signal) {
+        const context = udpRequestStorage.getStore();
+        let attempts = 0;
+        const maxAttempts = this.options.retransmissions + 1;
+        while (attempts < maxAttempts) {
+            try {
+                if (signal?.aborted) {
+                    throw new Error('Request aborted');
+                }
+                const response = await this.sendOnce(socket, data, port, address, signal);
+                return response;
+            }
+            catch (error) {
+                attempts++;
+                if (context) {
+                    context.retransmissions = attempts - 1;
+                }
+                if (attempts >= maxAttempts) {
+                    throw error;
+                }
+                const delay = Math.min(1000 * Math.pow(2, attempts - 1), 5000);
+                await this.sleep(delay);
+            }
+        }
+        throw new TimeoutError({ url: `udp://${address}:${port}` }, { phase: 'response', timeout: this.options.timeout });
+    }
+    sendOnce(socket, data, port, address, signal) {
+        return new Promise((resolve, reject) => {
+            const context = udpRequestStorage.getStore();
+            let timeoutId;
+            let resolved = false;
+            const cleanup = () => {
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                }
+                socket.removeListener('message', onMessage);
+                socket.removeListener('error', onError);
+            };
+            const onMessage = (msg, rinfo) => {
+                if (resolved)
+                    return;
+                resolved = true;
+                if (context && this.options.observability) {
+                    context.receiveTime = performance.now();
+                    context.remoteAddress = rinfo.address;
+                    context.remotePort = rinfo.port;
+                }
+                cleanup();
+                resolve(msg);
+            };
+            const onError = (err) => {
+                if (resolved)
+                    return;
+                resolved = true;
+                cleanup();
+                reject(new NetworkError(err.message, err.code || 'UNKNOWN', {}));
+            };
+            const onTimeout = () => {
+                if (resolved)
+                    return;
+                resolved = true;
+                cleanup();
+                reject(new TimeoutError({ url: `udp://${address}:${port}` }, {
+                    phase: 'response',
+                    timeout: this.options.timeout,
+                }));
+            };
+            if (signal) {
+                signal.addEventListener('abort', () => {
+                    if (resolved)
+                        return;
+                    resolved = true;
+                    cleanup();
+                    reject(new Error('Request aborted'));
+                }, { once: true });
+            }
+            socket.on('message', onMessage);
+            socket.on('error', onError);
+            timeoutId = setTimeout(onTimeout, this.options.timeout);
+            if (context && this.options.observability) {
+                context.sendTime = performance.now();
+            }
+            socket.send(data, 0, data.length, port, address, (err) => {
+                if (err) {
+                    if (resolved)
+                        return;
+                    resolved = true;
+                    cleanup();
+                    reject(new NetworkError(err.message, err.code || 'SEND_ERROR', {}));
+                }
+            });
+        });
+    }
+    collectTimings() {
+        const context = udpRequestStorage.getStore();
+        if (!context || !this.options.observability) {
+            return {
+                queued: 0,
+                send: 0,
+                receive: 0,
+                retransmissions: 0,
+                total: 0,
+            };
+        }
+        const now = performance.now();
+        const queued = context.queuedTime
+            ? context.sendTime - context.queuedTime
+            : context.sendTime
+                ? context.sendTime - context.startTime
+                : 0;
+        const send = context.sendTime && context.receiveTime
+            ? 0.1
+            : 0;
+        const receive = context.sendTime && context.receiveTime
+            ? context.receiveTime - context.sendTime
+            : 0;
+        return {
+            queued: Math.round(queued * 100) / 100,
+            send: Math.round(send * 100) / 100,
+            receive: Math.round(receive * 100) / 100,
+            retransmissions: context.retransmissions,
+            total: Math.round((now - context.startTime) * 100) / 100,
+        };
+    }
+    collectConnection(socket) {
+        const context = udpRequestStorage.getStore();
+        const address = socket.address();
+        return {
+            protocol: 'udp',
+            localAddress: typeof address === 'string' ? address : address.address,
+            localPort: typeof address === 'string' ? 0 : address.port,
+            remoteAddress: context?.remoteAddress || '',
+            remotePort: context?.remotePort || 0,
+        };
+    }
+    parseUrl(url) {
+        let cleanUrl = url;
+        if (url.startsWith('udp://')) {
+            cleanUrl = url.slice(6);
+        }
+        const pathIndex = cleanUrl.indexOf('/');
+        const hostPort = pathIndex > -1 ? cleanUrl.slice(0, pathIndex) : cleanUrl;
+        const path = pathIndex > -1 ? cleanUrl.slice(pathIndex) : '/';
+        const [host, portStr] = hostPort.split(':');
+        const port = portStr ? parseInt(portStr, 10) : 0;
+        return { host, port, path };
+    }
+    validatePacketSize(data) {
+        if (data.length > this.options.maxPacketSize) {
+            throw new Error(`Packet size ${data.length} exceeds maximum ${this.options.maxPacketSize} bytes`);
+        }
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    async close() {
+    }
+}

package/dist/transport/udp-response.d.ts

@@ -0,0 +1,65 @@
+import type { SSEEvent, ProgressEvent } from '../types/index.js';
+import type { UDPTimings, UDPConnection, UDPResponse } from '../types/udp.js';
+export interface UDPResponseOptions {
+    timings?: UDPTimings;
+    connection?: UDPConnection;
+    url?: string;
+}
+export declare class UDPResponseImpl implements UDPResponse {
+    private _buffer;
+    private _timings;
+    private _connection;
+    private _url;
+    private _bodyUsed;
+    readonly status: number;
+    readonly statusText: string;
+    readonly headers: Headers;
+    readonly ok: boolean;
+    readonly raw: Response;
+    constructor(data: Buffer, options?: UDPResponseOptions);
+    get url(): string;
+    get timings(): UDPTimings;
+    get connection(): UDPConnection;
+    buffer(): Promise<Buffer>;
+    json<R = unknown>(): Promise<R>;
+    text(): Promise<string>;
+    cleanText(): Promise<string>;
+    blob(): Promise<Blob>;
+    read(): ReadableStream<Uint8Array> | null;
+    clone(): UDPResponseImpl;
+    sse(): AsyncGenerator<SSEEvent>;
+    download(): AsyncGenerator<ProgressEvent>;
+    packets(): AsyncGenerator<Buffer>;
+    [Symbol.asyncIterator](): AsyncGenerator<Uint8Array>;
+}
+export declare class StreamingUDPResponse implements UDPResponse {
+    private _packets;
+    private _timings;
+    private _connection;
+    private _url;
+    private _complete;
+    private _waiters;
+    readonly status: number;
+    readonly statusText: string;
+    readonly headers: Headers;
+    readonly ok: boolean;
+    readonly raw: Response;
+    constructor(options?: UDPResponseOptions);
+    get url(): string;
+    get timings(): UDPTimings;
+    get connection(): UDPConnection;
+    pushPacket(packet: Buffer): void;
+    complete(): void;
+    buffer(): Promise<Buffer>;
+    json<R = unknown>(): Promise<R>;
+    text(): Promise<string>;
+    cleanText(): Promise<string>;
+    blob(): Promise<Blob>;
+    read(): ReadableStream<Uint8Array> | null;
+    clone(): StreamingUDPResponse;
+    sse(): AsyncGenerator<SSEEvent>;
+    download(): AsyncGenerator<ProgressEvent>;
+    packets(): AsyncGenerator<Buffer>;
+    [Symbol.asyncIterator](): AsyncGenerator<Uint8Array>;
+}
+//# sourceMappingURL=udp-response.d.ts.map

package/dist/transport/udp-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"udp-response.d.ts","sourceRoot":"","sources":["../../src/transport/udp-response.ts"],"names":[],"mappings":"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"}