test-proxy-recorder 0.1.2 → 0.1.4

package/dist/index-De4mgziH.d.cts

@@ -0,0 +1,96 @@
+import { TestInfo } from '@playwright/test';
+import http from 'node:http';
+
+declare const Modes: {
+    readonly transparent: "transparent";
+    readonly record: "record";
+    readonly replay: "replay";
+};
+type Mode = (typeof Modes)[keyof typeof Modes];
+interface ControlRequest {
+    mode: Mode;
+    id?: string;
+    timeout?: number;
+}
+interface RecordedRequest {
+    method: string;
+    url: string;
+    headers: http.IncomingHttpHeaders;
+    body: string | null;
+}
+interface RecordedResponse {
+    statusCode: number;
+    headers: http.IncomingHttpHeaders;
+    body: string | null;
+}
+interface Recording {
+    request: RecordedRequest;
+    response?: RecordedResponse;
+    timestamp: string;
+    key: string;
+    sequence: number;
+}
+interface WebSocketMessage {
+    direction: 'client-to-server' | 'server-to-client';
+    data: string;
+    timestamp: string;
+}
+interface WebSocketRecording {
+    url: string;
+    messages: WebSocketMessage[];
+    timestamp: string;
+    key: string;
+}
+interface RecordingSession {
+    id: string;
+    recordings: Recording[];
+    websocketRecordings: WebSocketRecording[];
+}
+
+type PlaywrightTestInfo = Pick<TestInfo, 'title'>;
+/**
+ * Set the proxy mode for a given session
+ * @param mode - The proxy mode to set (recording, replay, transparent)
+ * @param sessionId - Unique identifier for the session
+ * @param timeout - Optional timeout in milliseconds
+ */
+declare function setProxyMode(mode: Mode, sessionId?: string, timeout?: number): Promise<void>;
+/**
+ * Generate a session ID from test info
+ * @param testInfo - Playwright test info object
+ */
+declare function generateSessionId(testInfo: PlaywrightTestInfo): string;
+/**
+ * Start recording for a test
+ * @param testInfo - Playwright test info object
+ */
+declare function startRecording(testInfo: PlaywrightTestInfo): Promise<void>;
+/**
+ * Start replay for a test
+ * @param testInfo - Playwright test info object
+ */
+declare function startReplay(testInfo: PlaywrightTestInfo): Promise<void>;
+/**
+ * Stop recording/replay and return to transparent mode
+ * @param testInfo - Playwright test info object
+ */
+declare function stopProxy(testInfo: PlaywrightTestInfo): Promise<void>;
+/**
+ * Playwright test fixture helper for managing proxy mode
+ * Use this in beforeEach/afterEach hooks
+ */
+declare const playwrightProxy: {
+    /**
+     * Setup before test - sets the proxy mode
+     * @param testInfo - Playwright test info object
+     * @param mode - The proxy mode to use for this test
+     */
+    before(testInfo: PlaywrightTestInfo, mode: Mode): Promise<void>;
+    /**
+     * Cleanup after test - returns to transparent mode
+     * @param testInfo - Playwright test info object
+     */
+    after(testInfo: PlaywrightTestInfo): Promise<void>;
+};
+
+export { type ControlRequest as C, type Mode as M, type PlaywrightTestInfo as P, type Recording as R, type WebSocketRecording as W, type RecordingSession as a, startRecording as b, startReplay as c, stopProxy as d, generateSessionId as g, playwrightProxy as p, setProxyMode as s };

package/dist/index-De4mgziH.d.ts

