@replayio-app-building/netlify-recorder 0.40.0 → 0.41.0

package/dist/index.d.ts

@@ -344,33 +344,38 @@ interface RecordingEndpointResponse {
     error?: string;
 }
 /**
- * Creates a Netlify Function handler that other services can call to trigger
- * recording creation for a backend request (or retrieve its current status).
+ * Payload sent by the recorder service when a recording completes or fails.
+ * Used for both the PUT callback to this endpoint and the downstream
+ * notification to the user-configured `webhookUrl`.
+ */
+interface RecordingWebhookPayload {
+    requestId: string;
+    status: "recorded" | "failed";
+    recordingId?: string;
+    error?: string;
+}
+/**
+ * Creates a handler that other services can call to trigger recording creation
+ * for a backend request or retrieve its current status.
+ *
+ * ## Endpoints
  *
- * **POST** with `{ "requestId": "<uuid>" }` — triggers recording creation if
- * needed and returns the current status. Idempotent: re-posting the same
- * request ID will not re-queue an already-queued or recorded request.
+ * **GET** `?requestId=<uuid>` — returns the current recording status.
  *
- * **POST** with `?_callback=1&requestId=<uuid>` — webhook callback from the
- * recorder service. Updates `backend_requests` status and optionally forwards
- * to the configured `webhookUrl`.
+ * **POST** `{ "requestId": "<uuid>" }` — triggers recording creation if needed.
+ * Idempotent: re-posting the same request ID will not re-queue.
  *
- * **GET** with `?requestId=<uuid>` — returns the current recording status
- * without triggering any recording.
+ * **PUT** `RecordingWebhookPayload` — webhook callback from the recorder
+ * service when a recording completes or fails. Body must include
+ * `requestId`, `status` (`"recorded"` | `"failed"`), and either
+ * `recordingId` or `error`.
  *
  * When `secret` is provided, every request must include an
  * `Authorization: Bearer <secret>` header or receive a 401 response.
- *
- * Response body shape (`RecordingEndpointResponse`):
- * - `{ status: "recorded", recordingId, requestId }` — recording exists
- * - `{ status: "pending", requestId }` — recording is queued or processing
- * - `{ status: "queued", requestId }` — recording was just queued by this call
- * - `{ status: "not_found", error }` — request ID not in backend_requests
- * - `{ status: "error", requestId?, error }` — recording failed or server error
  */
 declare function createRecordingEndpoint(options: CreateRecordingEndpointOptions): (req: Request) => Promise<Response>;
 
 declare function runInRequestContext<T>(requestId: string | null, fn: () => Promise<T>): Promise<T>;
 declare function getCurrentRequestId(): string | null;
 
-export { type BackendRequest, type BlobData, type CapturedData, type CreateRecordingEndpointOptions, type CreateRecordingRequestHandlerOptions, type EnsureRequestRecordingOptions, type EnvRead, type FinishRequestCallbacks, type FinishRequestOptions, type HandlerResponse$1 as HandlerResponse, type NetlifyEvent, type NetlifyV2Request, type NetworkCall, type RecordingEndpointResponse, type RecordingResult, type RequestContext, type RequestInfo, backendRequestsEnsureTable, backendRequestsGet, backendRequestsGetBlobUrl, backendRequestsInsert, backendRequestsList, backendRequestsUpdateStatus, createRecordingEndpoint, createRecordingRequestHandler, createRequestRecording, databaseAuditDumpLogTable, databaseAuditEnsureLogTable, databaseAuditMonitorTable, databaseCallbacks, ensureRequestRecording, finishRequest, getCurrentRequestId, redactBlobData, remoteCallbacks, runInRequestContext, startRequest };
+export { type BackendRequest, type BlobData, type CapturedData, type CreateRecordingEndpointOptions, type CreateRecordingRequestHandlerOptions, type EnsureRequestRecordingOptions, type EnvRead, type FinishRequestCallbacks, type FinishRequestOptions, type HandlerResponse$1 as HandlerResponse, type NetlifyEvent, type NetlifyV2Request, type NetworkCall, type RecordingEndpointResponse, type RecordingResult, type RecordingWebhookPayload, type RequestContext, type RequestInfo, backendRequestsEnsureTable, backendRequestsGet, backendRequestsGetBlobUrl, backendRequestsInsert, backendRequestsList, backendRequestsUpdateStatus, createRecordingEndpoint, createRecordingRequestHandler, createRequestRecording, databaseAuditDumpLogTable, databaseAuditEnsureLogTable, databaseAuditMonitorTable, databaseCallbacks, ensureRequestRecording, finishRequest, getCurrentRequestId, redactBlobData, remoteCallbacks, runInRequestContext, startRequest };

package/dist/index.js

@@ -1517,6 +1517,28 @@ async function forwardWebhook(url, payload) {
 }
 function createRecordingEndpoint(options) {
   const { sql, recorderUrl, secret, webhookUrl } = options;
+  async function handleCallback(body) {
+    const { requestId, status, recordingId, error } = body;
+    if (!requestId) {
+      return jsonResponse({ status: "error", error: "Missing requestId in callback body" }, 400);
+    }
+    if (status === "recorded" && recordingId) {
+      await backendRequestsUpdateStatus(sql, requestId, "recorded", recordingId);
+      if (webhookUrl) {
+        await forwardWebhook(webhookUrl, { requestId, status: "recorded", recordingId });
+      }
+      return jsonResponse({ status: "recorded", recordingId, requestId }, 200);
+    }
+    if (status === "failed") {
+      const errorMsg = error ?? "Recording failed";
+      await backendRequestsUpdateStatus(sql, requestId, "failed", void 0, errorMsg);
+      if (webhookUrl) {
+        await forwardWebhook(webhookUrl, { requestId, status: "failed", error: errorMsg });
+      }
+      return jsonResponse({ status: "error", requestId, error: errorMsg }, 200);
+    }
+    return jsonResponse({ status: "error", error: "Invalid callback payload \u2014 expected status 'recorded' or 'failed'" }, 400);
+  }
   return async (req) => {
     if (secret) {
       const auth = req.headers.get("authorization");
@@ -1537,46 +1559,15 @@ function createRecordingEndpoint(options) {
         }
         return jsonResponse(formatStatus(request), 200);
       }
+      if (req.method === "PUT") {
+        const body = await req.json();
+        return handleCallback(body);
+      }
       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();
+        if (body.status) {
+          return handleCallback(body);
+        }
         const requestId = body.requestId;
         if (!requestId) {
           return jsonResponse({ status: "error", error: "Missing requestId in request body" }, 400);
@@ -1594,11 +1585,12 @@ 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)}`;
+        const url = new URL(req.url);
+        const callbackUrl = `${url.origin}${url.pathname}`;
         try {
           const recordingId = await ensureRequestRecording(sql, requestId, {
             recorderUrl,
-            webhookUrl: selfCallbackUrl
+            webhookUrl: callbackUrl
           });
           if (recordingId) {
             return jsonResponse({ status: "recorded", recordingId, requestId }, 200);

package/package.json

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