test-proxy-recorder 0.3.3 → 0.3.5

package/dist/proxy.js

@@ -8,6 +8,17 @@ import { WebSocket, WebSocketServer } from 'ws';
 import crypto from 'crypto';
 import filenamify2 from 'filenamify';
 
+// src/cli.ts
+
+// src/constants.ts
+var DEFAULT_TIMEOUT_MS = 120 * 1e3;
+var HTTP_STATUS_BAD_GATEWAY = 502;
+var HTTP_STATUS_OK = 200;
+var HTTP_STATUS_BAD_REQUEST = 400;
+var HTTP_STATUS_NOT_FOUND = 404;
+var CONTROL_ENDPOINT = "/__control";
+var RECORDING_ID_HEADER = "x-test-rcrd-id";
+
 // src/cli.ts
 var DEFAULT_PORT = 8e3;
 var DEFAULT_RECORDINGS_DIR = "./recordings";
@@ -16,8 +27,8 @@ function parseCliArgs() {
   program.name("dev-proxy").description(
     "Development proxy server with recording and replay capabilities"
   ).argument(
-    "<targets...>",
-    "Target API service URLs (e.g., http://localhost:3000)"
+    "<target>",
+    "Target API service URL (e.g., http://localhost:3000)"
   ).option(
     "-p, --port <number>",
     "Port number for the proxy server",
@@ -26,32 +37,32 @@ function parseCliArgs() {
     "-d, --dir <path>",
     "Directory to store recordings (relative to CWD)",
     DEFAULT_RECORDINGS_DIR
+  ).option(
+    "-t, --timeout <ms>",
+    "Session timeout in milliseconds",
+    String(DEFAULT_TIMEOUT_MS)
   ).action(() => {
   });
   program.parse();
-  const targets2 = program.args;
+  const target2 = program.args[0];
   const options = program.opts();
   const port2 = Number.parseInt(options.port, 10);
   if (Number.isNaN(port2) || port2 < 1025 || port2 > 65535) {
     console.error("Error: Invalid port number. Must be between 1 and 65535");
     process.exit(1);
   }
-  if (targets2.length === 0) {
+  const timeout2 = Number.parseInt(options.timeout, 10);
+  if (Number.isNaN(timeout2) || timeout2 < 0) {
+    console.error("Error: Invalid timeout. Must be a non-negative number");
+    process.exit(1);
+  }
+  if (!target2) {
     program.help();
   }
   const recordingsDir2 = path.resolve(process.cwd(), options.dir);
-  return { targets: targets2, port: port2, recordingsDir: recordingsDir2 };
+  return { target: target2, port: port2, recordingsDir: recordingsDir2, timeout: timeout2 };
 }
 
-// src/constants.ts
-var DEFAULT_TIMEOUT_MS = 120 * 1e3;
-var HTTP_STATUS_BAD_GATEWAY = 502;
-var HTTP_STATUS_OK = 200;
-var HTTP_STATUS_BAD_REQUEST = 400;
-var HTTP_STATUS_NOT_FOUND = 404;
-var CONTROL_ENDPOINT = "/__control";
-var RECORDING_ID_HEADER = "x-test-rcrd-id";
-
 // src/types.ts
 var Modes = {
   transparent: "transparent",
@@ -95,9 +106,9 @@ function processRecordings(recordings) {
   const processedRecordings = [];
   for (const [_key, keyRecordings] of recordingsByKey) {
     keyRecordings.sort((a, b) => a.recordingId - b.recordingId);
-    keyRecordings.forEach((recording, index) => {
+    for (const [index, recording] of keyRecordings.entries()) {
       processedRecordings.push({ ...recording, sequence: index });
-    });
+    }
   }
   processedRecordings.sort((a, b) => a.recordingId - b.recordingId);
   return processedRecordings;
@@ -155,8 +166,7 @@ function sendJsonResponse(res, statusCode, data) {
 
 // src/ProxyServer.ts
 var ProxyServer = class {
-  targets;
-  currentTargetIndex;
+  target;
   mode;
   recordingId;
   replayId;
@@ -164,19 +174,22 @@ var ProxyServer = class {
   proxy;
   currentSession;
   recordingsDir;
+  timeoutMs;
   recordingIdCounter;
   // Unique ID for each recording entry
   sequenceCounterByKey;
   // Sequence counter per key (endpoint)
   replaySessions;
   // Track multiple concurrent replay sessions by recording ID
+  sessionEvictionTimer;
+  // Periodic timer to evict idle replay sessions
   recordingPromises;
   // Stack of promises that resolve to completed recordings
   flushPromise;
   // Promise for in-progress flush operation
-  constructor(targets2, recordingsDir2) {
-    this.targets = targets2;
-    this.currentTargetIndex = 0;
+  constructor(target2, recordingsDir2, timeoutMs) {
+    this.target = target2;
+    this.timeoutMs = timeoutMs ?? DEFAULT_TIMEOUT_MS;
     this.mode = Modes.transparent;
     this.recordingId = null;
     this.recordingIdCounter = 0;
@@ -186,6 +199,7 @@ var ProxyServer = class {
     this.currentSession = null;
     this.recordingsDir = recordingsDir2;
     this.replaySessions = /* @__PURE__ */ new Map();
+    this.sessionEvictionTimer = null;
     this.recordingPromises = [];
     this.flushPromise = null;
     this.proxy = httpProxy.createProxyServer({
@@ -248,11 +262,6 @@ var ProxyServer = class {
     const corsHeaders = this.getCorsHeaders(req);
     Object.assign(proxyRes.headers, corsHeaders);
   }
-  getTarget() {
-    const target = this.targets[this.currentTargetIndex];
-    this.currentTargetIndex = (this.currentTargetIndex + 1) % this.targets.length;
-    return target;
-  }
   /**
    * Extract recording ID from custom HTTP header
    * Used for concurrent replay session routing, especially with Next.js
@@ -288,13 +297,7 @@ var ProxyServer = class {
   getRecordingIdFromRequest(req) {
     const fromHeader = this.getRecordingIdFromHeader(req);
     const fromCookie = this.getRecordingIdFromCookie(req);
-    if (fromHeader) {
-      return fromHeader;
-    }
-    if (fromCookie) {
-      return fromCookie;
-    }
-    return null;
+    return fromHeader ?? fromCookie ?? null;
   }
   /**
    * Get or create a replay session state for a given recording ID
@@ -314,6 +317,7 @@ var ProxyServer = class {
         sortedRecordingsByKey: /* @__PURE__ */ new Map()
       };
       this.replaySessions.set(recordingId, session);
+      this.startSessionEvictionTimer();
       console.log(
         `[CONCURRENT REPLAY] Created new session for recording: ${recordingId}`
       );
@@ -325,8 +329,9 @@ var ProxyServer = class {
    * @param sessionId The session ID to clean up
    */
   async cleanupSession(sessionId) {
-    if (this.replaySessions.has(sessionId)) {
-      this.replaySessions.delete(sessionId);
+    this.replaySessions.delete(sessionId);
+    if (this.replaySessions.size === 0) {
+      this.stopSessionEvictionTimer();
     }
     if (this.recordingId === sessionId) {
       await this.saveCurrentSession();
@@ -338,29 +343,44 @@ var ProxyServer = class {
     }
     console.log(`[CLEANUP] Session ${sessionId} cleaned up successfully`);
   }
-  parseGetParams(req) {
-    const url = new URL(req.url || "", `http://${req.headers.host}`);
-    const mode = url.searchParams.get("mode");
-    const id = url.searchParams.get("id") || void 0;
-    const timeoutParam = url.searchParams.get("timeout");
-    const timeout = timeoutParam ? Number.parseInt(timeoutParam, 10) : void 0;
-    if (!mode) {
-      throw new Error("Mode parameter is required");
+  startSessionEvictionTimer() {
+    if (this.sessionEvictionTimer) {
+      return;
     }
-    return { mode, id, timeout };
+    const CHECK_INTERVAL_MS = 3e4;
+    this.sessionEvictionTimer = setInterval(() => {
+      const now = Date.now();
+      for (const [id, session] of this.replaySessions) {
+        if (now - session.lastAccessTime >= this.timeoutMs) {
+          console.log(
+            `[EVICTION] Evicting idle replay session: ${id} (idle for ${Math.round((now - session.lastAccessTime) / 1e3)}s)`
+          );
+          this.replaySessions.delete(id);
+        }
+      }
+      if (this.replaySessions.size === 0) {
+        this.stopSessionEvictionTimer();
+      }
+    }, CHECK_INTERVAL_MS);
+    this.sessionEvictionTimer.unref();
   }
-  async parseControlRequest(req) {
-    if (req.method === "GET") {
-      return this.parseGetParams(req);
-    }
-    if (req.method === "POST") {
-      const body = await readRequestBody(req);
-      console.log(`MODE CHANGE (${req.method})`, body);
-      return JSON.parse(body);
+  stopSessionEvictionTimer() {
+    if (this.sessionEvictionTimer) {
+      clearInterval(this.sessionEvictionTimer);
+      this.sessionEvictionTimer = null;
     }
-    throw new Error("Unsupported control method");
+  }
+  async parseControlBody(req) {
+    const body = await readRequestBody(req);
+    console.log(`MODE CHANGE (${req.method})`, body);
+    return JSON.parse(body);
   }
   async handleControlRequest(req, res) {
+    if (req.method === "HEAD") {
+      res.writeHead(HTTP_STATUS_OK);
+      res.end();
+      return;
+    }
     if (req.method === "GET") {
       sendJsonResponse(res, HTTP_STATUS_OK, {
         recordingsDir: this.recordingsDir,
@@ -369,8 +389,11 @@ var ProxyServer = class {
       });
       return;
     }
+    await this.handleControlPost(req, res);
+  }
+  async handleControlPost(req, res) {
     try {
-      const data = await this.parseControlRequest(req);
+      const data = await this.parseControlBody(req);
       const { mode, id, timeout: requestTimeout, cleanup } = data;
       if (cleanup && id) {
         await this.cleanupSession(id);
@@ -381,29 +404,7 @@ var ProxyServer = class {
         });
         return;
       }
-      if (!mode) {
-        throw new Error(
-          "Mode parameter is required when cleanup is not specified"
-        );
-      }
-      const timeout = requestTimeout ?? DEFAULT_TIMEOUT_MS;
-      this.clearModeTimeout();
-      await this.switchMode(mode, id);
-      this.setupModeTimeout(timeout);
-      if (mode === Modes.replay && id) {
-        res.setHeader(
-          "Set-Cookie",
-          `proxy-recording-id=${encodeURIComponent(id)}; HttpOnly; Path=/; SameSite=Lax`
-        );
-        console.log(`[CONCURRENT REPLAY] Set cookie for recording: ${id}`);
-      }
-      sendJsonResponse(res, HTTP_STATUS_OK, {
-        success: true,
-        mode: this.mode,
-        id: this.recordingId || this.replayId,
-        timeout,
-        recordingsDir: this.recordingsDir
-      });
+      await this.applyModeChange(res, mode, id, requestTimeout);
     } catch (error) {
       console.error("Control request error:", error);
       sendJsonResponse(res, HTTP_STATUS_BAD_REQUEST, {
@@ -411,6 +412,31 @@ var ProxyServer = class {
       });
     }
   }
+  async applyModeChange(res, mode, id, requestTimeout) {
+    if (!mode) {
+      throw new Error(
+        "Mode parameter is required when cleanup is not specified"
+      );
+    }
+    const timeout2 = requestTimeout ?? this.timeoutMs;
+    this.clearModeTimeout();
+    await this.switchMode(mode, id);
+    this.setupModeTimeout(timeout2);
+    if (mode === Modes.replay && id) {
+      res.setHeader(
+        "Set-Cookie",
+        `proxy-recording-id=${encodeURIComponent(id)}; HttpOnly; Path=/; SameSite=Lax`
+      );
+      console.log(`[CONCURRENT REPLAY] Set cookie for recording: ${id}`);
+    }
+    sendJsonResponse(res, HTTP_STATUS_OK, {
+      success: true,
+      mode: this.mode,
+      id: this.recordingId || this.replayId,
+      timeout: timeout2,
+      recordingsDir: this.recordingsDir
+    });
+  }
   clearModeTimeout() {
     clearTimeout(this.modeTimeout || 0);
     this.modeTimeout = null;
@@ -450,7 +476,7 @@ var ProxyServer = class {
     this.recordingId = null;
     this.replayId = null;
     this.currentSession = null;
-    clearTimeout(this.modeTimeout || 0);
+    this.clearModeTimeout();
     console.log("Switched to transparent mode");
   }
   switchToRecordMode(id) {
@@ -480,14 +506,14 @@ var ProxyServer = class {
     }
     console.log(`Switched to replay mode with ID: ${id}`);
   }
-  setupModeTimeout(timeout) {
-    clearTimeout(this.modeTimeout || 0);
+  setupModeTimeout(timeout2) {
+    this.clearModeTimeout();
     this.modeTimeout = setTimeout(async () => {
       console.log("Timeout reached, switching back to transparent mode");
       await this.saveCurrentSession();
       this.switchToTransparentMode();
       this.modeTimeout = null;
-    }, timeout);
+    }, timeout2);
   }
   async flushPendingRecordings() {
     if (this.flushPromise) {
@@ -606,11 +632,10 @@ var ProxyServer = class {
     try {
       const sessionState = this.getOrCreateReplaySession(recordingId);
       if (!sessionState.loadedSession) {
-        const error = new Error(
-          `Recording session file not found: ${filePath}`
+        throw Object.assign(
+          new Error(`Recording session file not found: ${filePath}`),
+          { code: "ENOENT" }
         );
-        error.code = "ENOENT";
-        throw error;
       }
       const servedForThisKey = this.getServedTracker(sessionState, key);
       const host = req.headers.host || "unknown";
@@ -705,16 +730,16 @@ var ProxyServer = class {
     res.end();
   }
   async handleProxyRequest(req, res) {
-    const target = this.getTarget();
-    console.log(`[${this.mode}] ${req.method} ${req.url} -> ${target}`);
+    const target2 = this.target;
+    console.log(`[${this.mode}] ${req.method} ${req.url} -> ${target2}`);
     if (this.mode === Modes.record) {
-      await this.recordAndProxyRequest(req, res, target);
+      await this.recordAndProxyRequest(req, res, target2);
     } else {
-      this.proxy.web(req, res, { target });
+      this.proxy.web(req, res, { target: target2 });
     }
   }
   // Note: streaming requests are buffered before proxying; streaming passthrough is not yet implemented
-  async recordAndProxyRequest(req, res, target) {
+  async recordAndProxyRequest(req, res, target2) {
     if (!this.currentSession) {
       return;
     }
@@ -742,7 +767,7 @@ var ProxyServer = class {
             console.error("Error buffering request:", error);
           }
           const requestBody = Buffer.concat(chunks).toString("utf8");
-          const targetUrl = new URL(target);
+          const targetUrl = new URL(target2);
           const isHttps = targetUrl.protocol === "https:";
           const requestModule = isHttps ? https : http;
           const defaultPort = isHttps ? 443 : 80;
@@ -831,15 +856,15 @@ var ProxyServer = class {
       this.handleReplayWebSocket(req, socket);
       return;
     }
-    const target = this.getTarget();
-    console.log(`[${this.mode}] WebSocket upgrade ${req.url} -> ${target}`);
+    const target2 = this.target;
+    console.log(`[${this.mode}] WebSocket upgrade ${req.url} -> ${target2}`);
     if (this.mode === Modes.record) {
-      this.handleRecordWebSocket(req, socket, head, target);
+      this.handleRecordWebSocket(req, socket, head, target2);
     } else {
-      this.proxy.ws(req, socket, head, { target });
+      this.proxy.ws(req, socket, head, { target: target2 });
     }
   }
-  handleRecordWebSocket(req, clientSocket, head, target) {
+  handleRecordWebSocket(req, clientSocket, head, target2) {
     const url = req.url || "/";
     const key = `WS_${url.replaceAll("/", "_")}`;
     const wsRecording = {
@@ -851,7 +876,7 @@ var ProxyServer = class {
     if (this.currentSession) {
       this.currentSession.websocketRecordings.push(wsRecording);
     }
-    const backendWsUrl = `${target.replace("http", "ws")}${url}`;
+    const backendWsUrl = `${target2.replace("http", "ws")}${url}`;
     const backendWs = new WebSocket(backendWsUrl);
     const wss = new WebSocketServer({ noServer: true });
     backendWs.on("open", () => {
@@ -904,11 +929,12 @@ var ProxyServer = class {
       console.error("WebSocket server error:", err);
     });
   }
-  handleReplayWebSocket(req, socket) {
+  async handleReplayWebSocket(req, socket) {
     const url = req.url || "/";
     const key = `WS_${url.replaceAll("/", "_")}`;
     const filePath = getRecordingPath(this.recordingsDir, this.replayId);
-    loadRecordingSession(filePath).then((session) => {
+    try {
+      const session = await loadRecordingSession(filePath);
       const wsRecording = session.websocketRecordings.find(
         (r) => r.key === key
       );
@@ -974,25 +1000,25 @@ var ProxyServer = class {
           console.log("Replay WebSocket closed");
         });
       });
-    }).catch((error) => {
+    } catch (error) {
       console.error("Replay error:", error);
       socket.write("HTTP/1.1 404 Not Found\r\n\r\n");
       socket.destroy();
-    });
+    }
   }
   logServerStartup(port2) {
     console.log(`Proxy server running on http://localhost:${port2}`);
     console.log(`Mode: ${this.mode}`);
-    console.log(`Targets: ${this.targets.join(", ")}`);
+    console.log(`Target: ${this.target}`);
     console.log(
       `Control endpoint: http://localhost:${port2}${CONTROL_ENDPOINT}`
     );
   }
 };
 
-// src/proxy.ts
-var { targets, port, recordingsDir } = parseCliArgs();
-var proxy = new ProxyServer(targets, recordingsDir);
+// src/proxy-cli.ts
+var { target, port, recordingsDir, timeout } = parseCliArgs();
+var proxy = new ProxyServer(target, recordingsDir, timeout);
 await proxy.init();
 proxy.listen(port);
 console.log(`Recordings will be saved to: ${recordingsDir}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "test-proxy-recorder",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "description": "HTTP proxy server for recording and replaying network requests in testing. Works seamlessly with Playwright testing framework.",
   "type": "module",
   "main": "dist/index.mjs",
@@ -38,13 +38,18 @@
     "LICENSE"
   ],
   "pnpm": {
-    "onlyBuiltDependencies": ["esbuild"]
+    "onlyBuiltDependencies": ["esbuild", "sharp"]
   },
   "packageManager": "pnpm@10.20.0+sha512.cf9998222162dd85864d0a8102e7892e7ba4ceadebbf5a31f9c2fce48dfce317a9c53b9f6464d1ef9042cba2e02ae02a9f7c143a2b438cd93c91840f0192b9dd",
   "scripts": {
     "start": "node dist/proxy.js",
     "dev": "tsx src/proxy.ts",
     "build": "tsup",
+    "example:dev": "pnpm --filter example-nextjs16 dev",
+    "example:build": "pnpm --filter example-nextjs16 build",
+    "example:services": "pnpm build && pnpm --filter example-nextjs16 start:all",
+    "example:test:e2e": "pnpm --filter example-nextjs16 test:e2e",
+    "example:test:e2e:record": "pnpm --filter example-nextjs16 test:e2e:record",
     "prepublish": "pnpm run build && pnpm run test:run && pnpm run lint",
     "lint": "eslint src --ext .ts",
     "lint:fix": "eslint src --ext .ts --fix",
@@ -95,6 +100,7 @@
     "@playwright/test": ">=1.0.0"
   },
   "devDependencies": {
+    "@playwright/test": "^1.59.1",
     "@types/http-proxy": "^1.17.15",
     "@types/node": "^22.0.0",
     "@types/ws": "^8.18.1",