test-proxy-recorder 0.3.1 → 0.3.3

package/dist/playwright/index.d.ts

@@ -1,3 +1,3 @@
 import '@playwright/test';
-export { P as PlaywrightTestInfo, g as generateSessionId, p as playwrightProxy, s as setProxyMode, b as startRecording, c as startReplay, d as stopProxy } from '../index-CVuiglPk.js';
+export { f as ClientSideRecordingOptions, P as PlaywrightTestInfo, e as cleanupSession, g as generateSessionId, p as playwrightProxy, s as setProxyMode, b as startRecording, c as startReplay, d as stopProxy } from '../index-BlBWqSE4.js';
 import 'node:http';

package/dist/playwright/index.mjs

@@ -1,4 +1,6 @@
-// src/constants.ts
+import path from 'path';
+
+// src/playwright/index.ts
 var RECORDING_ID_HEADER = "x-test-rcrd-id";
 
 // src/types.ts
@@ -38,12 +40,34 @@ async function setProxyMode(mode, sessionId, timeout) {
       throw new Error(`Failed to set proxy mode: ${text}`);
     }
     await response.json();
-    console.log(`Proxy mode set to: ${mode} (session: ${sessionId})`);
   } catch (error) {
     console.error(`Error setting proxy mode:`, error);
     throw error;
   }
 }