@@ -0,0 +1,96 @@
+import { TestInfo } from '@playwright/test';
+import http from 'node:http';
+
+declare const Modes: {
+    readonly transparent: "transparent";
+    readonly record: "record";
+    readonly replay: "replay";
+};
+type Mode = (typeof Modes)[keyof typeof Modes];
+interface ControlRequest {
+    mode: Mode;
+    id?: string;
+    timeout?: number;
+}
+interface RecordedRequest {
+    method: string;
+    url: string;
+    headers: http.IncomingHttpHeaders;
+    body: string | null;
+}
+interface RecordedResponse {
+    statusCode: number;
+    headers: http.IncomingHttpHeaders;
+    body: string | null;
+}
+interface Recording {
+    request: RecordedRequest;
+    response?: RecordedResponse;
+    timestamp: string;
+    key: string;
+    sequence: number;
+}
+interface WebSocketMessage {
+    direction: 'client-to-server' | 'server-to-client';
+    data: string;
+    timestamp: string;
+}
+interface WebSocketRecording {
+    url: string;
+    messages: WebSocketMessage[];
+    timestamp: string;
+    key: string;
+}
+interface RecordingSession {
+    id: string;
+    recordings: Recording[];
+    websocketRecordings: WebSocketRecording[];
+}
+
+type PlaywrightTestInfo = Pick<TestInfo, 'title'>;
+/**
+ * Set the proxy mode for a given session
+ * @param mode - The proxy mode to set (recording, replay, transparent)
+ * @param sessionId - Unique identifier for the session
+ * @param timeout - Optional timeout in milliseconds
+ */
+declare function setProxyMode(mode: Mode, sessionId?: string, timeout?: number): Promise<void>;
+/**
+ * Generate a session ID from test info
+ * @param testInfo - Playwright test info object
+ */
+declare function generateSessionId(testInfo: PlaywrightTestInfo): string;
+/**
+ * Start recording for a test
+ * @param testInfo - Playwright test info object
+ */
+declare function startRecording(testInfo: PlaywrightTestInfo): Promise<void>;
+/**
+ * Start replay for a test
+ * @param testInfo - Playwright test info object
+ */
+declare function startReplay(testInfo: PlaywrightTestInfo): Promise<void>;
+/**
+ * Stop recording/replay and return to transparent mode
+ * @param testInfo - Playwright test info object
+ */
+declare function stopProxy(testInfo: PlaywrightTestInfo): Promise<void>;
+/**
+ * Playwright test fixture helper for managing proxy mode
+ * Use this in beforeEach/afterEach hooks
+ */
+declare const playwrightProxy: {
+    /**
+     * Setup before test - sets the proxy mode
+     * @param testInfo - Playwright test info object
+     * @param mode - The proxy mode to use for this test
+     */
+    before(testInfo: PlaywrightTestInfo, mode: Mode): Promise<void>;
+    /**
+     * Cleanup after test - returns to transparent mode
+     * @param testInfo - Playwright test info object
+     */
+    after(testInfo: PlaywrightTestInfo): Promise<void>;
+};
+
+export { type ControlRequest as C, type Mode as M, type PlaywrightTestInfo as P, type Recording as R, type WebSocketRecording as W, type RecordingSession as a, startRecording as b, startReplay as c, stopProxy as d, generateSessionId as g, playwrightProxy as p, setProxyMode as s };

package/dist/index.cjs

@@ -2,16 +2,20 @@
 
 var fs = require('fs/promises');
 var http = require('http');
+var https = require('https');
 var httpProxy = require('http-proxy');
 var ws = require('ws');
 var path = require('path');
+var filenamify = require('filenamify');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var fs__default = /*#__PURE__*/_interopDefault(fs);
 var http__default = /*#__PURE__*/_interopDefault(http);
+var https__default = /*#__PURE__*/_interopDefault(https);
 var httpProxy__default = /*#__PURE__*/_interopDefault(httpProxy);
 var path__default = /*#__PURE__*/_interopDefault(path);
+var filenamify__default = /*#__PURE__*/_interopDefault(filenamify);
 
 // src/ProxyServer.ts
 
@@ -47,6 +51,24 @@ async function saveRecordingSession(recordingsDir, session) {
     `Saved ${session.recordings.length} HTTP recordings and ${session.websocketRecordings?.length || 0} WebSocket recordings to ${filePath}`
   );
 }
+var QUERY_HASH_LENGTH = 8;
+function getReqID(req) {
+  const urlParts = req.url.split("?");
+  const pathname = urlParts[0];
+  const query = urlParts[1] || "";
+  const pathPart = pathname === "/" ? "root" : pathname.slice(1);
+  const normalizedPath = filenamify__default.default(pathPart, { replacement: "_" });
+  const queryHash = generateQueryHash(query);
+  const filename = `${req.method}_${normalizedPath}${queryHash}.json`;
+  return filenamify__default.default(filename, { replacement: "_" });
+}
+function generateQueryHash(query) {
+  if (!query) {
+    return "";
+  }
+  const hash = Buffer.from(query).toString("base64").replaceAll(/[^a-zA-Z0-9]/g, "").slice(0, Math.max(0, QUERY_HASH_LENGTH));
+  return `_${hash}`;
+}
 
 // src/utils/httpHelpers.ts
 var CONTENT_TYPE_JSON = "application/json";
