recker 1.0.20-next.de24f7d → 1.0.20-next.e194d90

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

@@ -0,0 +1,298 @@
+import { EventEmitter } from 'node:events';
+import { createServer } from 'node:http';
+export class MockHttpServer extends EventEmitter {
+    options;
+    httpServer = null;
+    routes = [];
+    _port = 0;
+    _started = false;
+    stats = {
+        totalRequests: 0,
+        requestsByMethod: {},
+        requestsByPath: {},
+        requestLog: [],
+    };
+    constructor(options = {}) {
+        super();
+        this.options = {
+            port: 0,
+            host: '127.0.0.1',
+            defaultResponse: { status: 404, body: { error: 'Not Found' } },
+            delay: 0,
+            cors: true,
+            corsOrigin: '*',
+            ...options,
+        };
+    }
+    get port() {
+        return this._port;
+    }
+    get address() {
+        return this.options.host;
+    }
+    get url() {
+        return `http://${this.options.host}:${this._port}`;
+    }
+    get isRunning() {
+        return this._started;
+    }
+    get statistics() {
+        return { ...this.stats };
+    }
+    get routeCount() {
+        return this.routes.length;
+    }
+    async start() {
+        if (this._started) {
+            throw new Error('Server already started');
+        }
+        return new Promise((resolve, reject) => {
+            this.httpServer = createServer((req, res) => this.handleRequest(req, res));
+            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;
+        return new Promise((resolve) => {
+            this.httpServer?.close(() => {
+                this._started = false;
+                this.httpServer = null;
+                this.emit('close');
+                resolve();
+            });
+        });
+    }
+    reset() {
+        this.routes = [];
+        this.stats = {
+            totalRequests: 0,
+            requestsByMethod: {},
+            requestsByPath: {},
+            requestLog: [],
+        };
+        this.emit('reset');
+    }
+    route(method, path, handler, options = {}) {
+        const pattern = this.pathToRegex(path);
+        this.routes.push({
+            method: method.toUpperCase(),
+            pattern,
+            pathPattern: path,
+            handler,
+            times: options.times,
+            callCount: 0,
+        });
+        return this;
+    }
+    get(path, handler, options) {
+        return this.route('GET', path, handler, options);
+    }
+    post(path, handler, options) {
+        return this.route('POST', path, handler, options);
+    }
+    put(path, handler, options) {
+        return this.route('PUT', path, handler, options);
+    }
+    patch(path, handler, options) {
+        return this.route('PATCH', path, handler, options);
+    }
+    delete(path, handler, options) {
+        return this.route('DELETE', path, handler, options);
+    }
+    head(path, handler, options) {
+        return this.route('HEAD', path, handler, options);
+    }
+    optionsRoute(path, handler, options) {
+        return this.route('OPTIONS', path, handler, options);
+    }
+    any(path, handler, options) {
+        return this.route('*', path, handler, options);
+    }
+    removeRoute(method, path) {
+        const index = this.routes.findIndex((r) => r.method === method.toUpperCase() && r.pathPattern === path);
+        if (index >= 0) {
+            this.routes.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+    clearRoutes() {
+        this.routes = [];
+    }
+    async handleRequest(req, res) {
+        const startTime = Date.now();
+        const method = req.method?.toUpperCase() ?? 'GET';
+        const urlParts = new URL(req.url ?? '/', `http://${req.headers.host}`);
+        const path = urlParts.pathname;
+        const query = Object.fromEntries(urlParts.searchParams);
+        this.stats.totalRequests++;
+        this.stats.requestsByMethod[method] = (this.stats.requestsByMethod[method] ?? 0) + 1;
+        this.stats.requestsByPath[path] = (this.stats.requestsByPath[path] ?? 0) + 1;
+        if (this.options.cors && method === 'OPTIONS') {
+            this.sendCorsHeaders(res);
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        const body = await this.parseBody(req);
+        const mockReq = {
+            method,
+            path,
+            query,
+            headers: req.headers,
+            body,
+            raw: req,
+        };
+        this.emit('request', mockReq);
+        const route = this.findRoute(method, path);
+        let response;
+        if (route) {
+            route.callCount++;
+            if (route.times !== undefined && route.callCount > route.times) {
+                response = this.options.defaultResponse;
+            }
+            else {
+                response = typeof route.handler === 'function'
+                    ? await route.handler(mockReq)
+                    : route.handler;
+            }
+        }
+        else {
+            response = this.options.defaultResponse;
+        }
+        await this.sendResponse(res, response);
+        const duration = Date.now() - startTime;
+        this.stats.requestLog.push({
+            method,
+            path,
+            status: response.status ?? 200,
+            timestamp: startTime,
+            duration,
+        });
+        this.emit('response', mockReq, response, duration);
+    }
+    findRoute(method, path) {
+        for (const route of this.routes) {
+            if ((route.method === method || route.method === '*') && route.pattern.test(path)) {
+                return route;
+            }
+        }
+        return undefined;
+    }
+    async sendResponse(res, response) {
+        if (response.drop) {
+            res.destroy();
+            return;
+        }
+        const delay = response.delay ?? this.options.delay;
+        if (delay > 0) {
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+        if (this.options.cors) {
+            this.sendCorsHeaders(res);
+        }
+        const status = response.status ?? 200;
+        const headers = {
+            'Content-Type': 'application/json',
+            ...response.headers,
+        };
+        if (response.stream) {
+            res.writeHead(status, headers);
+            for (const chunk of response.stream.chunks) {
+                res.write(chunk);
+                await new Promise((resolve) => setTimeout(resolve, response.stream.interval));
+            }
+            res.end();
+            return;
+        }
+        let body = '';
+        if (response.body !== undefined) {
+            if (typeof response.body === 'string' || Buffer.isBuffer(response.body)) {
+                body = response.body;
+                if (typeof response.body === 'string' && !headers['Content-Type'].includes('json')) {
+                    headers['Content-Type'] = 'text/plain';
+                }
+            }
+            else {
+                body = JSON.stringify(response.body);
+            }
+        }
+        headers['Content-Length'] = String(Buffer.byteLength(body));
+        res.writeHead(status, headers);
+        res.end(body);
+    }
+    sendCorsHeaders(res) {
+        res.setHeader('Access-Control-Allow-Origin', this.options.corsOrigin);
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, PATCH, DELETE, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+        res.setHeader('Access-Control-Max-Age', '86400');
+    }
+    async parseBody(req) {
+        return new Promise((resolve) => {
+            const chunks = [];
+            req.on('data', (chunk) => chunks.push(chunk));
+            req.on('end', () => {
+                if (chunks.length === 0) {
+                    resolve(undefined);
+                    return;
+                }
+                const raw = Buffer.concat(chunks).toString('utf-8');
+                const contentType = req.headers['content-type'] ?? '';
+                if (contentType.includes('application/json')) {
+                    try {
+                        resolve(JSON.parse(raw));
+                    }
+                    catch {
+                        resolve(raw);
+                    }
+                }
+                else {
+                    resolve(raw);
+                }
+            });
+            req.on('error', () => resolve(undefined));
+        });
+    }
+    pathToRegex(path) {
+        const escaped = path.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const withParams = escaped.replace(/:(\w+)/g, '([^/]+)');
+        return new RegExp(`^${withParams}$`);
+    }
+    async waitForRequests(count, timeout = 5000) {
+        const start = Date.now();
+        while (this.stats.totalRequests < count) {
+            if (Date.now() - start > timeout) {
+                throw new Error(`Timeout waiting for ${count} requests (have ${this.stats.totalRequests})`);
+            }
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+    }
+    getCallCount(method, path) {
+        const route = this.routes.find((r) => r.method === method.toUpperCase() && r.pathPattern === path);
+        return route?.callCount ?? 0;
+    }
+    static async create(options = {}) {
+        const server = new MockHttpServer(options);
+        await server.start();
+        return server;
+    }
+}
+export async function createMockHttpServer(routes, options) {
+    const server = new MockHttpServer(options);
+    if (routes) {
+        for (const [key, response] of Object.entries(routes)) {
+            const [method, path] = key.includes(' ') ? key.split(' ') : ['GET', key];
+            server.route(method, path, response);
+        }
+    }
+    await server.start();
+    return server;
+}

package/dist/testing/mock-sse-server.d.ts

@@ -0,0 +1,76 @@
+import { EventEmitter } from 'node:events';
+import { type ServerResponse } from 'node:http';
+export interface MockSSEServerOptions {
+    port?: number;
+    host?: string;
+    path?: string;
+    retryInterval?: number;
+    sendRetry?: boolean;
+    maxConnections?: number;
+    keepAliveInterval?: number;
+    corsOrigin?: string;
+}
+export interface SSEEvent {
+    event?: string;
+    data: string;
+    id?: string;
+    retry?: number;
+}
+export interface MockSSEClient {
+    id: string;
+    response: ServerResponse;
+    connectedAt: number;
+    lastEventId?: string;
+    eventsSent: number;
+    metadata: Record<string, any>;
+}
+export interface MockSSEStats {
+    totalConnections: number;
+    currentConnections: number;
+    totalEventsSent: number;
+    eventLog: Array<{
+        event: SSEEvent;
+        timestamp: number;
+        clientCount: number;
+    }>;
+}
+export declare class MockSSEServer extends EventEmitter {
+    private options;
+    private httpServer;
+    private clients;
+    private _port;
+    private _started;
+    private clientIdCounter;
+    private periodicIntervals;
+    private keepAliveInterval;
+    private eventIdCounter;
+    private stats;
+    constructor(options?: MockSSEServerOptions);
+    get port(): number;
+    get address(): string;
+    get url(): string;
+    get isRunning(): boolean;
+    get connectionCount(): number;
+    get statistics(): MockSSEStats;
+    get allClients(): MockSSEClient[];
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    reset(): void;
+    sendEvent(event: SSEEvent): number;
+    sendEventTo(clientId: string, event: SSEEvent): boolean;
+    sendData(data: string, event?: string): number;
+    sendJSON(data: any, event?: string): number;
+    sendComment(comment: string): void;
+    startPeriodicEvents(eventType: string, intervalMs: number, dataGenerator?: () => string): void;
+    stopPeriodicEvents(eventType?: string): void;
+    getClient(id: string): MockSSEClient | undefined;
+    disconnectClient(id: string): void;
+    disconnectAll(): void;
+    waitForConnections(count: number, timeout?: number): Promise<MockSSEClient[]>;
+    private handleRequest;
+    private formatEvent;
+    private writeToClient;
+    nextEventId(): string;
+    static create(options?: MockSSEServerOptions): Promise<MockSSEServer>;
+}
+export declare function createMockSSEServer(options?: MockSSEServerOptions): Promise<MockSSEServer>;

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

@@ -0,0 +1,291 @@
+import { EventEmitter } from 'node:events';
+import { createServer } from 'node:http';
+export class MockSSEServer extends EventEmitter {
+    options;
+    httpServer = null;
+    clients = new Map();
+    _port = 0;
+    _started = false;
+    clientIdCounter = 0;
+    periodicIntervals = new Map();
+    keepAliveInterval = null;
+    eventIdCounter = 0;
+    stats = {
+        totalConnections: 0,
+        currentConnections: 0,
+        totalEventsSent: 0,
+        eventLog: [],
+    };
+    constructor(options = {}) {
+        super();
+        this.options = {
+            port: 0,
+            host: '127.0.0.1',
+            path: '/events',
+            retryInterval: 3000,
+            sendRetry: true,
+            maxConnections: 0,
+            keepAliveInterval: 15000,
+            corsOrigin: '*',
+            ...options,
+        };
+    }
+    get port() {
+        return this._port;
+    }
+    get address() {
+        return this.options.host;
+    }
+    get url() {
+        return `http://${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');
+        }
+        return new Promise((resolve, reject) => {
+            this.httpServer = createServer((req, res) => this.handleRequest(req, res));
+            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;
+                if (this.options.keepAliveInterval > 0) {
+                    this.keepAliveInterval = setInterval(() => {
+                        this.sendComment('keep-alive');
+                    }, this.options.keepAliveInterval);
+                }
+                this.emit('listening', this._port);
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        if (!this._started)
+            return;
+        if (this.keepAliveInterval) {
+            clearInterval(this.keepAliveInterval);
+            this.keepAliveInterval = null;
+        }
+        for (const interval of this.periodicIntervals.values()) {
+            clearInterval(interval);
+        }
+        this.periodicIntervals.clear();
+        for (const client of this.clients.values()) {
+            client.response.end();
+        }
+        this.clients.clear();
+        return new Promise((resolve) => {
+            this.httpServer?.close(() => {
+                this._started = false;
+                this.httpServer = null;
+                this.emit('close');
+                resolve();
+            });
+        });
+    }
+    reset() {
+        this.stats = {
+            totalConnections: 0,
+            currentConnections: 0,
+            totalEventsSent: 0,
+            eventLog: [],
+        };
+        this.eventIdCounter = 0;
+        for (const interval of this.periodicIntervals.values()) {
+            clearInterval(interval);
+        }
+        this.periodicIntervals.clear();
+        this.emit('reset');
+    }
+    sendEvent(event) {
+        let sent = 0;
+        const formatted = this.formatEvent(event);
+        for (const client of this.clients.values()) {
+            if (this.writeToClient(client, formatted)) {
+                client.eventsSent++;
+                sent++;
+            }
+        }
+        this.stats.totalEventsSent += sent;
+        this.stats.eventLog.push({
+            event,
+            timestamp: Date.now(),
+            clientCount: sent,
+        });
+        this.emit('event', event, sent);
+        return sent;
+    }
+    sendEventTo(clientId, event) {
+        const client = this.clients.get(clientId);
+        if (!client)
+            return false;
+        const formatted = this.formatEvent(event);
+        if (this.writeToClient(client, formatted)) {
+            client.eventsSent++;
+            this.stats.totalEventsSent++;
+            return true;
+        }
+        return false;
+    }
+    sendData(data, event) {
+        return this.sendEvent({ data, event });
+    }
+    sendJSON(data, event) {
+        return this.sendEvent({ data: JSON.stringify(data), event });
+    }
+    sendComment(comment) {
+        const formatted = `: ${comment}\n\n`;
+        for (const client of this.clients.values()) {
+            this.writeToClient(client, formatted);
+        }
+    }
+    startPeriodicEvents(eventType, intervalMs, dataGenerator) {
+        if (this.periodicIntervals.has(eventType)) {
+            clearInterval(this.periodicIntervals.get(eventType));
+        }
+        const interval = setInterval(() => {
+            const data = dataGenerator?.() ?? new Date().toISOString();
+            this.sendEvent({ event: eventType, data });
+        }, intervalMs);
+        this.periodicIntervals.set(eventType, interval);
+    }
+    stopPeriodicEvents(eventType) {
+        if (eventType) {
+            const interval = this.periodicIntervals.get(eventType);
+            if (interval) {
+                clearInterval(interval);
+                this.periodicIntervals.delete(eventType);
+            }
+        }
+        else {
+            for (const interval of this.periodicIntervals.values()) {
+                clearInterval(interval);
+            }
+            this.periodicIntervals.clear();
+        }
+    }
+    getClient(id) {
+        return this.clients.get(id);
+    }
+    disconnectClient(id) {
+        const client = this.clients.get(id);
+        if (client) {
+            client.response.end();
+            this.clients.delete(id);
+            this.stats.currentConnections--;
+            this.emit('disconnect', client);
+        }
+    }
+    disconnectAll() {
+        for (const client of this.clients.values()) {
+            client.response.end();
+        }
+        this.clients.clear();
+        this.stats.currentConnections = 0;
+    }
+    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);
+    }
+    handleRequest(req, res) {
+        if (req.method !== 'GET' || req.url !== this.options.path) {
+            res.writeHead(404);
+            res.end('Not Found');
+            return;
+        }
+        if (this.options.maxConnections > 0 && this.clients.size >= this.options.maxConnections) {
+            res.writeHead(503);
+            res.end('Max connections reached');
+            return;
+        }
+        const lastEventId = req.headers['last-event-id'];
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+            'Access-Control-Allow-Origin': this.options.corsOrigin,
+            'X-Accel-Buffering': 'no',
+        });
+        if (this.options.sendRetry) {
+            res.write(`retry: ${this.options.retryInterval}\n\n`);
+        }
+        const clientId = `sse-client-${++this.clientIdCounter}`;
+        const client = {
+            id: clientId,
+            response: res,
+            connectedAt: Date.now(),
+            lastEventId,
+            eventsSent: 0,
+            metadata: {},
+        };
+        this.clients.set(clientId, client);
+        this.stats.totalConnections++;
+        this.stats.currentConnections++;
+        this.emit('connection', client);
+        req.on('close', () => {
+            this.clients.delete(clientId);
+            this.stats.currentConnections--;
+            this.emit('disconnect', client);
+        });
+        res.on('error', (err) => {
+            this.emit('clientError', client, err);
+            this.clients.delete(clientId);
+            this.stats.currentConnections--;
+        });
+    }
+    formatEvent(event) {
+        const lines = [];
+        if (event.id) {
+            lines.push(`id: ${event.id}`);
+        }
+        if (event.event) {
+            lines.push(`event: ${event.event}`);
+        }
+        if (event.retry !== undefined) {
+            lines.push(`retry: ${event.retry}`);
+        }
+        const dataLines = event.data.split('\n');
+        for (const line of dataLines) {
+            lines.push(`data: ${line}`);
+        }
+        return lines.join('\n') + '\n\n';
+    }
+    writeToClient(client, data) {
+        try {
+            return client.response.write(data);
+        }
+        catch {
+            return false;
+        }
+    }
+    nextEventId() {
+        return String(++this.eventIdCounter);
+    }
+    static async create(options = {}) {
+        const server = new MockSSEServer(options);
+        await server.start();
+        return server;
+    }
+}
+export async function createMockSSEServer(options) {
+    return MockSSEServer.create(options);
+}