playwright-codegen-pro-core 1.0.0

package/lib/server/recorder/networkCapture.js

@@ -0,0 +1,282 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var networkCapture_exports = {};
+__export(networkCapture_exports, {
+  NetworkCapture: () => NetworkCapture
+});
+module.exports = __toCommonJS(networkCapture_exports);
+function _isSameAction(a, b) {
+  return a.action.name === b.action.name && a.frame.pageAlias === b.frame.pageAlias && a.frame.framePath.join("|") === b.frame.framePath.join("|");
+}
+function _shouldMergeAction(action, lastAction) {
+  if (!lastAction)
+    return false;
+  if (action.action.name === "fill")
+    return _isSameAction(action, lastAction) && "selector" in action.action && "selector" in lastAction.action && action.action.selector === lastAction.action.selector;
+  if (action.action.name === "navigate")
+    return _isSameAction(action, lastAction);
+  if (action.action.name === "click")
+    return _isSameAction(action, lastAction) && "selector" in action.action && "selector" in lastAction.action && action.action.selector === lastAction.action.selector && action.startTime - lastAction.startTime < 500 && action.action.clickCount > lastAction.action.clickCount;
+  return false;
+}
+function _collapseActions(actions) {
+  const result = [];
+  for (const action of actions) {
+    const last = result[result.length - 1];
+    if (!_shouldMergeAction(action, last)) {
+      result.push(action);
+    } else {
+      const startTime = last.startTime;
+      result[result.length - 1] = action;
+      result[result.length - 1].startTime = startTime;
+    }
+  }
+  return result;
+}
+const CTX_EVENTS = {
+  Request: "request",
+  RequestFinished: "requestfinished",
+  RequestFailed: "requestfailed",
+  RequestAborted: "requestaborted"
+};
+const debugNetwork = !!process.env.PW_DEBUG_NETWORK;
+class NetworkCapture {
+  constructor(context, delegate) {
+    this._knownActions = [];
+    this._pending = /* @__PURE__ */ new Map();
+    // pageGuid → timestamp of last nav signal
+    this._navBoundaries = /* @__PURE__ */ new Map();
+    // pageGuid → { until: absolute ms, fromClick: bool }
+    this._bucketBWindows = /* @__PURE__ */ new Map();
+    // pageGuid+url+method → recent fire timestamps (for poll detection)
+    this._pollTracker = /* @__PURE__ */ new Map();
+    this._listeners = [];
+    this._context = context;
+    this._delegate = delegate;
+  }
+  start() {
+    const onRequest = (req) => this._onRequest(req);
+    const onFinished = ({ request, response }) => void this._onRequestFinished(request, response);
+    const onFailed = (req) => this._onRequestAbortedOrFailed(req);
+    const onAborted = (req) => this._onRequestAbortedOrFailed(req);
+    this._context.on(CTX_EVENTS.Request, onRequest);
+    this._context.on(CTX_EVENTS.RequestFinished, onFinished);
+    this._context.on(CTX_EVENTS.RequestFailed, onFailed);
+    this._context.on(CTX_EVENTS.RequestAborted, onAborted);
+    this._listeners.push(
+      () => this._context.off(CTX_EVENTS.Request, onRequest),
+      () => this._context.off(CTX_EVENTS.RequestFinished, onFinished),
+      () => this._context.off(CTX_EVENTS.RequestFailed, onFailed),
+      () => this._context.off(CTX_EVENTS.RequestAborted, onAborted)
+    );
+  }
+  stop() {
+    this.dispose();
+  }
+  dispose() {
+    for (const remove of this._listeners)
+      remove();
+    this._listeners = [];
+  }
+  onActionAdded(action) {
+    this._knownActions.push(action);
+    if (debugNetwork)
+      console.log(`[NC] action "${action.action.name}" at t=${action.startTime}`);
+  }
+  onNavigationSignal(pageGuid, url) {
+    const now = Date.now();
+    this._navBoundaries.set(pageGuid, now);
+    const lastAction = this._findLastActionForPage(pageGuid);
+    const fromClick = lastAction?.action.name === "click";
+    const windowMs = fromClick ? 1500 : 800;
+    this._bucketBWindows.set(pageGuid, { until: now + windowMs, fromClick });
+    if (debugNetwork)
+      console.log(`[NC] nav signal pageGuid=${pageGuid} url=${url} \u2192 Bucket B window=${windowMs}ms`);
+  }
+  async waitForPendingResponses(maxMs) {
+    const deadline = Date.now() + maxMs;
+    while (this._pending.size > 0 && Date.now() < deadline)
+      await new Promise((r) => setTimeout(r, 50));
+  }
+  getEnrichedActions(rawActions) {
+    return _collapseActions(rawActions);
+  }
+  // ─── Private ─────────────────────────────────────────────────────────────
+  _findLastActionForPage(pageGuid) {
+    for (let i = this._knownActions.length - 1; i >= 0; i--) {
+      if (this._knownActions[i].frame.pageGuid === pageGuid)
+        return this._knownActions[i];
+    }
+    return null;
+  }
+  _isNoiseUrl(url, method) {
+    if (method === "OPTIONS")
+      return true;
+    if (/\.(js|css|woff|woff2|ttf|eot|svg|png|jpg|jpeg|gif|ico|map)(\?|$)/i.test(url))
+      return true;
+    try {
+      const parsed = new URL(url);
+      if (/analytics|segment\.io|mixpanel|amplitude|hotjar|fullstory|heap\.io|intercom\.io|clarity\.ms|googletagmanager|google-analytics|facebook\.net/.test(parsed.hostname))
+        return true;
+      if (/\/analytics\/|\/tracking\/|\/pixel|\/beacon/i.test(parsed.pathname))
+        return true;
+    } catch {
+      return true;
+    }
+    if (/refresh[_-]?token|token\/refresh|oauth\/token|auth\/refresh/i.test(url))
+      return true;
+    return false;
+  }
+  _isPolling(pageGuid, key, method) {
+    const trackKey = `${pageGuid}|${key}|${method}`;
+    const now = Date.now();
+    const times = (this._pollTracker.get(trackKey) ?? []).filter((t) => now - t < 3e4);
+    times.push(now);
+    this._pollTracker.set(trackKey, times);
+    return times.length >= 3;
+  }
+  _extractGraphQLOperationName(request) {
+    if (request.method() !== "POST")
+      return void 0;
+    try {
+      const url = request.url();
+      if (!/graphql/i.test(url))
+        return void 0;
+      const buf = request.postDataBuffer();
+      if (!buf)
+        return void 0;
+      const body = JSON.parse(buf.toString("utf-8"));
+      return typeof body.operationName === "string" ? body.operationName : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  _assignBucket(request, pageGuid) {
+    const now = Date.now();
+    const method = request.method();
+    const url = request.url();
+    if (this._isNoiseUrl(url, method))
+      return "noise";
+    if (!pageGuid)
+      return "noise";
+    const knownPage = this._knownActions.some((a) => a.frame.pageGuid === pageGuid);
+    if (!knownPage)
+      return "noise";
+    const opName = this._extractGraphQLOperationName(request);
+    const pollKey = opName ?? url;
+    if (this._isPolling(pageGuid, pollKey, method))
+      return "noise";
+    const bWindow = this._bucketBWindows.get(pageGuid);
+    if (bWindow && now <= bWindow.until)
+      return "pageLoad";
+    const navTime = this._navBoundaries.get(pageGuid) ?? 0;
+    const lastAction = this._findLastActionForPage(pageGuid);
+    if (lastAction && lastAction.startTime > navTime)
+      return "direct";
+    return "noise";
+  }
+  _onRequest(request) {
+    const pageGuid = request.frame()?._page?.guid ?? "";
+    const method = request.method();
+    const url = request.url();
+    const redirectedFrom = request.redirectedFrom();
+    if (redirectedFrom) {
+      const parentEntry = this._pending.get(redirectedFrom.guid);
+      if (parentEntry) {
+        const networkEvent2 = {
+          ...parentEntry.networkEvent,
+          isRedirect: true,
+          firedMs: Date.now() - (parentEntry.targetAction?.startTime ?? 0),
+          aborted: false,
+          status: void 0,
+          resolvedMs: void 0,
+          requestBodySnippet: void 0,
+          bodySnippet: void 0
+        };
+        this._pending.set(request.guid, { networkEvent: networkEvent2, targetAction: parentEntry.targetAction });
+        return;
+      }
+    }
+    const bucket = this._assignBucket(request, pageGuid);
+    const targetAction = pageGuid ? this._findLastActionForPage(pageGuid) : null;
+    const operationName = this._extractGraphQLOperationName(request);
+    let requestBodySnippet;
+    if (["POST", "PUT", "PATCH", "DELETE"].includes(method) && bucket !== "noise") {
+      const buf = request.postDataBuffer();
+      if (buf) {
+        const text = buf.toString("utf-8");
+        if (text)
+          requestBodySnippet = text.slice(0, 500) + (text.length > 500 ? "..." : "");
+      }
+    }
+    const networkEvent = {
+      url,
+      method,
+      bucket,
+      pageGuid,
+      firedMs: Date.now() - (targetAction?.startTime ?? 0),
+      isRedirect: !!request.redirectedFrom(),
+      aborted: false,
+      ...operationName ? { operationName } : {},
+      ...requestBodySnippet ? { requestBodySnippet } : {}
+    };
+    this._pending.set(request.guid, { networkEvent, targetAction });
+    if (debugNetwork) {
+      const actionLabel = targetAction ? `"${targetAction.action.name}"` : "none";
+      console.log(`[NC]   ${method} ${url}${operationName ? ` (${operationName})` : ""} \u2192 Bucket ${bucket} linked=${actionLabel}`);
+    }
+  }
+  async _onRequestFinished(request, response) {
+    const entry = this._pending.get(request.guid);
+    if (!entry)
+      return;
+    if (response) {
+      entry.networkEvent.status = response.status();
+      entry.networkEvent.resolvedMs = Date.now() - (entry.targetAction?.startTime ?? 0);
+      const ct = response.headers().find((h) => h.name.toLowerCase() === "content-type")?.value ?? "";
+      if (/text|json|html/i.test(ct)) {
+        const buf = await response.body().catch(() => null);
+        if (buf)
+          entry.networkEvent.bodySnippet = buf.toString("utf-8").slice(0, 500);
+      }
+    }
+    this._pending.delete(request.guid);
+    if (entry.targetAction) {
+      entry.targetAction.networkEvents ??= [];
+      entry.targetAction.networkEvents.push(entry.networkEvent);
+    }
+    this._delegate.onNetworkEventsUpdated();
+  }
+  _onRequestAbortedOrFailed(request) {
+    const entry = this._pending.get(request.guid);
+    if (!entry)
+      return;
+    entry.networkEvent.aborted = true;
+    this._pending.delete(request.guid);
+    if (entry.targetAction) {
+      entry.targetAction.networkEvents ??= [];
+      entry.targetAction.networkEvents.push(entry.networkEvent);
+    }
+    this._delegate.onNetworkEventsUpdated();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NetworkCapture
+});