recker 1.0.79 → 1.0.80-next.70ea84d

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

@@ -1,188 +0,0 @@
-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/testing/mock-websocket-server.d.ts

@@ -1,76 +0,0 @@
-import { EventEmitter } from 'node:events';
-export interface MockWebSocketServerOptions {
-    port?: number;
-    host?: string;
-    path?: string;
-    echo?: boolean;
-    delay?: number;
-    protocols?: string[];
-    autoCloseAfter?: number;
-    dropRate?: number;
-    maxConnections?: number;
-}
-export interface MockWebSocketClient {
-    id: string;
-    socket: import('ws').WebSocket;
-    connectedAt: number;
-    messageCount: number;
-    lastMessage?: import('ws').RawData;
-    metadata: Record<string, any>;
-}
-export interface MockWebSocketMessage {
-    clientId: string;
-    data: import('ws').RawData;
-    timestamp: number;
-    isBinary: boolean;
-}
-export interface MockWebSocketStats {
-    totalConnections: number;
-    currentConnections: number;
-    totalMessages: number;
-    totalBytesSent: number;
-    totalBytesReceived: number;
-    messageLog: MockWebSocketMessage[];
-}
-export declare class MockWebSocketServer extends EventEmitter {
-    private options;
-    private httpServer;
-    private wss;
-    private clients;
-    private responses;
-    private _port;
-    private _started;
-    private clientIdCounter;
-    private stats;
-    constructor(options?: MockWebSocketServerOptions);
-    get port(): number;
-    get address(): string;
-    get url(): string;
-    get isRunning(): boolean;
-    get connectionCount(): number;
-    get statistics(): MockWebSocketStats;
-    get allClients(): MockWebSocketClient[];
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    reset(): void;
-    setResponse(pattern: string | RegExp, response: string | Buffer | ((msg: string, client: MockWebSocketClient) => string | Buffer | null)): void;
-    clearResponses(): void;
-    setEcho(enabled: boolean): void;
-    setDelay(delay: number): void;
-    setDropRate(rate: number): void;
-    getClient(id: string): MockWebSocketClient | undefined;
-    disconnectClient(id: string, code?: number, reason?: string): void;
-    disconnectAll(code?: number, reason?: string): void;
-    send(clientId: string, data: string | Buffer | object): boolean;
-    broadcast(data: string | Buffer | object): number;
-    sendToAll(data: string | Buffer | object): number;
-    simulateMessage(clientId: string, data: string | Buffer): void;
-    ping(clientId?: string): void;
-    waitForConnections(count: number, timeout?: number): Promise<MockWebSocketClient[]>;
-    waitForMessages(count: number, timeout?: number): Promise<MockWebSocketMessage[]>;
-    private handleConnection;
-    private handleMessage;
-    private getResponse;
-    static create(options?: MockWebSocketServerOptions): Promise<MockWebSocketServer>;
-}
-export declare function createMockWebSocketServer(responses?: Record<string, string>, options?: MockWebSocketServerOptions): Promise<MockWebSocketServer>;

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

