recker 1.0.5 → 1.0.6

package/dist/transport/udp-response.js

@@ -0,0 +1,269 @@
+export class UDPResponseImpl {
+    _buffer;
+    _timings;
+    _connection;
+    _url;
+    _bodyUsed = false;
+    status = 200;
+    statusText = 'OK';
+    headers;
+    ok = true;
+    raw;
+    constructor(data, options = {}) {
+        this._buffer = data;
+        this._url = options.url || '';
+        this._timings = options.timings ?? {
+            queued: 0,
+            send: 0,
+            receive: 0,
+            retransmissions: 0,
+            total: 0,
+        };
+        this._connection = options.connection ?? {
+            protocol: 'udp',
+            localAddress: '',
+            localPort: 0,
+            remoteAddress: '',
+            remotePort: 0,
+        };
+        this.headers = new Headers({
+            'content-type': 'application/octet-stream',
+            'content-length': String(data.length),
+            'x-protocol': 'udp',
+        });
+        this.raw = new Response(new Uint8Array(data), {
+            status: 200,
+            statusText: 'OK',
+            headers: this.headers,
+        });
+    }
+    get url() {
+        return this._url;
+    }
+    get timings() {
+        return this._timings;
+    }
+    get connection() {
+        return this._connection;
+    }
+    async buffer() {
+        this._bodyUsed = true;
+        return this._buffer;
+    }
+    async json() {
+        this._bodyUsed = true;
+        const text = this._buffer.toString('utf8');
+        return JSON.parse(text);
+    }
+    async text() {
+        this._bodyUsed = true;
+        return this._buffer.toString('utf8');
+    }
+    async cleanText() {
+        this._bodyUsed = true;
+        return this._buffer
+            .toString('utf8')
+            .replace(/[\x00-\x1F\x7F-\x9F]/g, ' ')
+            .replace(/\s+/g, ' ')
+            .trim();
+    }
+    async blob() {
+        this._bodyUsed = true;
+        return new Blob([new Uint8Array(this._buffer)]);
+    }
+    read() {
+        if (this._bodyUsed) {
+            return null;
+        }
+        this._bodyUsed = true;
+        const buffer = this._buffer;
+        return new ReadableStream({
+            start(controller) {
+                controller.enqueue(new Uint8Array(buffer));
+                controller.close();
+            },
+        });
+    }
+    clone() {
+        return new UDPResponseImpl(Buffer.from(this._buffer), {
+            timings: { ...this._timings },
+            connection: { ...this._connection },
+            url: this._url,
+        });
+    }
+    async *sse() {
+        throw new Error('SSE is not supported for UDP responses');
+    }
+    async *download() {
+        yield {
+            loaded: this._buffer.length,
+            transferred: this._buffer.length,
+            total: this._buffer.length,
+            percent: 100,
+            direction: 'download',
+        };
+    }
+    async *packets() {
+        yield this._buffer;
+    }
+    async *[Symbol.asyncIterator]() {
+        yield new Uint8Array(this._buffer);
+    }
+}
+export class StreamingUDPResponse {
+    _packets = [];
+    _timings;
+    _connection;
+    _url;
+    _complete = false;
+    _waiters = [];
+    status = 200;
+    statusText = 'OK';
+    headers;
+    ok = true;
+    raw;
+    constructor(options = {}) {
+        this._url = options.url || '';
+        this._timings = options.timings ?? {
+            queued: 0,
+            send: 0,
+            receive: 0,
+            retransmissions: 0,
+            total: 0,
+        };
+        this._connection = options.connection ?? {
+            protocol: 'udp',
+            localAddress: '',
+            localPort: 0,
+            remoteAddress: '',
+            remotePort: 0,
+        };
+        this.headers = new Headers({
+            'content-type': 'application/octet-stream',
+            'x-protocol': 'udp',
+            'x-streaming': 'true',
+        });
+        this.raw = new Response(null, {
+            status: 200,
+            statusText: 'OK',
+            headers: this.headers,
+        });
+    }
+    get url() {
+        return this._url;
+    }
+    get timings() {
+        return this._timings;
+    }
+    get connection() {
+        return this._connection;
+    }
+    pushPacket(packet) {
+        if (this._complete) {
+            throw new Error('Cannot push to completed stream');
+        }
+        const waiter = this._waiters.shift();
+        if (waiter) {
+            waiter.resolve({ value: packet, done: false });
+        }
+        else {
+            this._packets.push(packet);
+        }
+    }
+    complete() {
+        this._complete = true;
+        for (const waiter of this._waiters) {
+            waiter.resolve({ value: undefined, done: true });
+        }
+        this._waiters = [];
+    }
+    async buffer() {
+        while (!this._complete) {
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+        return Buffer.concat(this._packets);
+    }
+    async json() {
+        const buf = await this.buffer();
+        return JSON.parse(buf.toString('utf8'));
+    }
+    async text() {
+        const buf = await this.buffer();
+        return buf.toString('utf8');
+    }
+    async cleanText() {
+        const text = await this.text();
+        return text
+            .replace(/[\x00-\x1F\x7F-\x9F]/g, ' ')
+            .replace(/\s+/g, ' ')
+            .trim();
+    }
+    async blob() {
+        const buf = await this.buffer();
+        return new Blob([new Uint8Array(buf)]);
+    }
+    read() {
+        const self = this;
+        return new ReadableStream({
+            async pull(controller) {
+                const result = await self.packets().next();
+                if (result.done) {
+                    controller.close();
+                }
+                else {
+                    controller.enqueue(new Uint8Array(result.value));
+                }
+            },
+        });
+    }
+    clone() {
+        const cloned = new StreamingUDPResponse({
+            timings: { ...this._timings },
+            connection: { ...this._connection },
+            url: this._url,
+        });
+        cloned._packets = this._packets.map((p) => Buffer.from(p));
+        cloned._complete = this._complete;
+        return cloned;
+    }
+    async *sse() {
+        throw new Error('SSE is not supported for UDP responses');
+    }
+    async *download() {
+        let loaded = 0;
+        for await (const packet of this.packets()) {
+            loaded += packet.length;
+            yield {
+                loaded,
+                transferred: loaded,
+                direction: 'download',
+            };
+        }
+    }
+    async *packets() {
+        while (true) {
+            if (this._packets.length > 0) {
+                yield this._packets.shift();
+                continue;
+            }
+            if (this._complete) {
+                return;
+            }
+            const packet = await new Promise((resolve, reject) => {
+                this._waiters.push({
+                    resolve: (result) => resolve(result.done ? null : result.value),
+                    reject,
+                });
+            });
+            if (packet === null) {
+                return;
+            }
+            yield packet;
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        for await (const packet of this.packets()) {
+            yield new Uint8Array(packet);
+        }
+    }
+}

package/dist/transport/udp.d.ts

@@ -0,0 +1,22 @@
+import type { ReckerRequest, ReckerResponse } from '../types/index.js';
+import type { UDPTransportOptions, SimpleUDPAPI } from '../types/udp.js';
+import { BaseUDPTransport } from './base-udp.js';
+export declare class UDPTransportImpl extends BaseUDPTransport {
+    private socket;
+    private baseUrl;
+    private udpOptions;
+    private multicastGroups;
+    constructor(baseUrl?: string, options?: UDPTransportOptions);
+    private getSocket;
+    private _socketBound;
+    dispatch(req: ReckerRequest): Promise<ReckerResponse>;
+    send(host: string, port: number, data: Buffer): Promise<void>;
+    broadcast(port: number, data: Buffer): Promise<void>;
+    joinMulticast(group: string): void;
+    leaveMulticast(group: string): void;
+    close(): Promise<void>;
+}
+export declare function createUDPClient(options?: UDPTransportOptions): UDPTransportImpl;
+export declare const udp: SimpleUDPAPI;
+export { UDPTransportImpl as UDPTransport };
+//# sourceMappingURL=udp.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"udp.d.ts","sourceRoot":"","sources":["../../src/transport/udp.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACvE,OAAO,KAAK,EACV,mBAAmB,EAInB,YAAY,EACb,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,gBAAgB,EAAwC,MAAM,eAAe,CAAC;AAqCvF,qBAAa,gBAAiB,SAAQ,gBAAgB;IACpD,OAAO,CAAC,MAAM,CAA6B;IAC3C,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,UAAU,CAAgC;IAClD,OAAO,CAAC,eAAe,CAA0B;gBAErC,OAAO,GAAE,MAAW,EAAE,OAAO,GAAE,mBAAwB;IAyBnE,OAAO,CAAC,SAAS;IA0CjB,OAAO,CAAC,YAAY,CAAkB;IAKhC,QAAQ,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;IAoFrD,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAyB7D,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiB1D,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAWlC,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAW7B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAqB7B;AASD,wBAAgB,eAAe,CAAC,OAAO,GAAE,mBAAwB,GAAG,gBAAgB,CAEnF;AAKD,eAAO,MAAM,GAAG,EAAE,YAuGjB,CAAC;AAGF,OAAO,EAAE,gBAAgB,IAAI,YAAY,EAAE,CAAC"}

package/dist/transport/udp.js

@@ -0,0 +1,260 @@
+import dgram from 'node:dgram';
+import { BaseUDPTransport, udpRequestStorage } from './base-udp.js';
+import { UDPResponseImpl } from './udp-response.js';
+const DEFAULT_OPTIONS = {
+    timeout: 5000,
+    retransmissions: 3,
+    maxPacketSize: 65507,
+    observability: true,
+    broadcast: false,
+    multicastTTL: 1,
+    multicastLoopback: true,
+    type: 'udp4',
+};
+export class UDPTransportImpl extends BaseUDPTransport {
+    socket = null;
+    baseUrl;
+    udpOptions;
+    multicastGroups = new Set();
+    constructor(baseUrl = '', options = {}) {
+        super(options);
+        this.baseUrl = baseUrl;
+        this.udpOptions = {
+            ...DEFAULT_OPTIONS,
+            ...options,
+            timeout: options.timeout ?? DEFAULT_OPTIONS.timeout,
+            retransmissions: options.retransmissions ?? DEFAULT_OPTIONS.retransmissions,
+            maxPacketSize: options.maxPacketSize ?? DEFAULT_OPTIONS.maxPacketSize,
+            observability: options.observability ?? DEFAULT_OPTIONS.observability,
+            localAddress: options.localAddress ?? '',
+            localPort: options.localPort ?? 0,
+            broadcast: options.broadcast ?? DEFAULT_OPTIONS.broadcast,
+            multicastTTL: options.multicastTTL ?? DEFAULT_OPTIONS.multicastTTL,
+            multicastGroups: options.multicastGroups ?? [],
+            multicastLoopback: options.multicastLoopback ?? DEFAULT_OPTIONS.multicastLoopback,
+            type: options.type ?? DEFAULT_OPTIONS.type,
+            recvBufferSize: options.recvBufferSize,
+            sendBufferSize: options.sendBufferSize,
+        };
+    }
+    getSocket() {
+        if (!this.socket) {
+            this.socket = this.createSocket(this.udpOptions.type);
+            this._socketBound = false;
+            this.socket.on('listening', () => {
+                this._socketBound = true;
+                if (this.udpOptions.broadcast) {
+                    this.socket.setBroadcast(true);
+                }
+                if (this.udpOptions.multicastTTL !== 1) {
+                    this.socket.setMulticastTTL(this.udpOptions.multicastTTL);
+                }
+                if (!this.udpOptions.multicastLoopback) {
+                    this.socket.setMulticastLoopback(false);
+                }
+                if (this.udpOptions.recvBufferSize) {
+                    this.socket.setRecvBufferSize(this.udpOptions.recvBufferSize);
+                }
+                if (this.udpOptions.sendBufferSize) {
+                    this.socket.setSendBufferSize(this.udpOptions.sendBufferSize);
+                }
+                for (const group of this.udpOptions.multicastGroups ?? []) {
+                    this.joinMulticast(group);
+                }
+            });
+            this.socket.bind(this.udpOptions.localPort, this.udpOptions.localAddress || undefined);
+        }
+        return this.socket;
+    }
+    _socketBound = false;
+    async dispatch(req) {
+        const context = {
+            startTime: performance.now(),
+            retransmissions: 0,
+        };
+        return udpRequestStorage.run(context, async () => {
+            const fullUrl = this.baseUrl ? `${this.baseUrl}${req.url}` : req.url;
+            const { host, port, path } = this.parseUrl(fullUrl);
+            if (!host || !port) {
+                throw new Error(`Invalid UDP URL: ${fullUrl}. Expected format: udp://host:port/path`);
+            }
+            let body;
+            if (req.body === null || req.body === undefined) {
+                body = Buffer.from(path);
+            }
+            else if (Buffer.isBuffer(req.body)) {
+                body = req.body;
+            }
+            else if (typeof req.body === 'string') {
+                body = Buffer.from(req.body);
+            }
+            else if (req.body instanceof ArrayBuffer) {
+                body = Buffer.from(req.body);
+            }
+            else if (ArrayBuffer.isView(req.body)) {
+                body = Buffer.from(req.body.buffer, req.body.byteOffset, req.body.byteLength);
+            }
+            else {
+                body = Buffer.from(JSON.stringify(req.body));
+            }
+            this.validatePacketSize(body);
+            const socket = this.getSocket();
+            if (!this._socketBound) {
+                await new Promise((resolve) => {
+                    socket.once('listening', () => resolve());
+                });
+            }
+            const udpReq = req;
+            const isBroadcast = udpReq.udp?.broadcast ?? this.udpOptions.broadcast;
+            const targetPort = udpReq.udp?.port ?? port;
+            const targetAddress = isBroadcast ? '255.255.255.255' : (udpReq.udp?.multicast ?? host);
+            if (isBroadcast && !this.udpOptions.broadcast) {
+                socket.setBroadcast(true);
+            }
+            const responseBuffer = await this.sendWithRetry(socket, body, targetPort, targetAddress, req.signal);
+            const timings = this.collectTimings();
+            const connection = this.collectConnection(socket);
+            return new UDPResponseImpl(responseBuffer, {
+                timings,
+                connection,
+                url: fullUrl,
+            });
+        });
+    }
+    async send(host, port, data) {
+        this.validatePacketSize(data);
+        const socket = this.getSocket();
+        if (!this._socketBound) {
+            await new Promise((resolve) => {
+                socket.once('listening', () => resolve());
+            });
+        }
+        return new Promise((resolve, reject) => {
+            socket.send(data, 0, data.length, port, host, (err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    async broadcast(port, data) {
+        const socket = this.getSocket();
+        if (!this._socketBound) {
+            await new Promise((resolve) => {
+                socket.once('listening', () => resolve());
+            });
+        }
+        socket.setBroadcast(true);
+        await this.send('255.255.255.255', port, data);
+    }
+    joinMulticast(group) {
+        const socket = this.getSocket();
+        if (!this.multicastGroups.has(group)) {
+            socket.addMembership(group);
+            this.multicastGroups.add(group);
+        }
+    }
+    leaveMulticast(group) {
+        const socket = this.getSocket();
+        if (this.multicastGroups.has(group)) {
+            socket.dropMembership(group);
+            this.multicastGroups.delete(group);
+        }
+    }
+    async close() {
+        if (this.socket) {
+            for (const group of this.multicastGroups) {
+                try {
+                    this.socket.dropMembership(group);
+                }
+                catch {
+                }
+            }
+            this.multicastGroups.clear();
+            return new Promise((resolve) => {
+                this.socket.close(() => {
+                    this.socket = null;
+                    resolve();
+                });
+            });
+        }
+    }
+}
+export function createUDPClient(options = {}) {
+    return new UDPTransportImpl('', options);
+}
+export const udp = {
+    async send(address, data, options = {}) {
+        const transport = new UDPTransportImpl('', options);
+        try {
+            const response = await transport.dispatch({
+                url: address.startsWith('udp://') ? address : `udp://${address}`,
+                method: 'GET',
+                headers: new Headers(),
+                body: new Uint8Array(data),
+                withHeader: () => ({ url: address }),
+                withBody: () => ({ url: address }),
+            });
+            return response;
+        }
+        finally {
+            await transport.close();
+        }
+    },
+    async broadcast(port, data, options = {}) {
+        const timeout = options.timeout ?? 3000;
+        const results = [];
+        const socket = dgram.createSocket({ type: options.type ?? 'udp4', reuseAddr: true });
+        return new Promise((resolve) => {
+            const startTime = performance.now();
+            socket.on('message', (msg, rinfo) => {
+                results.push({
+                    address: rinfo.address,
+                    port: rinfo.port,
+                    data: msg,
+                    latency: performance.now() - startTime,
+                });
+            });
+            socket.on('listening', () => {
+                socket.setBroadcast(true);
+                socket.send(data, 0, data.length, port, '255.255.255.255');
+            });
+            socket.bind();
+            setTimeout(() => {
+                socket.close();
+                resolve(results);
+            }, timeout);
+        });
+    },
+    async discover(group, port, data, options = {}) {
+        const timeout = options.timeout ?? 3000;
+        const results = [];
+        const socket = dgram.createSocket({ type: options.type ?? 'udp4', reuseAddr: true });
+        return new Promise((resolve) => {
+            const startTime = performance.now();
+            socket.on('message', (msg, rinfo) => {
+                results.push({
+                    address: rinfo.address,
+                    port: rinfo.port,
+                    data: msg,
+                    latency: performance.now() - startTime,
+                });
+            });
+            socket.on('listening', () => {
+                socket.addMembership(group);
+                socket.setMulticastTTL(options.multicastTTL ?? 1);
+                socket.send(data, 0, data.length, port, group);
+            });
+            socket.bind(port);
+            setTimeout(() => {
+                socket.dropMembership(group);
+                socket.close();
+                resolve(results);
+            }, timeout);
+        });
+    },
+};
+export { UDPTransportImpl as UDPTransport };