@@ -62,28 +84,6 @@ function sendJsonResponse(res, statusCode, data) {
   res.end(JSON.stringify(data));
 }
 
-// src/utils/requestKeyGenerator.ts
-var QUERY_HASH_LENGTH = 8;
-function generateRequestKey(req) {
-  const urlParts = req.url.split("?");
-  const pathname = urlParts[0];
-  const query = urlParts[1] || "";
-  const normalizedPath = normalizePathname(pathname);
-  const queryHash = generateQueryHash(query);
-  return `${req.method}_${normalizedPath}${queryHash}.json`;
-}
-function normalizePathname(pathname) {
-  const normalized = pathname.replaceAll("/", "_").replace(/^_/, "");
-  return normalized || "root";
-}
-function generateQueryHash(query) {
-  if (!query) {
-    return "";
-  }
-  const hash = Buffer.from(query).toString("base64").replaceAll(/[^a-zA-Z0-9]/g, "").slice(0, Math.max(0, QUERY_HASH_LENGTH));
-  return `_${hash}`;
-}
-
 // src/ProxyServer.ts
 var ProxyServer = class {
   targets;
@@ -95,6 +95,10 @@ var ProxyServer = class {
   proxy;
   currentSession;
   recordingsDir;
+  requestSequenceMap;
+  // Track sequence per request key
+  replaySequenceMap;
+  // Track replay position per request key
   constructor(targets, recordingsDir) {
     this.targets = targets;
     this.currentTargetIndex = 0;
@@ -104,6 +108,8 @@ var ProxyServer = class {
     this.modeTimeout = null;
     this.currentSession = null;
     this.recordingsDir = recordingsDir;
+    this.requestSequenceMap = /* @__PURE__ */ new Map();
+    this.replaySequenceMap = /* @__PURE__ */ new Map();
     this.proxy = httpProxy__default.default.createProxyServer({
       secure: false,
       changeOrigin: true
@@ -142,10 +148,19 @@ var ProxyServer = class {
     res.end(JSON.stringify({ error: "Proxy error", message: err.message }));
   }
   handleProxyResponse(proxyRes, req) {
+    this.addCorsHeaders(proxyRes, req);
     if (this.mode === Modes.record && this.recordingId) {
       this.recordResponse(req, proxyRes);
     }
   }
+  addCorsHeaders(proxyRes, req) {
+    const origin = req.headers.origin;
+    proxyRes.headers["access-control-allow-origin"] = origin || "*";
+    proxyRes.headers["access-control-allow-credentials"] = "true";
+    proxyRes.headers["access-control-allow-headers"] = req.headers["access-control-request-headers"] || "Origin, X-Requested-With, Content-Type, Accept, Authorization";
+    proxyRes.headers["access-control-allow-methods"] = "GET, POST, PUT, DELETE, PATCH, OPTIONS";
+    proxyRes.headers["access-control-expose-headers"] = "*";
+  }
   getTarget() {
     const target = this.targets[this.currentTargetIndex];
     this.currentTargetIndex = (this.currentTargetIndex + 1) % this.targets.length;
@@ -209,6 +224,7 @@ var ProxyServer = class {
     this.recordingId = null;
     this.replayId = null;
     this.currentSession = null;
+    clearTimeout(this.modeTimeout || 0);
     console.log("Switched to transparent mode");
   }
   switchToRecordMode(id) {
@@ -219,6 +235,7 @@ var ProxyServer = class {
     this.recordingId = id;
     this.replayId = null;
     this.currentSession = { id, recordings: [], websocketRecordings: [] };
+    this.requestSequenceMap.clear();
     console.log(`Switched to record mode with ID: ${id}`);
   }
   switchToReplayMode(id) {
@@ -229,6 +246,7 @@ var ProxyServer = class {
     this.replayId = id;
     this.recordingId = null;
     this.currentSession = null;
+    this.replaySequenceMap.clear();
     console.log(`Switched to replay mode with ID: ${id}`);
   }
   setupModeTimeout(timeout) {
@@ -259,7 +277,9 @@ var ProxyServer = class {
     if (!this.currentSession) {
       return;
     }
-    const key = generateRequestKey(req);
+    const key = getReqID(req);
+    const currentSequence = this.requestSequenceMap.get(key) || 0;
+    this.requestSequenceMap.set(key, currentSequence + 1);
     const record = {
       request: {
         method: req.method,
@@ -268,7 +288,8 @@ var ProxyServer = class {
         body: body || null
       },
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      key
+      key,
+      sequence: currentSequence
     };
     this.currentSession.recordings.push(record);
   }
@@ -276,8 +297,10 @@ var ProxyServer = class {
     if (!this.currentSession) {
       return;
     }
-    const key = generateRequestKey(req);
-    const record = this.currentSession.recordings.find((r) => r.key === key);
+    const key = getReqID(req);
+    const record = this.currentSession.recordings.findLast(
+      (r) => r.key === key && !r.response
+    );
     if (!record) {
       console.error("Request record not found for response:", key);
       return;
@@ -298,21 +321,35 @@ var ProxyServer = class {
     });
   }
   async handleReplayRequest(req, res) {
-    const key = generateRequestKey(req);
+    const key = getReqID(req);
     const filePath = getRecordingPath(this.recordingsDir, this.replayId);
     try {
       const session = await loadRecordingSession(filePath);
-      const record = session.recordings.find((r) => r.key === key);
+      const currentSequence = this.replaySequenceMap.get(key) || 0;
+      const record = session.recordings.find(
+        (r) => r.key === key && r.sequence === currentSequence
+      );
       if (!record) {
-        throw new Error(`No recording found for ${key}`);
+        throw new Error(
+          `No recording found for ${key} with sequence ${currentSequence}`
+        );
       }
       if (!record.response) {
         throw new Error("No response recorded for this request");
       }
+      this.replaySequenceMap.set(key, currentSequence + 1);
       const { statusCode, headers, body } = record.response;
-      res.writeHead(statusCode, headers);
+      const origin = req.headers.origin;
+      const responseHeaders = {
+        ...headers,
+        "access-control-allow-origin": origin || "*",
+        "access-control-allow-credentials": "true"
+      };
+      res.writeHead(statusCode, responseHeaders);
       res.end(body);
-      console.log(`Replayed: ${req.method} ${req.url}`);
+      console.log(
+        `Replayed: ${req.method} ${req.url} (sequence: ${currentSequence})`
+      );
     } catch (error) {
       this.handleReplayError(res, error, key, filePath);
     }
@@ -328,6 +365,9 @@ var ProxyServer = class {
     });
   }
   async handleRequest(req, res) {
+    if (req.method === "OPTIONS") {
+      return this.handleCorsPreflightRequest(req, res);
+    }
     if (req.url === CONTROL_ENDPOINT) {
       return this.handleControlRequest(req, res);
     }
@@ -336,23 +376,63 @@ var ProxyServer = class {
     }
     await this.handleProxyRequest(req, res);
   }
+  handleCorsPreflightRequest(req, res) {
+    const origin = req.headers.origin;
+    res.writeHead(HTTP_STATUS_OK, {
+      "Access-Control-Allow-Origin": origin || "*",
+      "Access-Control-Allow-Credentials": "true",
+      "Access-Control-Allow-Headers": req.headers["access-control-request-headers"] || "Origin, X-Requested-With, Content-Type, Accept, Authorization",
+      "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
+      "Access-Control-Max-Age": "86400"
+      // 24 hours
+    });
+    res.end();
+  }
   async handleProxyRequest(req, res) {
     const target = this.getTarget();
     console.log(`[${this.mode}] ${req.method} ${req.url} -> ${target}`);
     if (this.mode === Modes.record) {
-      await this.bufferRequestForRecord(req);
+      await this.bufferAndProxyRequest(req, res, target);
+    } else {
+      this.proxy.web(req, res, { target });
     }
-    this.proxy.web(req, res, { target });
   }
-  async bufferRequestForRecord(req) {
+  async bufferAndProxyRequest(req, res, target) {
     const chunks = [];
     req.on("data", (chunk) => {
       chunks.push(chunk);
     });
-    req.on("end", async () => {
-      const body = Buffer.concat(chunks).toString("utf8");
-      await this.saveRequestRecord(req, body);
+    await new Promise((resolve) => {
+      req.on("end", () => resolve());
     });
+    const body = Buffer.concat(chunks).toString("utf8");
+    await this.saveRequestRecord(req, body);
+    const targetUrl = new URL(target);
+    const isHttps = targetUrl.protocol === "https:";
+    const requestModule = isHttps ? https__default.default : http__default.default;
+    const defaultPort = isHttps ? 443 : 80;
+    const proxyReq = requestModule.request(
+      {
+        hostname: targetUrl.hostname,
+        port: targetUrl.port || defaultPort,
+        path: req.url,
+        method: req.method,
+        headers: req.headers
+      },
+      (proxyRes) => {
+        this.addCorsHeaders(proxyRes, req);
+        this.recordResponse(req, proxyRes);
+        res.writeHead(proxyRes.statusCode || 200, proxyRes.headers);
+        proxyRes.pipe(res);
+      }
+    );
+    proxyReq.on("error", (err) => {
+      this.handleProxyError(err, req, res);
+    });
+    if (chunks.length > 0) {
+      proxyReq.write(Buffer.concat(chunks));
+    }
+    proxyReq.end();
   }
   handleUpgrade(req, socket, head) {
     if (this.mode === Modes.replay) {
@@ -555,15 +635,15 @@ function generateSessionId(testInfo) {
 }
 async function startRecording(testInfo) {
   const sessionId = generateSessionId(testInfo);
-  await setProxyMode("recording", sessionId);
+  await setProxyMode(Modes.record, sessionId);
 }
 async function startReplay(testInfo) {
   const sessionId = generateSessionId(testInfo);
-  await setProxyMode("replay", sessionId);
+  await setProxyMode(Modes.replay, sessionId);
 }
 async function stopProxy(testInfo) {
   const sessionId = generateSessionId(testInfo);
-  await setProxyMode("transparent", sessionId);
+  await setProxyMode(Modes.transparent, sessionId);
 }
 var playwrightProxy = {
   /**
@@ -582,7 +662,7 @@ var playwrightProxy = {
    */
   async after(testInfo) {
     const sessionId = generateSessionId(testInfo);
-    await setProxyMode("transparent", sessionId);
+    await setProxyMode(Modes.transparent, sessionId);
   }
 };
 

package/dist/index.d.cts

@@ -1,5 +1,5 @@
 import http from 'node:http';
-export { PlaywrightTestInfo, ProxyMode, generateSessionId, playwrightProxy, setProxyMode, startRecording, startReplay, stopProxy } from './playwright/index.cjs';
+export { C as ControlRequest, M as Mode, P as PlaywrightTestInfo, R as Recording, a as RecordingSession, W as WebSocketRecording, g as generateSessionId, p as playwrightProxy, s as setProxyMode, b as startRecording, c as startReplay, d as stopProxy } from './index-De4mgziH.cjs';
 import '@playwright/test';
 
 declare class ProxyServer {
@@ -12,12 +12,15 @@ declare class ProxyServer {
     private proxy;
     private currentSession;
     private recordingsDir;
+    private requestSequenceMap;
+    private replaySequenceMap;
     constructor(targets: string[], recordingsDir: string);
     init(): Promise<void>;
     listen(port: number): http.Server;
     private setupProxyEventHandlers;
     private handleProxyError;
     private handleProxyResponse;
+    private addCorsHeaders;
     private getTarget;
     private handleControlRequest;
     private clearModeTimeout;
@@ -32,57 +35,13 @@ declare class ProxyServer {
     private handleReplayRequest;
     private handleReplayError;
     private handleRequest;
+    private handleCorsPreflightRequest;
     private handleProxyRequest;
-    private bufferRequestForRecord;
+    private bufferAndProxyRequest;
     private handleUpgrade;
     private handleRecordWebSocket;
     private handleReplayWebSocket;
     private logServerStartup;
 }
 
-declare const Modes: {
-    readonly transparent: "transparent";
-    readonly record: "record";
-    readonly replay: "replay";
-};
-type Mode = (typeof Modes)[keyof typeof Modes];
-interface ControlRequest {
-    mode: Mode;
-    id?: string;
-    timeout?: number;
-}
-interface RecordedRequest {
-    method: string;
-    url: string;
-    headers: http.IncomingHttpHeaders;
-    body: string | null;
-}
-interface RecordedResponse {
-    statusCode: number;
-    headers: http.IncomingHttpHeaders;
-    body: string | null;
-}
-interface Recording {
-    request: RecordedRequest;
-    response?: RecordedResponse;
-    timestamp: string;
-    key: string;
-}
-interface WebSocketMessage {
-    direction: 'client-to-server' | 'server-to-client';
-    data: string;
-    timestamp: string;
-}
-interface WebSocketRecording {
-    url: string;
-    messages: WebSocketMessage[];
-    timestamp: string;
-    key: string;
-}
-interface RecordingSession {
-    id: string;
-    recordings: Recording[];
-    websocketRecordings: WebSocketRecording[];
-}
-
-export { type ControlRequest, type Mode, ProxyServer, type Recording, type RecordingSession, type WebSocketRecording };
+export { ProxyServer };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import http from 'node:http';
-export { PlaywrightTestInfo, ProxyMode, generateSessionId, playwrightProxy, setProxyMode, startRecording, startReplay, stopProxy } from './playwright/index.js';
+export { C as ControlRequest, M as Mode, P as PlaywrightTestInfo, R as Recording, a as RecordingSession, W as WebSocketRecording, g as generateSessionId, p as playwrightProxy, s as setProxyMode, b as startRecording, c as startReplay, d as stopProxy } from './index-De4mgziH.js';
 import '@playwright/test';
 
 declare class ProxyServer {
@@ -12,12 +12,15 @@ declare class ProxyServer {
     private proxy;
     private currentSession;
     private recordingsDir;
+    private requestSequenceMap;
+    private replaySequenceMap;
     constructor(targets: string[], recordingsDir: string);
     init(): Promise<void>;
     listen(port: number): http.Server;
     private setupProxyEventHandlers;
     private handleProxyError;
     private handleProxyResponse;
+    private addCorsHeaders;
     private getTarget;
     private handleControlRequest;
     private clearModeTimeout;
@@ -32,57 +35,13 @@ declare class ProxyServer {
     private handleReplayRequest;
     private handleReplayError;
     private handleRequest;
+    private handleCorsPreflightRequest;
     private handleProxyRequest;
-    private bufferRequestForRecord;
+    private bufferAndProxyRequest;
     private handleUpgrade;
     private handleRecordWebSocket;
     private handleReplayWebSocket;
     private logServerStartup;
 }
 
-declare const Modes: {
-    readonly transparent: "transparent";
-    readonly record: "record";
-    readonly replay: "replay";
-};
-type Mode = (typeof Modes)[keyof typeof Modes];
-interface ControlRequest {
-    mode: Mode;
-    id?: string;
-    timeout?: number;
-}
-interface RecordedRequest {
-    method: string;
-    url: string;
-    headers: http.IncomingHttpHeaders;
-    body: string | null;
-}
-interface RecordedResponse {
-    statusCode: number;
-    headers: http.IncomingHttpHeaders;
-    body: string | null;
-}
-interface Recording {
-    request: RecordedRequest;
-    response?: RecordedResponse;
-    timestamp: string;
-    key: string;
-}
-interface WebSocketMessage {
-    direction: 'client-to-server' | 'server-to-client';
-    data: string;
-    timestamp: string;
-}
-interface WebSocketRecording {
-    url: string;
-    messages: WebSocketMessage[];
-    timestamp: string;
-    key: string;
-}
-interface RecordingSession {
-    id: string;
-    recordings: Recording[];
-    websocketRecordings: WebSocketRecording[];
-}
-
-export { type ControlRequest, type Mode, ProxyServer, type Recording, type RecordingSession, type WebSocketRecording };
+export { ProxyServer };