recker 1.0.79 → 1.0.80-next.70ea84d

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

@@ -1,343 +0,0 @@
-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);
-    }
-    trace(path, handler, options) {
-        return this.route('TRACE', path, handler, options);
-    }
-    connect(path, handler, options) {
-        return this.route('CONNECT', path, handler, options);
-    }
-    purge(path, handler, options) {
-        return this.route('PURGE', 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;
-}
-export async function createWebhookServer(options = {}) {
-    const { log = true, logger, status = 204, ...serverOptions } = options;
-    const server = new MockHttpServer(serverOptions);
-    const webhooks = [];
-    const handleWebhook = (req, id) => {
-        const payload = {
-            id,
-            timestamp: new Date(),
-            method: req.method,
-            path: req.path,
-            headers: req.headers,
-            body: req.body,
-        };
-        webhooks.push(payload);
-        if (logger) {
-            logger(payload);
-        }
-        else if (log) {
-            const idStr = id ? ` [${id}]` : '';
-            console.log(`\n📥 Webhook received${idStr} at ${payload.timestamp.toISOString()}`);
-            console.log(`   Path: ${req.path}`);
-            if (req.body !== undefined) {
-                console.log(`   Body:`, typeof req.body === 'object' ? JSON.stringify(req.body, null, 2) : req.body);
-            }
-        }
-        return { status };
-    };
-    server.any('/', (req) => handleWebhook(req, null));
-    server.any('/:id', (req) => {
-        const match = req.path.match(/^\/([^/]+)$/);
-        const id = match ? match[1] : null;
-        return handleWebhook(req, id);
-    });
-    await server.start();
-    return Object.assign(server, { webhooks });
-}

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

@@ -1,108 +0,0 @@
-import { EventEmitter } from 'node:events';
-export type ProxyMode = 'forward' | 'intercept';
-export interface ProxyServerOptions {
-    port?: number;
-    host?: string;
-    mode?: ProxyMode;
-    mtls?: {
-        enabled: boolean;
-        caCert?: string;
-        caKey?: string;
-        clientCert?: string;
-        clientKey?: string;
-        requireClientCert?: boolean;
-    };
-    intercept?: {
-        logPayloads?: boolean;
-        maxPayloadSize?: number;
-        modifyRequest?: (req: ProxyRequest) => ProxyRequest | Promise<ProxyRequest>;
-        modifyResponse?: (res: ProxyResponse) => ProxyResponse | Promise<ProxyResponse>;
-    };
-    timeout?: number;
-    verbose?: boolean;
-}
-export interface ProxyRequest {
-    id: string;
-    timestamp: number;
-    method: string;
-    url: string;
-    headers: Record<string, string>;
-    body?: Buffer;
-    clientIp: string;
-    targetHost: string;
-    targetPort: number;
-    isHttps: boolean;
-}
-export interface ProxyResponse {
-    id: string;
-    timestamp: number;
-    statusCode: number;
-    statusText: string;
-    headers: Record<string, string>;
-    body?: Buffer;
-    latency: number;
-    size: number;
-}
-export interface ProxyError {
-    requestId?: string;
-    type: 'connection' | 'timeout' | 'tls' | 'upstream' | 'parse';
-    message: string;
-    error?: Error;
-    targetHost?: string;
-    targetPort?: number;
-}
-export interface ProxyStats {
-    totalRequests: number;
-    successCount: number;
-    errorCount: number;
-    bytesIn: number;
-    bytesOut: number;
-    avgLatency: number;
-    requestsPerSecond: number;
-    activeConnections: number;
-    byStatusCode: Record<number, number>;
-    byMethod: Record<string, number>;
-    topHosts: Array<{
-        host: string;
-        count: number;
-    }>;
-}
-export declare class MockProxyServer extends EventEmitter {
-    private options;
-    private httpServer;
-    private _port;
-    private _started;
-    private _stats;
-    private hostCounts;
-    private latencies;
-    private requestTimestamps;
-    private activeConnections;
-    private certCache;
-    constructor(options?: ProxyServerOptions);
-    get port(): number;
-    get address(): string;
-    get url(): string;
-    get isRunning(): boolean;
-    get mode(): ProxyMode;
-    get stats(): ProxyStats;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    reset(): void;
-    private handleHttpRequest;
-    private forwardHttpRequest;
-    private handleConnect;
-    private tunnel;
-    private intercept;
-    private handleInterceptedConnection;
-    private forwardInterceptedRequest;
-    private getCertificateForHost;
-    private sendError;
-    private emitError;
-    private updateStats;
-    private updateLatency;
-    private headersToRecord;
-    private readBody;
-    static create(options?: ProxyServerOptions): Promise<MockProxyServer>;
-}
-export declare function createForwardProxy(port?: number, options?: Omit<ProxyServerOptions, 'port' | 'mode'>): Promise<MockProxyServer>;
-export declare function createInterceptProxy(port?: number, options?: Omit<ProxyServerOptions, 'port' | 'mode'>): Promise<MockProxyServer>;