@replayio-app-building/netlify-recorder 0.15.10 → 0.17.0

package/README.md

@@ -1,6 +1,6 @@
 # @replayio-app-building/netlify-recorder
 
-Capture and replay Netlify function executions as [Replay](https://replay.io) recordings. This package intercepts outbound network calls and environment variable reads during handler execution, stores the captured data as a blob, and can later reproduce the exact execution as a Replay recording for debugging and analysis.
+Capture and replay Netlify function executions as [Replay](https://replay.io) recordings. This package intercepts outbound network calls and environment variable reads during handler execution, stores the captured data via the Netlify Recorder service, and can later reproduce the exact execution as a Replay recording for debugging and analysis.
 
 ## Installation
 
@@ -8,23 +8,11 @@ Capture and replay Netlify function executions as [Replay](https://replay.io) re
 npm install @replayio-app-building/netlify-recorder
 ```
 
-## Integration Options
-
-There are two ways to use this package:
-
-- **Option A: Use the Netlify Recorder service (recommended)** — The service handles blob storage, request tracking, and recording creation. Your app just wraps its handlers and calls `remoteCallbacks()`. No database or container infrastructure needed.
-
-- **Option B: Self-hosted** — You manage your own blob storage, database tables, and recording containers. Full control, but requires more setup.
-
----
-
-## Option A: Using the Netlify Recorder Service
-
-The Netlify Recorder app (`https://netlify-recorder-bm4wmw.netlify.app`) provides a hosted service that stores captured request data, manages a pool of recording containers, and creates Replay recordings on demand. Your app needs zero database or infrastructure setup.
+## Setup
 
 ### 1. Set required environment variables
 
-`finishRequest` needs to know which repository, branch, and commit your deployed code belongs to. Set these three environment variables on your Netlify site:
+`finishRequest` needs to know which repository, branch, and commit your deployed code belongs to. Set these environment variables on your Netlify site:
 
 | Variable | Description | How to set |
 |---|---|---|
@@ -115,7 +103,7 @@ export default createRecordingRequestHandler(
 
 ### 3. Create recordings
 
-When you want to turn a captured request into a Replay recording, POST to the service's `create-recording` endpoint with the request ID. If the request was created with a secret, you must include it:
+When you want to turn a captured request into a Replay recording, POST to the Netlify Recorder service's `create-recording` endpoint with the request ID. If the request was created with a secret, you must include it:
 
 ```typescript
 const response = await fetch(
@@ -132,7 +120,7 @@ const response = await fetch(
 );
 ```
 
-The service looks up the stored blob data, dispatches the work to a pool container, and creates the recording.
+The service looks up the stored blob data, dispatches the work to a recording container, and creates the recording.
 
 If `webhookUrl` is provided, the service will POST the result to that URL when the recording completes (or fails):
 
@@ -225,7 +213,7 @@ Requests created without a secret remain accessible without one (backward compat
 
 Store your secret as a `NETLIFY_RECORDER_SECRET` environment variable. To keep it secure:
 
-1. **Netlify site environment:** Add `NETLIFY_RECORDER_SECRET` in your Netlify site's environment variables (Site settings → Environment variables). This makes it available to all deployed functions.
+1. **Netlify site environment:** Add `NETLIFY_RECORDER_SECRET` in your Netlify site's environment variables (Site settings > Environment variables). This makes it available to all deployed functions.
 
 2. **Branch-level secret** (for CI/development): If you're using the Netlify Recorder agent infrastructure, store the secret as a branch secret so deploy scripts and background agents can access it:
 
@@ -239,158 +227,6 @@ Use a strong random string (e.g. `openssl rand -base64 32`) and rotate it if com
 
 ---
 
-## Option B: Self-Hosted
-
-If you need full control, you can manage your own blob storage, database, and recording containers. This requires more setup but gives you complete ownership of the data pipeline.
-
-### 1. Set required environment variables
-
-Same as Option A — you must set `REPLAY_REPOSITORY_URL`, `COMMIT_SHA`, and `BRANCH_NAME` on your Netlify site. See the table in Option A, Step 1 above.
-
-### 2. Wrap your Netlify function
-
-Use `createRecordingRequestHandler` with custom callbacks that write to your own storage and database:
-
-```typescript
-import { createRecordingRequestHandler } from "@replayio-app-building/netlify-recorder";
-
-const handler = createRecordingRequestHandler(
-  async (event) => {
-    const result = await myBusinessLogic();
-
-    return {
-      statusCode: 200,
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(result),
-    };
-  },
-  {
-    secret: process.env.NETLIFY_RECORDER_SECRET,
-    callbacks: {
-      uploadBlob: async (data) => {
-        // Upload the JSON string to your blob storage (S3, R2, etc.)
-        const res = await fetch("https://storage.example.com/upload", {
-          method: "PUT",
-          body: data,
-        });
-        const { url } = await res.json();
-        return url;
-      },
-      storeRequestData: async ({ blobUrl, commitSha, branchName, repositoryUrl, handlerPath, secret }) => {
-        const [row] = await sql`
-          INSERT INTO requests (blob_url, commit_sha, branch_name, repository_url, handler_path, secret, status)
-          VALUES (${blobUrl}, ${commitSha}, ${branchName}, ${repositoryUrl}, ${handlerPath}, ${secret}, 'captured')
-          RETURNING id
-        `;
-        return row.id;
-      },
-    },
-  }
-);
-
-export { handler };
-```
-
-### 3. Create a requests database table
-
-```sql
-CREATE TABLE IF NOT EXISTS requests (
-  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-  blob_url TEXT,
-  commit_sha TEXT,
-  branch_name TEXT,
-  repository_url TEXT,
-  handler_path TEXT,
-  secret TEXT,
-  recording_id TEXT,
-  status TEXT NOT NULL DEFAULT 'captured'
-    CHECK (status IN ('captured', 'processing', 'recorded', 'failed')),
-  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-  updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-);
-
-CREATE INDEX IF NOT EXISTS idx_requests_secret ON requests (secret) WHERE secret IS NOT NULL;
-```
-
-### 4. Create a background function to produce recordings
-
-```typescript
-import { ensureRequestRecording } from "@replayio-app-building/netlify-recorder";
-import type { Handler } from "@netlify/functions";
-
-const handler: Handler = async (event) => {
-  const { requestId } = JSON.parse(event.body ?? "{}");
-
-  const recordingId = await ensureRequestRecording(requestId, {
-    repositoryUrl: process.env.APP_REPOSITORY_URL!,
-    lookupRequest: async (id) => {
-      const [row] = await sql`
-        SELECT blob_url, commit_sha, branch_name, handler_path
-        FROM requests WHERE id = ${id}
-      `;
-      return {
-        blobUrl: row.blob_url,
-        commitSha: row.commit_sha,
-        branchName: row.branch_name ?? "main",
-        handlerPath: row.handler_path,
-      };
-    },
-    updateStatus: async (id, status, recordingId) => {
-      await sql`
-        UPDATE requests
-        SET status = ${status},
-            recording_id = ${recordingId ?? null},
-            updated_at = NOW()
-        WHERE id = ${id}
-      `;
-    },
-  });
-
-  return {
-    statusCode: 200,
-    body: JSON.stringify({ recordingId }),
-  };
-};
-
-export { handler };
-```
-
-### 5. Create a container script
-
-This script runs inside the recording container under `replay-node`:
-
-```typescript
-// scripts/create-request-recording.ts
-import { createRequestRecording } from "@replayio-app-building/netlify-recorder";
-
-const args = process.argv.slice(2);
-const blobUrl = args[args.indexOf("--blob-url") + 1]!;
-const handlerPath = args[args.indexOf("--handler-path") + 1]!;
-
-await createRequestRecording(blobUrl, handlerPath, {
-  method: "POST",
-  url: handlerPath,
-  headers: {},
-});
-```
-
-### Required infrastructure
-
-Self-hosted recording requires these environment variables:
-
-| Variable | Description |
-|---|---|
-| `INFISICAL_CLIENT_ID` | Infisical service account client ID |
-| `INFISICAL_CLIENT_SECRET` | Infisical service account client secret |
-| `INFISICAL_PROJECT_ID` | Infisical project ID |
-| `INFISICAL_ENVIRONMENT` | Infisical environment (e.g. `production`) |
-| `FLY_API_TOKEN` | Fly.io API token for container management |
-| `FLY_APP_NAME` | Fly.io app name for container deployment |
-| `APP_REPOSITORY_URL` | Git repository URL for container cloning |
-| `RECORD_REPLAY_API_KEY` | Replay API key for recording upload |
-
----
-
 ## Audit Log Support
 
 The package automatically tracks database mutations (INSERT, UPDATE, DELETE) in an `audit_log` table and links each change to the Replay request that caused it. When your handler is wrapped with `createRecordingRequestHandler`, all Neon SQL queries are automatically tagged with the request ID — no changes to your SQL code required.
@@ -484,7 +320,7 @@ When `context.waitUntil` is not available (v1 handlers or missing context), the
 
 **Parameters:**
 - `handler` — Your async handler function `(event, context?) => Promise<{ statusCode, headers?, body? }>`
-- `options.callbacks` — Either `remoteCallbacks(serviceUrl)` or custom `{ uploadBlob, storeRequestData }` callbacks
+- `options.callbacks` — `remoteCallbacks(serviceUrl)` for sending captured data to the Netlify Recorder service
 - `options.handlerPath` — Path to the handler file (used for recording metadata)
 - `options.commitSha` — Override `COMMIT_SHA` env var
 - `options.branchName` — Override `BRANCH_NAME` env var
@@ -520,7 +356,7 @@ Logs a `console.warn` when the total duration exceeds 2 seconds or when individu
 
 **Parameters:**
 - `requestContext` — The context returned by `startRequest`
-- `callbacks` — Either `remoteCallbacks(serviceUrl)` or custom `{ uploadBlob, storeRequestData }` callbacks
+- `callbacks` — `remoteCallbacks(serviceUrl)` for sending captured data to the Netlify Recorder service
 - `response` — The handler's response object (`{ statusCode, headers?, body? }`)
 - `options.handlerPath` — Path to the handler file (used for recording metadata)
 - `options.commitSha` — Override `COMMIT_SHA` env var
@@ -531,30 +367,11 @@ Logs a `console.warn` when the total duration exceeds 2 seconds or when individu
 
 ### `remoteCallbacks(serviceUrl): FinishRequestCallbacks`
 
-Creates callbacks for `finishRequest` that send captured data to the Netlify Recorder service. The service handles blob storage and request tracking — no local database needed.
+Creates callbacks for `finishRequest` that send captured data to the Netlify Recorder service. The service handles blob storage and request tracking.
 
 **Parameters:**
 - `serviceUrl` — Base URL of the Netlify Recorder service (e.g. `"https://netlify-recorder-bm4wmw.netlify.app"`)
 
-### `ensureRequestRecording(requestId, options): Promise<string>`
-
-Spawns a container via `@replayio/app-building` to create a Replay recording from captured request data. Returns the recording ID. Only needed for self-hosted setups (Option B).
-
-**Parameters:**
-- `requestId` — The request to create a recording for
-- `options.repositoryUrl` — Git repository URL for the container to clone
-- `options.lookupRequest(id)` — Fetches `{ blobUrl, commitSha, branchName, handlerPath }` from the database
-- `options.updateStatus(id, status, recordingId?)` — Updates the request status in the database
-
-### `createRequestRecording(blobUrl, handlerPath, requestInfo): Promise<void>`
-
-Called inside a container running under `replay-node`. Downloads the captured data blob, installs replay-mode interceptors (which return pre-recorded responses instead of making real calls), and executes the original handler so replay-node can record the execution. Only needed for self-hosted setups (Option B).
-
-**Parameters:**
-- `blobUrl` — URL to the captured data blob
-- `handlerPath` — Path to the handler module to execute
-- `requestInfo` — The original request info to replay
-
 ### `databaseAuditEnsureLogTable(sql): Promise<void>`
 
 Creates the `audit_log` table, its indexes, and a reusable PL/pgSQL trigger function (`audit_trigger_function`). Call once during schema initialization.
@@ -579,8 +396,6 @@ Returns all rows from the `audit_log` table, ordered by `performed_at` DESC.
 
 ## Environment Variables
 
-### Required for all setups (read by `finishRequest`)
-
 These must be set on your Netlify site. Your deploy script should resolve them from git and push them to the Netlify environment before deploying. `finishRequest` will throw an error if any are missing.
 
 | Variable | Description | How to resolve |
@@ -590,15 +405,8 @@ These must be set on your Netlify site. Your deploy script should resolve them f
 | `REPLAY_REPOSITORY_URL` | Git repository URL (no embedded credentials) | `git remote get-url origin` (strip tokens) |
 | `NETLIFY_RECORDER_SECRET` | Secret for access control (strongly recommended) | `openssl rand -base64 32` — store in Netlify site env vars |
 
-### Required for self-hosted recording (Option B)
-
-| Variable | Description |
-|---|---|
-| `RECORD_REPLAY_API_KEY` | Replay API key for uploading recordings |
-| `APP_REPOSITORY_URL` | Git repository URL for container cloning |
-
 ## How It Works
 
-1. **Capture phase** (`createRecordingRequestHandler` or `startRequest` / `finishRequest`): When a Netlify function handles a request, the recording layer patches `globalThis.fetch` and `process.env` with Proxies that record every outbound network call and environment variable read. When the handler completes, the originals are restored, the captured data is serialized to JSON, and sent to either the remote service (via `remoteCallbacks`) or your own storage (via custom callbacks).
+1. **Capture phase** (`createRecordingRequestHandler` or `startRequest` / `finishRequest`): When a Netlify function handles a request, the recording layer patches `globalThis.fetch` and `process.env` with Proxies that record every outbound network call and environment variable read. When the handler completes, the originals are restored, the captured data is serialized to JSON, and sent to the Netlify Recorder service via `remoteCallbacks`.
 
-2. **Recording phase**: The captured blob is sent to a recording container (either via the Netlify Recorder service or self-hosted). Inside the container, `createRequestRecording` downloads the blob, installs replay-mode interceptors that return the pre-recorded responses, and re-executes the handler under `replay-node`. Since replay-node records all execution, this produces a Replay recording of the exact same handler execution.
+2. **Recording phase**: The Netlify Recorder service dispatches the captured data to a recording container. Inside the container, the captured blob is downloaded, replay-mode interceptors return the pre-recorded responses instead of making real calls, and the original handler is re-executed under `replay-node`. Since replay-node records all execution, this produces a Replay recording of the exact same handler execution.

package/dist/index.d.ts

@@ -312,7 +312,7 @@ interface CreateRecordingRequestHandlerOptions extends FinishRequestOptions {
  * );
  * ```
  */
-declare function createRecordingRequestHandler(handler: (event: NetlifyEvent | NetlifyV2Request, context?: unknown) => Promise<HandlerResponse>, options: CreateRecordingRequestHandlerOptions): (event: NetlifyEvent | NetlifyV2Request, context?: unknown) => Promise<HandlerResponse | Response>;
+declare function createRecordingRequestHandler(handler: (event: NetlifyEvent | NetlifyV2Request, context?: unknown) => Promise<HandlerResponse>, options: CreateRecordingRequestHandlerOptions): (event: NetlifyEvent | NetlifyV2Request, context?: unknown) => Promise<HandlerResponse>;
 
 /**
  * Creates `FinishRequestCallbacks` that send captured data to a remote

package/dist/index.js

@@ -578,7 +578,6 @@ async function finishRequest(requestContext, callbacks, response, options) {
 import crypto from "crypto";
 function createRecordingRequestHandler(handler, options) {
   return async (event, context) => {
-    const isV2 = isWebApiRequest(event);
     const requestId = crypto.randomUUID();
     setCurrentRequestId(requestId);
     const reqContext = startRequest(event);
@@ -612,18 +611,12 @@ function createRecordingRequestHandler(handler, options) {
           }
         )
       );
-      return isV2 ? toWebResponse(responseWithHeader) : responseWithHeader;
+      return responseWithHeader;
     }
     await finishRequest(reqContext, options.callbacks, response, finishOpts);
-    return isV2 ? toWebResponse(responseWithHeader) : responseWithHeader;
+    return responseWithHeader;
   };
 }
-function toWebResponse(result) {
-  return new Response(result.body, {
-    status: result.statusCode,
-    headers: result.headers
-  });
-}
 
 // src/remoteCallbacks.ts
 function remoteCallbacks(serviceUrl) {
@@ -1236,23 +1229,7 @@ async function databaseAuditEnsureLogTable(sql) {
       changed_cols TEXT[];
       req_id TEXT;
       call_idx INTEGER;
-      pk_col TEXT;
-      pk_val TEXT;
     BEGIN
-      -- Dynamically look up the primary key column for this table
-      SELECT a.attname INTO pk_col
-      FROM pg_index i
-      JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
-      WHERE i.indrelid = TG_RELID AND i.indisprimary
-      LIMIT 1;
-
-      -- Extract PK value from the appropriate record
-      IF TG_OP = 'DELETE' THEN
-        EXECUTE format('SELECT ($1.%I)::TEXT', pk_col) INTO pk_val USING OLD;
-      ELSE
-        EXECUTE format('SELECT ($1.%I)::TEXT', pk_col) INTO pk_val USING NEW;
-      END IF;
-
       -- Read application context injected by the network interceptor
       req_id := COALESCE(current_setting('app.replay_request_id', true), '');
       IF req_id = '' THEN req_id := NULL; END IF;
@@ -1265,7 +1242,7 @@ async function databaseAuditEnsureLogTable(sql) {
 
       IF TG_OP = 'INSERT' THEN
         INSERT INTO audit_log (table_name, record_id, action, new_data, replay_request_id, replay_request_call_index)
-        VALUES (TG_TABLE_NAME, pk_val, 'INSERT', to_jsonb(NEW), req_id, call_idx);
+        VALUES (TG_TABLE_NAME, NEW.id::TEXT, 'INSERT', to_jsonb(NEW), req_id, call_idx);
         RETURN NEW;
       ELSIF TG_OP = 'UPDATE' THEN
         SELECT ARRAY_AGG(n.key) INTO changed_cols
@@ -1274,11 +1251,11 @@ async function databaseAuditEnsureLogTable(sql) {
         WHERE o.value IS DISTINCT FROM n.value;
 
         INSERT INTO audit_log (table_name, record_id, action, old_data, new_data, changed_fields, replay_request_id, replay_request_call_index)
-        VALUES (TG_TABLE_NAME, pk_val, 'UPDATE', to_jsonb(OLD), to_jsonb(NEW), COALESCE(changed_cols, ARRAY[]::TEXT[]), req_id, call_idx);
+        VALUES (TG_TABLE_NAME, NEW.id::TEXT, 'UPDATE', to_jsonb(OLD), to_jsonb(NEW), COALESCE(changed_cols, ARRAY[]::TEXT[]), req_id, call_idx);
         RETURN NEW;
       ELSIF TG_OP = 'DELETE' THEN
         INSERT INTO audit_log (table_name, record_id, action, old_data, replay_request_id, replay_request_call_index)
-        VALUES (TG_TABLE_NAME, pk_val, 'DELETE', to_jsonb(OLD), req_id, call_idx);
+        VALUES (TG_TABLE_NAME, OLD.id::TEXT, 'DELETE', to_jsonb(OLD), req_id, call_idx);
         RETURN OLD;
       END IF;
       RETURN NULL;

package/package.json

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