@replayio-app-building/netlify-recorder 0.37.0 → 0.38.0

package/dist/index.d.ts

@@ -351,6 +351,10 @@ interface RecordingEndpointResponse {
  * needed and returns the current status. Idempotent: re-posting the same
  * request ID will not re-queue an already-queued or recorded request.
  *
+ * **POST** with `?_callback=1&requestId=<uuid>` — webhook callback from the
+ * recorder service. Updates `backend_requests` status and optionally forwards
+ * to the configured `webhookUrl`.
+ *
  * **GET** with `?requestId=<uuid>` — returns the current recording status
  * without triggering any recording.
  *

package/dist/index.js

@@ -890,11 +890,21 @@ async function createRequestRecording(blobUrlOrData, handlerPath, requestInfo) {
       const nodeCrypto = __require("crypto");
       g.crypto = {
         randomUUID: () => nodeCrypto.randomUUID(),
-        getRandomValues: (buf) => nodeCrypto.getRandomValues(buf)
+        getRandomValues: (buf) => nodeCrypto.getRandomValues(buf),
+        subtle: nodeCrypto.webcrypto?.subtle
       };
     } catch {
     }
   }
+  if (g.crypto && typeof g.crypto.subtle === "undefined") {
+    try {
+      const nodeCrypto = __require("crypto");
+      if (nodeCrypto.webcrypto?.subtle) {
+        g.crypto.subtle = nodeCrypto.webcrypto.subtle;
+      }
+    } catch {
+    }
+  }
   if (typeof g.Headers === "undefined") {
     const HeadersShim = class Headers {
       _map;
@@ -1073,6 +1083,9 @@ async function createRequestRecording(blobUrlOrData, handlerPath, requestInfo) {
           );
         }
         const req = new RequestCtor(url, reqInit);
+        const cookieKey = Object.keys(requestInfo.headers).find((k) => k.toLowerCase() === "cookie");
+        g.__REPLAY_REQUEST_COOKIES__ = cookieKey ? requestInfo.headers[cookieKey] : "";
+        g.__REPLAY_REQUEST_HEADERS__ = requestInfo.headers;
         const context = { geo: {}, ip: "127.0.0.1", requestId: "replay", server: { region: "local" } };
         const response = await handler(req, context);
         if (response && typeof response === "object" && typeof response.status === "number" && typeof response.text === "function") {
@@ -1162,6 +1175,8 @@ async function createRequestRecording(blobUrlOrData, handlerPath, requestInfo) {
       console.log(`  [network-replay] All ${total} recorded network call(s) were consumed.`);
     }
     globalThis.__REPLAY_RECORDING_MODE__ = false;
+    delete g.__REPLAY_REQUEST_COOKIES__;
+    delete g.__REPLAY_REQUEST_HEADERS__;
     networkHandle.restore();
     envHandle.restore();
   }
@@ -1484,6 +1499,16 @@ function formatStatus(request) {
   }
   return { status: "pending", requestId: request.id };
 }
+async function forwardWebhook(url, payload) {
+  try {
+    await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+  } catch {
+  }
+}
 function createRecordingEndpoint(options) {
   const { sql, recorderUrl, secret, webhookUrl } = options;
   return async (req) => {
@@ -1507,6 +1532,44 @@ function createRecordingEndpoint(options) {
         return jsonResponse(formatStatus(request), 200);
       }
       if (req.method === "POST") {
+        const url = new URL(req.url);
+        if (url.searchParams.has("_callback")) {
+          const callbackRequestId = url.searchParams.get("requestId");
+          if (!callbackRequestId) {
+            return jsonResponse({ status: "error", error: "Missing requestId in callback" }, 400);
+          }
+          const callbackBody = await req.json();
+          if (callbackBody.status === "recorded" && callbackBody.recordingId) {
+            await backendRequestsUpdateStatus(
+              sql,
+              callbackRequestId,
+              "recorded",
+              callbackBody.recordingId
+            );
+            if (webhookUrl) {
+              await forwardWebhook(webhookUrl, {
+                status: "recorded",
+                recordingId: callbackBody.recordingId
+              });
+            }
+            return jsonResponse(
+              { status: "recorded", recordingId: callbackBody.recordingId, requestId: callbackRequestId },
+              200
+            );
+          }
+          if (callbackBody.status === "failed") {
+            const errorMsg = callbackBody.error ?? "Recording failed";
+            await backendRequestsUpdateStatus(sql, callbackRequestId, "failed", void 0, errorMsg);
+            if (webhookUrl) {
+              await forwardWebhook(webhookUrl, { status: "failed", error: errorMsg });
+            }
+            return jsonResponse(
+              { status: "error", requestId: callbackRequestId, error: errorMsg },
+              200
+            );
+          }
+          return jsonResponse({ status: "error", error: "Invalid callback payload" }, 400);
+        }
         const body = await req.json();
         const requestId = body.requestId;
         if (!requestId) {
@@ -1525,10 +1588,11 @@ function createRecordingEndpoint(options) {
         if (request.status === "queued" || request.status === "processing") {
           return jsonResponse({ status: "pending", requestId }, 200);
         }
+        const selfCallbackUrl = `${url.origin}${url.pathname}?_callback=1&requestId=${encodeURIComponent(requestId)}`;
         try {
           const recordingId = await ensureRequestRecording(sql, requestId, {
             recorderUrl,
-            webhookUrl
+            webhookUrl: selfCallbackUrl
           });
           if (recordingId) {
             return jsonResponse({ status: "recorded", recordingId, requestId }, 200);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@replayio-app-building/netlify-recorder",
-  "version": "0.37.0",
+  "version": "0.38.0",
   "description": "Capture and replay Netlify function executions as Replay recordings",
   "type": "module",
   "exports": {