@@ -1,334 +0,0 @@
-import { EventEmitter } from 'node:events';
-import { createServer } from 'node:http';
-let wsModule = null;
-let WebSocketServer;
-const WS_OPEN = 1;
-async function loadWsModule() {
-    if (wsModule)
-        return wsModule;
-    try {
-        wsModule = await import('ws');
-        WebSocketServer = wsModule.WebSocketServer;
-        return wsModule;
-    }
-    catch {
-        throw new Error('MockWebSocketServer requires the "ws" package. Install it with:\n\n' +
-            '  pnpm add ws\n' +
-            '  # or\n' +
-            '  npm install ws\n');
-    }
-}
-export class MockWebSocketServer extends EventEmitter {
-    options;
-    httpServer = null;
-    wss = null;
-    clients = new Map();
-    responses = new Map();
-    _port = 0;
-    _started = false;
-    clientIdCounter = 0;
-    stats = {
-        totalConnections: 0,
-        currentConnections: 0,
-        totalMessages: 0,
-        totalBytesSent: 0,
-        totalBytesReceived: 0,
-        messageLog: [],
-    };
-    constructor(options = {}) {
-        super();
-        this.options = {
-            port: 0,
-            host: '127.0.0.1',
-            path: '/',
-            echo: true,
-            delay: 0,
-            protocols: [],
-            autoCloseAfter: 0,
-            dropRate: 0,
-            maxConnections: 0,
-            ...options,
-        };
-    }
-    get port() {
-        return this._port;
-    }
-    get address() {
-        return this.options.host;
-    }
-    get url() {
-        return `ws://${this.options.host}:${this._port}${this.options.path}`;
-    }
-    get isRunning() {
-        return this._started;
-    }
-    get connectionCount() {
-        return this.clients.size;
-    }
-    get statistics() {
-        return { ...this.stats };
-    }
-    get allClients() {
-        return [...this.clients.values()];
-    }
-    async start() {
-        if (this._started) {
-            throw new Error('Server already started');
-        }
-        await loadWsModule();
-        return new Promise((resolve, reject) => {
-            this.httpServer = createServer();
-            this.wss = new WebSocketServer({
-                server: this.httpServer,
-                path: this.options.path,
-                handleProtocols: this.options.protocols.length > 0
-                    ? (protocols) => {
-                        for (const p of protocols) {
-                            if (this.options.protocols.includes(p)) {
-                                return p;
-                            }
-                        }
-                        return false;
-                    }
-                    : undefined,
-            });
-            this.wss.on('connection', (socket, req) => this.handleConnection(socket, req));
-            this.wss.on('error', (err) => this.emit('error', err));
-            this.httpServer.on('error', reject);
-            this.httpServer.listen(this.options.port, this.options.host, () => {
-                const addr = this.httpServer.address();
-                this._port = typeof addr === 'string' ? 0 : addr?.port ?? 0;
-                this._started = true;
-                this.emit('listening', this._port);
-                resolve();
-            });
-        });
-    }
-    async stop() {
-        if (!this._started)
-            return;
-        for (const client of this.clients.values()) {
-            client.socket.close(1001, 'Server shutting down');
-        }
-        this.clients.clear();
-        return new Promise((resolve) => {
-            this.wss?.close(() => {
-                this.httpServer?.close(() => {
-                    this._started = false;
-                    this.wss = null;
-                    this.httpServer = null;
-                    this.emit('close');
-                    resolve();
-                });
-            });
-        });
-    }
-    reset() {
-        this.responses.clear();
-        this.stats = {
-            totalConnections: 0,
-            currentConnections: 0,
-            totalMessages: 0,
-            totalBytesSent: 0,
-            totalBytesReceived: 0,
-            messageLog: [],
-        };
-        this.options.echo = true;
-        this.options.delay = 0;
-        this.options.dropRate = 0;
-        this.emit('reset');
-    }
-    setResponse(pattern, response) {
-        const key = pattern instanceof RegExp ? pattern.source : pattern;
-        this.responses.set(key, response);
-    }
-    clearResponses() {
-        this.responses.clear();
-    }
-    setEcho(enabled) {
-        this.options.echo = enabled;
-    }
-    setDelay(delay) {
-        this.options.delay = delay;
-    }
-    setDropRate(rate) {
-        this.options.dropRate = Math.max(0, Math.min(1, rate));
-    }
-    getClient(id) {
-        return this.clients.get(id);
-    }
-    disconnectClient(id, code = 1000, reason = 'Disconnected by server') {
-        const client = this.clients.get(id);
-        if (client) {
-            client.socket.close(code, reason);
-        }
-    }
-    disconnectAll(code = 1000, reason = 'Disconnected by server') {
-        for (const client of this.clients.values()) {
-            client.socket.close(code, reason);
-        }
-    }
-    send(clientId, data) {
-        const client = this.clients.get(clientId);
-        if (!client || client.socket.readyState !== WS_OPEN) {
-            return false;
-        }
-        const message = typeof data === 'object' && !Buffer.isBuffer(data)
-            ? JSON.stringify(data)
-            : data;
-        client.socket.send(message);
-        this.stats.totalBytesSent += Buffer.byteLength(message);
-        return true;
-    }
-    broadcast(data) {
-        let sent = 0;
-        for (const client of this.clients.values()) {
-            if (this.send(client.id, data)) {
-                sent++;
-            }
-        }
-        return sent;
-    }
-    sendToAll(data) {
-        return this.broadcast(data);
-    }
-    simulateMessage(clientId, data) {
-        const client = this.clients.get(clientId);
-        if (client) {
-            const rawData = Buffer.isBuffer(data) ? data : Buffer.from(data);
-            this.handleMessage(client, rawData, Buffer.isBuffer(data));
-        }
-    }
-    ping(clientId) {
-        if (clientId) {
-            const client = this.clients.get(clientId);
-            client?.socket.ping();
-        }
-        else {
-            for (const client of this.clients.values()) {
-                client.socket.ping();
-            }
-        }
-    }
-    async waitForConnections(count, timeout = 5000) {
-        const start = Date.now();
-        while (this.clients.size < count) {
-            if (Date.now() - start > timeout) {
-                throw new Error(`Timeout waiting for ${count} connections (have ${this.clients.size})`);
-            }
-            await new Promise((resolve) => setTimeout(resolve, 10));
-        }
-        return [...this.clients.values()].slice(0, count);
-    }
-    async waitForMessages(count, timeout = 5000) {
-        const start = Date.now();
-        while (this.stats.messageLog.length < count) {
-            if (Date.now() - start > timeout) {
-                throw new Error(`Timeout waiting for ${count} messages (have ${this.stats.messageLog.length})`);
-            }
-            await new Promise((resolve) => setTimeout(resolve, 10));
-        }
-        return this.stats.messageLog.slice(0, count);
-    }
-    handleConnection(socket, _req) {
-        if (this.options.maxConnections > 0 && this.clients.size >= this.options.maxConnections) {
-            socket.close(1013, 'Max connections reached');
-            return;
-        }
-        if (this.options.dropRate > 0 && Math.random() < this.options.dropRate) {
-            socket.close(1006, 'Connection dropped');
-            this.emit('dropped');
-            return;
-        }
-        const clientId = `client-${++this.clientIdCounter}`;
-        const client = {
-            id: clientId,
-            socket,
-            connectedAt: Date.now(),
-            messageCount: 0,
-            metadata: {},
-        };
-        this.clients.set(clientId, client);
-        this.stats.totalConnections++;
-        this.stats.currentConnections++;
-        this.emit('connection', client);
-        if (this.options.autoCloseAfter > 0) {
-            setTimeout(() => {
-                if (socket.readyState === WS_OPEN) {
-                    socket.close(1000, 'Auto-close timeout');
-                }
-            }, this.options.autoCloseAfter);
-        }
-        socket.on('message', (data, isBinary) => {
-            this.handleMessage(client, data, isBinary);
-        });
-        socket.on('close', (code, reason) => {
-            this.clients.delete(clientId);
-            this.stats.currentConnections--;
-            this.emit('disconnect', client, code, reason.toString());
-        });
-        socket.on('error', (err) => {
-            this.emit('clientError', client, err);
-        });
-        socket.on('ping', () => {
-            this.emit('ping', client);
-        });
-        socket.on('pong', () => {
-            this.emit('pong', client);
-        });
-    }
-    async handleMessage(client, data, isBinary) {
-        const bytes = Buffer.isBuffer(data) ? data.length : Buffer.byteLength(data.toString());
-        this.stats.totalBytesReceived += bytes;
-        this.stats.totalMessages++;
-        client.messageCount++;
-        client.lastMessage = data;
-        const message = {
-            clientId: client.id,
-            data,
-            timestamp: Date.now(),
-            isBinary,
-        };
-        this.stats.messageLog.push(message);
-        this.emit('message', message, client);
-        if (this.options.delay > 0) {
-            await new Promise((resolve) => setTimeout(resolve, this.options.delay));
-        }
-        const response = this.getResponse(data.toString(), client);
-        if (response !== null && client.socket.readyState === WS_OPEN) {
-            client.socket.send(response);
-            this.stats.totalBytesSent += Buffer.byteLength(response);
-        }
-    }
-    getResponse(msg, client) {
-        for (const [pattern, response] of this.responses) {
-            const regex = new RegExp(pattern);
-            if (regex.test(msg)) {
-                if (typeof response === 'function') {
-                    return response(msg, client);
-                }
-                return response;
-            }
-        }
-        if (this.options.echo) {
-            return msg;
-        }
-        return null;
-    }
-    static async create(options = {}) {
-        const server = new MockWebSocketServer(options);
-        await server.start();
-        return server;
-    }
-}
-export async function createMockWebSocketServer(responses, options) {
-    const server = new MockWebSocketServer(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/testing/mock-whois-server.d.ts

@@ -1,56 +0,0 @@
-import { EventEmitter } from 'node:events';
-export interface MockWhoisServerOptions {
-    port?: number;
-    host?: string;
-    delay?: number;
-}
-export interface WhoisDomainData {
-    registrar?: string;
-    registrarUrl?: string;
-    createdDate?: string;
-    updatedDate?: string;
-    expiryDate?: string;
-    status?: string[];
-    nameservers?: string[];
-    registrantName?: string;
-    registrantOrg?: string;
-    registrantEmail?: string;
-    adminEmail?: string;
-    techEmail?: string;
-    dnssec?: string;
-}
-export interface MockWhoisStats {
-    queriesReceived: number;
-    responseSent: number;
-    queryLog: Array<{
-        query: string;
-        timestamp: number;
-    }>;
-}
-export declare class MockWhoisServer extends EventEmitter {
-    private options;
-    private server;
-    private domains;
-    private started;
-    private stats;
-    constructor(options?: MockWhoisServerOptions);
-    get isRunning(): boolean;
-    get port(): number;
-    get host(): string;
-    get url(): string;
-    get statistics(): MockWhoisStats;
-    addDomain(domain: string, data: WhoisDomainData): void;
-    removeDomain(domain: string): void;
-    getDomain(domain: string): WhoisDomainData | undefined;
-    clearDomains(): void;
-    private addDefaultDomains;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    reset(): void;
-    private handleConnection;
-    private handleQuery;
-    private buildResponse;
-    private buildNotFoundResponse;
-    private buildDomainResponse;
-    static create(options?: MockWhoisServerOptions): Promise<MockWhoisServer>;
-}