+async function cleanupSession(sessionId) {
+  const proxyPort = getProxyPort();
+  try {
+    const body = {
+      cleanup: true,
+      id: sessionId
+    };
+    const response = await fetch(`http://127.0.0.1:${proxyPort}/__control`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      console.error(`Failed to cleanup session ${sessionId}:`, text);
+      throw new Error(`Failed to cleanup session: ${text}`);
+    }
+    await response.json();
+  } catch (error) {
+    console.error(`Error cleaning up session: ${sessionId}`, error);
+    throw error;
+  }
+}
 function parseSpecFilePath(specPath) {
   const folderMatch = specPath.match(/^(.+?)\/([^/]+)\.(spec|test)\.ts$/);
   if (folderMatch) {
@@ -85,6 +109,50 @@ async function stopProxy(testInfo) {
   const sessionId = generateSessionId(testInfo);
   await setProxyMode(Modes.transparent, sessionId);
 }
+var cachedRecordingsDir = null;
+async function getRecordingsDir() {
+  if (cachedRecordingsDir) {
+    return cachedRecordingsDir;
+  }
+  const proxyPort = getProxyPort();
+  try {
+    const response = await fetch(`http://127.0.0.1:${proxyPort}/__control`);
+    if (response.ok) {
+      const data = await response.json();
+      if (data.recordingsDir) {
+        cachedRecordingsDir = data.recordingsDir;
+        return cachedRecordingsDir;
+      }
+    }
+  } catch (error) {
+    console.warn(
+      "Failed to get recordings directory from proxy, using default:",
+      error
+    );
+  }
+  cachedRecordingsDir = path.join(process.cwd(), "e2e", "recordings");
+  return cachedRecordingsDir;
+}
+async function setupClientSideRecording(page, sessionId, mode, url) {
+  const harFileName = sessionId.replaceAll("/", "__");
+  const recordingsDir = await getRecordingsDir();
+  const harPath = path.join(recordingsDir, `${harFileName}.har`);
+  try {
+    await page.routeFromHAR(harPath, {
+      url,
+      update: mode === Modes.record,
+      updateContent: "embed"
+    });
+  } catch (error) {
+    if (mode === Modes.replay) {
+      console.error(
+        `[Client-Side Replay] Failed to load HAR file. Run tests in record mode first.`,
+        error
+      );
+      throw error;
+    }
+  }
+}
 var playwrightProxy = {
   /**
    * Setup before test - sets the proxy mode and configures page with custom header
@@ -92,24 +160,66 @@ var playwrightProxy = {
    * @param page - Playwright page object
    * @param testInfo - Playwright test info object
    * @param mode - The proxy mode to use for this test
-   * @param timeout - Optional timeout in milliseconds
+   * @param options - Optional configuration including timeout and client-side recording patterns
    */
-  async before(page, testInfo, mode, timeout) {
+  async before(page, testInfo, mode, options) {
+    const timeout = typeof options === "number" ? options : options?.timeout;
+    const clientSideOptions = typeof options === "object" && options !== null ? options : void 0;
     const sessionId = generateSessionId(testInfo);
     await page.setExtraHTTPHeaders({
       [RECORDING_ID_HEADER]: sessionId
     });
     await setProxyMode(mode, sessionId, timeout);
-    page.on("close", async () => {
-      try {
-        await setProxyMode(Modes.replay, sessionId);
-        console.log(
-          `[Cleanup] Switched to replay mode for session: ${sessionId}`
-        );
-      } catch (error) {
-        console.error("[Cleanup] Error during page close cleanup:", error);
-      }
-    });
+    if (clientSideOptions?.url) {
+      await setupClientSideRecording(
+        page,
+        sessionId,
+        mode,
+        clientSideOptions.url
+      );
+    }
+    const proxyPort = process.env.TEST_PROXY_RECORDER_PORT || "8100";
+    const proxyUrl = `localhost:${proxyPort}`;
+    await page.route(
+      (url) => {
+        const urlStr = url.toString();
+        const matches = urlStr.includes(proxyUrl);
+        return matches;
+      },
+      async (route) => {
+        try {
+          const headers = route.request().headers();
+          headers[RECORDING_ID_HEADER] = sessionId;
+          await route.continue({ headers });
+        } catch (error) {
+          console.error(
+            `[Route Handler Error] Failed to add ${RECORDING_ID_HEADER} header:`,
+            error
+          );
+          await route.fallback();
+        }
+      },
+      { times: Infinity }
+      // Ensure the handler applies to all matching requests
+    );
+    const context = page.context();
+    const contextId = context._guid || "default";
+    const handlerKey = `cleanup_${contextId}`;
+    if (!globalThis[handlerKey]) {
+      globalThis[handlerKey] = true;
+      context.on("close", async () => {
+        try {
+          await cleanupSession(sessionId);
+        } catch (error) {
+          console.warn(
+            `[Cleanup] Failed to cleanup session ${sessionId}:`,
+            error
+          );
+        } finally {
+          delete globalThis[handlerKey];
+        }
+      });
+    }
   },
   /**
    * Global teardown - switches proxy to transparent mode
@@ -120,6 +230,6 @@ var playwrightProxy = {
   }
 };
 
-export { generateSessionId, playwrightProxy, setProxyMode, startRecording, startReplay, stopProxy };
+export { cleanupSession, generateSessionId, playwrightProxy, setProxyMode, startRecording, startReplay, stopProxy };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/proxy.js

@@ -118,16 +118,19 @@ async function saveRecordingSession(recordingsDir2, session) {
     `Saved ${processedRecordings.length} HTTP recordings and ${session.websocketRecordings?.length || 0} WebSocket recordings to ${filePath}`
   );
 }
-function getReqID(req) {
-  const urlParts = req.url.split("?");
-  const pathname = urlParts[0];
-  const query = urlParts[1] || "";
+function generateRecordingKey(pathname, query, method) {
   const pathPart = pathname === "/" ? "root" : pathname.slice(1);
   const normalizedPath = filenamify2(pathPart, { replacement: "_" });
   const queryHash = generateQueryHash(query);
-  const filename = `${req.method}_${normalizedPath}${queryHash}.json`;
+  const filename = `${method}_${normalizedPath}${queryHash}.json`;
   return filenamify2(filename, { replacement: "_" });
 }
+function getReqID(req) {
+  const urlParts = req.url.split("?");
+  const pathname = urlParts[0];
+  const query = urlParts[1] || "";
+  return generateRecordingKey(pathname, query, req.method);
+}
 function generateQueryHash(query) {
   if (!query) {
     return "";
@@ -169,6 +172,8 @@ var ProxyServer = class {
   // Track multiple concurrent replay sessions by recording ID
   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;
@@ -182,6 +187,7 @@ var ProxyServer = class {
     this.recordingsDir = recordingsDir2;
     this.replaySessions = /* @__PURE__ */ new Map();
     this.recordingPromises = [];
+    this.flushPromise = null;
     this.proxy = httpProxy.createProxyServer({
       secure: false,
       changeOrigin: true,
@@ -280,7 +286,15 @@ var ProxyServer = class {
    * @returns The recording ID, or null if not found
    */
   getRecordingIdFromRequest(req) {
-    return this.getRecordingIdFromHeader(req) || this.getRecordingIdFromCookie(req);
+    const fromHeader = this.getRecordingIdFromHeader(req);
+    const fromCookie = this.getRecordingIdFromCookie(req);
+    if (fromHeader) {
+      return fromHeader;
+    }
+    if (fromCookie) {
+      return fromCookie;
+    }
+    return null;
   }
   /**
    * Get or create a replay session state for a given recording ID
@@ -296,7 +310,8 @@ var ProxyServer = class {
         recordingId,
         servedRecordingIdsByKey: /* @__PURE__ */ new Map(),
         loadedSession: null,
-        lastAccessTime: Date.now()
+        lastAccessTime: Date.now(),
+        sortedRecordingsByKey: /* @__PURE__ */ new Map()
       };
       this.replaySessions.set(recordingId, session);
       console.log(
@@ -305,6 +320,24 @@ var ProxyServer = class {
     }
     return session;
   }
+  /**
+   * Clean up a session - removes it from memory and resets counters
+   * @param sessionId The session ID to clean up
+   */
+  async cleanupSession(sessionId) {
+    if (this.replaySessions.has(sessionId)) {
+      this.replaySessions.delete(sessionId);
+    }
+    if (this.recordingId === sessionId) {
+      await this.saveCurrentSession();
+      this.currentSession = null;
+      this.recordingId = null;
+    }
+    if (this.replayId === sessionId) {
+      this.replayId = null;
+    }
+    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");
@@ -328,9 +361,31 @@ var ProxyServer = class {
     throw new Error("Unsupported control method");
   }
   async handleControlRequest(req, res) {
+    if (req.method === "GET") {
+      sendJsonResponse(res, HTTP_STATUS_OK, {
+        recordingsDir: this.recordingsDir,
+        mode: this.mode,
+        id: this.recordingId || this.replayId
+      });
+      return;
+    }
     try {
       const data = await this.parseControlRequest(req);
-      const { mode, id, timeout: requestTimeout } = data;
+      const { mode, id, timeout: requestTimeout, cleanup } = data;
+      if (cleanup && id) {
+        await this.cleanupSession(id);
+        sendJsonResponse(res, HTTP_STATUS_OK, {
+          success: true,
+          message: `Session ${id} cleaned up`,
+          mode: this.mode
+        });
+        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);
@@ -346,7 +401,8 @@ var ProxyServer = class {
         success: true,
         mode: this.mode,
         id: this.recordingId || this.replayId,
-        timeout
+        timeout,
+        recordingsDir: this.recordingsDir
       });
     } catch (error) {
       console.error("Control request error:", error);
@@ -411,16 +467,21 @@ var ProxyServer = class {
     this.replayId = id;
     this.recordingId = null;
     this.currentSession = null;
-    const session = this.replaySessions.get(id);
-    if (session) {
-      session.servedRecordingIdsByKey.clear();
-      console.log(`Reset served recordings tracker for session: ${id}`);
-    } else {
-      this.getOrCreateReplaySession(id);
+    const sessionState = this.getOrCreateReplaySession(id);
+    sessionState.servedRecordingIdsByKey.clear();
+    sessionState.sortedRecordingsByKey.clear();
+    const filePath = getRecordingPath(this.recordingsDir, id);
+    try {
+      sessionState.loadedSession = await loadRecordingSession(filePath);
+      console.log(`[REPLAY] Loaded recording session: ${id}`);
+    } catch (error) {
+      console.error(`[REPLAY ERROR] Failed to load session ${id}:`, error);
+      sessionState.loadedSession = null;
     }
     console.log(`Switched to replay mode with ID: ${id}`);
   }
   setupModeTimeout(timeout) {
+    clearTimeout(this.modeTimeout || 0);
     this.modeTimeout = setTimeout(async () => {
       console.log("Timeout reached, switching back to transparent mode");
       await this.saveCurrentSession();
@@ -429,21 +490,32 @@ var ProxyServer = class {
     }, timeout);
   }
   async flushPendingRecordings() {
+    if (this.flushPromise) {
+      await this.flushPromise;
+      return;
+    }
     if (this.recordingPromises.length === 0) {
       return;
     }
-    const results = await Promise.allSettled(this.recordingPromises);
-    if (this.currentSession) {
-      for (const result of results) {
-        if (result.status === "fulfilled" && result.value) {
-          this.currentSession.recordings.push(result.value);
+    this.flushPromise = (async () => {
+      try {
+        const results = await Promise.allSettled(this.recordingPromises);
+        if (this.currentSession) {
+          for (const result of results) {
+            if (result.status === "fulfilled" && result.value) {
+              this.currentSession.recordings.push(result.value);
+            }
+          }
+          console.log(
+            `Flushed ${results.length} recordings to session (total: ${this.currentSession.recordings.length})`
+          );
         }
+        this.recordingPromises = [];
+      } finally {
+        this.flushPromise = null;
       }
-      console.log(
-        `Flushed ${results.length} recordings to session (total: ${this.currentSession.recordings.length})`
-      );
-    }
-    this.recordingPromises = [];
+    })();
+    await this.flushPromise;
   }
   async saveCurrentSession() {
     if (!this.currentSession) {
@@ -456,7 +528,29 @@ var ProxyServer = class {
     await saveRecordingSession(this.recordingsDir, this.currentSession);
   }
   getRecordingIdOrError(req, res) {
-    const recordingId = this.getRecordingIdFromRequest(req) || this.replayId;
+    const recordingIdFromRequest = this.getRecordingIdFromRequest(req);
+    if (recordingIdFromRequest) {
+      return recordingIdFromRequest;
+    }
+    if (this.replaySessions.size > 1) {
+      console.warn(
+        `[CONCURRENT REPLAY WARNING] Request to ${req.method} ${req.url} is missing ${RECORDING_ID_HEADER} header/cookie. Active sessions: ${[...this.replaySessions.keys()].join(", ")}. this.replayId fallback would be: ${this.replayId} (NOT USING - could be wrong session)`
+      );
+      const corsHeaders = this.getCorsHeaders(req);
+      res.writeHead(HTTP_STATUS_BAD_REQUEST, {
+        "Content-Type": "application/json",
+        ...corsHeaders
+      });
+      res.end(
+        JSON.stringify({
+          error: "Missing recording ID in concurrent replay mode. Ensure x-test-rcrd-id header is set.",
+          activeSessions: [...this.replaySessions.keys()],
+          hint: "This usually means page.setExtraHTTPHeaders() did not apply to this request type"
+        })
+      );
+      return null;
+    }
+    const recordingId = this.replayId;
     if (!recordingId) {
       const corsHeaders = this.getCorsHeaders(req);
       res.writeHead(HTTP_STATUS_BAD_REQUEST, {
@@ -466,22 +560,30 @@ var ProxyServer = class {
       res.end(JSON.stringify({ error: "No replay session active" }));
       return null;
     }
+    console.log(
+      `[FALLBACK] Using replayId fallback for ${req.method} ${req.url} -> session: ${recordingId} (single session mode)`
+    );
     return recordingId;
   }
-  async ensureSessionLoaded(recordingId, filePath) {
-    const sessionState = this.getOrCreateReplaySession(recordingId);
-    if (!sessionState.loadedSession) {
-      sessionState.loadedSession = await loadRecordingSession(filePath);
-      console.log(`[REPLAY] Loaded recording session: ${recordingId}`);
-    }
-    return sessionState;
-  }
   getServedTracker(sessionState, key) {
     if (!sessionState.servedRecordingIdsByKey.has(key)) {
       sessionState.servedRecordingIdsByKey.set(key, /* @__PURE__ */ new Set());
     }
     return sessionState.servedRecordingIdsByKey.get(key);
   }
+  getSortedRecordings(sessionState, key) {
+    if (sessionState.sortedRecordingsByKey.has(key)) {
+      return sessionState.sortedRecordingsByKey.get(key);
+    }
+    const session = sessionState.loadedSession;
+    const sortedRecords = session.recordings.filter((r) => r.key === key && r.response).toSorted((a, b) => {
+      const aSeq = a.sequence !== void 0 ? a.sequence : a.recordingId;
+      const bSeq = b.sequence !== void 0 ? b.sequence : b.recordingId;
+      return aSeq - bSeq;
+    });
+    sessionState.sortedRecordingsByKey.set(key, sortedRecords);
+    return sortedRecords;
+  }
   selectReplayRecord(recordsWithKey, servedForThisKey, key, recordingId) {
     for (const rec of recordsWithKey) {
       if (!servedForThisKey.has(rec.recordingId)) {
@@ -502,18 +604,17 @@ var ProxyServer = class {
     const key = getReqID(req);
     const filePath = getRecordingPath(this.recordingsDir, recordingId);
     try {
-      const sessionState = await this.ensureSessionLoaded(
-        recordingId,
-        filePath
-      );
-      const session = sessionState.loadedSession;
+      const sessionState = this.getOrCreateReplaySession(recordingId);
+      if (!sessionState.loadedSession) {
+        const error = new Error(
+          `Recording session file not found: ${filePath}`
+        );
+        error.code = "ENOENT";
+        throw error;
+      }
       const servedForThisKey = this.getServedTracker(sessionState, key);
       const host = req.headers.host || "unknown";
-      const recordsWithKey = session.recordings.filter((r) => r.key === key && r.response).toSorted((a, b) => {
-        const aSeq = a.sequence !== void 0 ? a.sequence : a.recordingId;
-        const bSeq = b.sequence !== void 0 ? b.sequence : b.recordingId;
-        return aSeq - bSeq;
-      });
+      const recordsWithKey = this.getSortedRecordings(sessionState, key);
       if (recordsWithKey.length === 0) {
         const errorMsg = `No recording found for ${key} at ${req.method} ${host}${req.url}`;
         console.error(`[REPLAY ERROR] ${errorMsg} (session: ${recordingId})`);
@@ -724,7 +825,6 @@ var ProxyServer = class {
       })();
     });
     this.recordingPromises.push(recordingPromise);
-    await recordingPromise;
   }
   handleUpgrade(req, socket, head) {
     if (this.mode === Modes.replay) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "test-proxy-recorder",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "HTTP proxy server for recording and replaying network requests in testing. Works seamlessly with Playwright testing framework.",
   "type": "module",
   "main": "dist/index.mjs",