@replayio-app-building/netlify-recorder 0.23.0 → 0.25.0

package/README.md

@@ -137,12 +137,12 @@ The function is idempotent — calling it multiple times for the same request is
 - **`status: "queued"` or `"processing"`** — returns `null` without re-queuing
 - **`status: "captured"` or `"failed"`** — calls the service, updates status to `"queued"`, returns `null`
 
-By default, the blob data URL points to `${recorderUrl}/api/get-backend-request-blob?requestId=${requestId}`. If your app serves blob data from a different endpoint, pass a custom `blobDataUrl`:
+The `blobDataUrl` must be a direct URL to the blob JSON (e.g. an UploadThing URL). The recording container fetches this URL directly — no callback to the recorder service is involved:
 
 ```typescript
 const recordingId = await ensureRequestRecording(sql, requestId, {
   recorderUrl: RECORDER_URL,
-  blobDataUrl: `https://your-app.netlify.app/api/get-blob?id=${requestId}`,
+  blobDataUrl: `https://utfs.io/f/${blobFileKey}`, // direct URL to stored blob data
   webhookUrl: "https://your-app.netlify.app/api/on-recording-complete", // optional
 });
 ```
@@ -411,7 +411,7 @@ Ensures a Replay recording exists (or is being created) for a backend request. L
 - `sql` — A Neon SQL tagged-template function
 - `requestId` — The backend request UUID
 - `options.recorderUrl` — Base URL of the Netlify Recorder service
-- `options.blobDataUrl` — Override the URL where the recording container fetches the blob JSON (defaults to `${recorderUrl}/api/get-backend-request-blob?requestId=${requestId}`)
+- `options.blobDataUrl` — Direct URL where the recording container fetches the blob JSON (e.g. an UploadThing URL)
 - `options.webhookUrl` — URL to POST the result to when the recording completes or fails
 
 **Returns:** The recording ID (`string`) if the request is already recorded, or `null` if the recording was queued or is in progress.

package/dist/index.d.ts

@@ -279,9 +279,10 @@ interface EnsureRequestRecordingOptions {
     recorderUrl: string;
     /**
      * Full URL where the recording container can fetch the blob JSON for this request.
-     * Defaults to `${recorderUrl}/api/get-backend-request-blob?requestId=${requestId}`.
+     * Must be a direct URL to the blob data (e.g. an UploadThing URL). The container
+     * fetches this URL directly — no callback to the recorder service is involved.
      */
-    blobDataUrl?: string;
+    blobDataUrl: string;
     /** URL to POST the result to when the recording completes or fails. */
     webhookUrl?: string;
 }

package/dist/index.js

@@ -827,45 +827,53 @@ async function createRequestRecording(blobUrlOrData, handlerPath, requestInfo) {
       );
     }
     let rawResult;
-    if (isV2) {
-      const url = requestInfo.rawUrl ?? `https://localhost${requestInfo.url}`;
-      const reqInit = {
-        method: requestInfo.method,
-        headers: requestInfo.headers
-      };
-      if (requestInfo.body && requestInfo.method !== "GET" && requestInfo.method !== "HEAD") {
-        reqInit.body = requestInfo.body;
-      }
-      const RequestCtor = globalThis.Request;
-      if (!RequestCtor) {
-        throw new Error(
-          "Handler uses Netlify Functions v2 signature but Request is not available in this environment. Ensure undici or a Request polyfill is installed."
-        );
-      }
-      const req = new RequestCtor(url, reqInit);
-      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") {
-        const res = response;
-        rawResult = {
-          statusCode: res.status,
-          body: await res.text()
+    try {
+      if (isV2) {
+        const url = requestInfo.rawUrl ?? `https://localhost${requestInfo.url}`;
+        const reqInit = {
+          method: requestInfo.method,
+          headers: requestInfo.headers
         };
+        if (requestInfo.body && requestInfo.method !== "GET" && requestInfo.method !== "HEAD") {
+          reqInit.body = requestInfo.body;
+        }
+        const RequestCtor = globalThis.Request;
+        if (!RequestCtor) {
+          throw new Error(
+            "Handler uses Netlify Functions v2 signature but Request is not available in this environment. Ensure undici or a Request polyfill is installed."
+          );
+        }
+        const req = new RequestCtor(url, reqInit);
+        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") {
+          const res = response;
+          rawResult = {
+            statusCode: res.status,
+            body: await res.text()
+          };
+        } else {
+          rawResult = response;
+        }
       } else {
-        rawResult = response;
+        rawResult = await handler({
+          httpMethod: requestInfo.method,
+          path: requestInfo.url,
+          headers: requestInfo.headers,
+          body: requestInfo.body ?? null,
+          queryStringParameters: requestInfo.queryStringParameters ?? null,
+          multiValueQueryStringParameters: requestInfo.multiValueQueryStringParameters ?? null,
+          rawUrl: requestInfo.rawUrl ?? requestInfo.url,
+          rawQuery: requestInfo.rawQuery ?? "",
+          isBase64Encoded: requestInfo.isBase64Encoded ?? false
+        });
       }
-    } else {
-      rawResult = await handler({
-        httpMethod: requestInfo.method,
-        path: requestInfo.url,
-        headers: requestInfo.headers,
-        body: requestInfo.body ?? null,
-        queryStringParameters: requestInfo.queryStringParameters ?? null,
-        multiValueQueryStringParameters: requestInfo.multiValueQueryStringParameters ?? null,
-        rawUrl: requestInfo.rawUrl ?? requestInfo.url,
-        rawQuery: requestInfo.rawQuery ?? "",
-        isBase64Encoded: requestInfo.isBase64Encoded ?? false
-      });
+    } catch (handlerErr) {
+      const errorMessage = handlerErr instanceof Error ? handlerErr.message : String(handlerErr);
+      rawResult = {
+        statusCode: 500,
+        body: JSON.stringify({ error: errorMessage })
+      };
     }
     if (blobData.handlerResponse) {
       const replayRes = rawResult;
@@ -1067,12 +1075,11 @@ async function ensureRequestRecording(sql, requestId, options) {
     return null;
   }
   const recorderUrl = options.recorderUrl.replace(/\/+$/, "");
-  const blobDataUrl = options.blobDataUrl ?? `${recorderUrl}/api/get-backend-request-blob?requestId=${requestId}`;
   const res = await fetch(`${recorderUrl}/api/create-recording`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({
-      blobDataUrl,
+      blobDataUrl: options.blobDataUrl,
       handlerPath: request.handler_path,
       commitSha: request.commit_sha,
       branchName: request.branch_name,

package/package.json

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