@replayio-app-building/netlify-recorder 0.15.9 → 0.16.0

package/dist/index.d.ts

@@ -93,66 +93,24 @@ interface BlobData {
     handlerResponse?: HandlerResponse$1;
 }
 interface FinishRequestCallbacks {
-    /** Uploads serialized captured data and returns the blob URL. */
-    uploadBlob: (data: string) => Promise<string>;
     /**
-     * Stores request metadata in the database and returns the request ID.
+     * Stores the captured request data and returns the request ID.
      *
      * When `requestId` is provided (from `createRecordingRequestHandler`'s
      * `waitUntil` flow), the callback should use it as the row ID so the
-     * client-facing header and the stored record match.  When omitted, the
-     * callback generates its own ID (backward-compatible).
+     * client-facing header and the stored record match. When omitted, the
+     * callback generates its own ID.
      */
-    storeRequestData: (data: {
-        blobUrl: string;
+    storeRequest: (data: {
+        blobData: string;
         commitSha: string;
         branchName: string;
         repositoryUrl: string;
         handlerPath: string;
         /** Pre-generated request ID. Use as the row ID when provided. */
         requestId?: string;
-        /** Optional secret that restricts access to this request. */
-        secret?: string;
     }) => Promise<string>;
 }
-/**
- * Infrastructure credentials required to start a recording container.
- *
- * The container is started on Fly.io via the `@replayio/app-building` package.
- * It requires Infisical credentials (for secrets management inside the
- * container) and a Fly.io token + app name.
- *
- * These must be set as environment variables on the Netlify site:
- *   INFISICAL_CLIENT_ID, INFISICAL_CLIENT_SECRET,
- *   INFISICAL_PROJECT_ID, INFISICAL_ENVIRONMENT,
- *   FLY_API_TOKEN, FLY_APP_NAME
- */
-interface ContainerInfraConfig {
-    infisicalClientId: string;
-    infisicalClientSecret: string;
-    infisicalProjectId: string;
-    infisicalEnvironment: string;
-    flyToken: string;
-    flyApp: string;
-}
-interface EnsureRecordingOptions {
-    repositoryUrl: string;
-    /** Infrastructure credentials for starting the recording container. */
-    infraConfig?: ContainerInfraConfig;
-    /** Webhook URL the container can POST log entries to (optional). */
-    webhookUrl?: string;
-    /** Looks up request metadata by ID. */
-    lookupRequest: (requestId: string) => Promise<{
-        blobUrl: string;
-        commitSha: string;
-        branchName: string;
-        handlerPath: string;
-    }>;
-    /** Updates the request status (and optionally recording ID) in the database. */
-    updateStatus: (requestId: string, status: string, recordingId?: string) => Promise<void>;
-    /** Optional callback for the caller to emit structured log entries. */
-    onLog?: (level: "info" | "warn" | "error", message: string) => Promise<void>;
-}
 
 /**
  * Called at the beginning of a Netlify handler execution.
@@ -212,32 +170,16 @@ interface FinishRequestOptions {
     repositoryUrl?: string;
     /**
      * Pre-generated request ID. When provided, this ID is passed to the
-     * `storeRequestData` callback so the stored row matches the ID already
+     * `storeRequest` callback so the stored row matches the ID already
      * sent to the client in the `X-Replay-Request-Id` header.
-     *
-     * Used by `createRecordingRequestHandler` in the `waitUntil` flow where
-     * the response is returned before `finishRequest` runs.
      */
     requestId?: string;
-    /**
-     * Optional secret string. When set, the stored request is only
-     * accessible via API calls that provide the same secret value.
-     */
-    secret?: string;
 }
 /**
  * Called at the end of the handler execution.
  * Restores original globals, serializes all captured data,
- * uploads it as a JSON blob via the provided callback,
- * stores the request metadata, and sets the X-Replay-Request-Id header.
- *
- * **Important:** The returned response includes the `X-Replay-Request-Id`
- * header. You must send the returned response to the client — not the
- * original response object you passed in.
- *
- * Logs a warning to `console.warn` when the total finishRequest time or
- * individual callback steps exceed their thresholds, to help diagnose
- * slow blob uploads or database writes.
+ * stores the request via the provided callback, and sets the
+ * X-Replay-Request-Id header.
  */
 declare function finishRequest(requestContext: RequestContext, callbacks: FinishRequestCallbacks, response: FullHandlerResponse, options?: FinishRequestOptions): Promise<FullHandlerResponse>;
 
@@ -254,80 +196,15 @@ interface CreateRecordingRequestHandlerOptions extends FinishRequestOptions {
  *
  * Automatically calls `startRequest` before the handler and `finishRequest`
  * after, capturing all outbound network calls and environment variable reads.
- * On error, interceptors are cleaned up and the error is re-thrown.
+ * The captured data is stored via the provided callbacks.
  *
  * **Response timing:** When the Netlify Functions v2 `context` object is
  * available (with `waitUntil`), the response is returned to the client
  * **immediately** with a pre-generated `X-Replay-Request-Id` header. The
- * blob upload and metadata storage continue in the background via
- * `context.waitUntil()`. This avoids adding latency to the client response.
- *
- * When `context.waitUntil` is not available (v1 handlers or missing context),
- * the wrapper falls back to awaiting `finishRequest` before returning.
- *
- * For v2 handlers the request body is read from a clone internally — your
- * handler still receives the original request with an unconsumed body.
- *
- * @example v1 handler (NetlifyEvent)
- * ```typescript
- * import { createRecordingRequestHandler, remoteCallbacks } from "@replayio-app-building/netlify-recorder";
- *
- * const handler = createRecordingRequestHandler(
- *   async (event) => {
- *     const result = await myBusinessLogic(event.body);
- *     return {
- *       statusCode: 200,
- *       headers: { "Content-Type": "application/json" },
- *       body: JSON.stringify(result),
- *     };
- *   },
- *   {
- *     callbacks: remoteCallbacks("https://netlify-recorder-bm4wmw.netlify.app"),
- *     handlerPath: "netlify/functions/my-handler",
- *   }
- * );
- *
- * export { handler };
- * ```
- *
- * @example v2 handler (Web API Request)
- * ```typescript
- * import { createRecordingRequestHandler, remoteCallbacks } from "@replayio-app-building/netlify-recorder";
- *
- * export default createRecordingRequestHandler(
- *   async (req) => {
- *     // Body is still available — startRequest reads from a clone
- *     const body = await (req as Request).json();
- *     const result = await myBusinessLogic(body);
- *     return {
- *       statusCode: 200,
- *       headers: { "Content-Type": "application/json" },
- *       body: JSON.stringify(result),
- *     };
- *   },
- *   {
- *     callbacks: remoteCallbacks("https://netlify-recorder-bm4wmw.netlify.app"),
- *     handlerPath: "netlify/functions/my-handler",
- *   }
- * );
- * ```
+ * data storage continues in the background via `context.waitUntil()`.
  */
 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
- * Netlify Recorder service. This removes the need for the consuming app
- * to set up its own blob storage or database tables.
- *
- * The callbacks upload blob data and store request metadata via the
- * service's `/api/store-request` endpoint, which handles UploadThing
- * storage and database insertion.
- *
- * @param serviceUrl - Base URL of the Netlify Recorder service
- *   (e.g. "https://netlify-recorder-bm4wmw.netlify.app")
- */
-declare function remoteCallbacks(serviceUrl: string): FinishRequestCallbacks;
-
 /**
  * Redacts sensitive environment variable values from blob data.
  *
@@ -348,28 +225,6 @@ declare function remoteCallbacks(serviceUrl: string): FinishRequestCallbacks;
  */
 declare function redactBlobData(blobData: BlobData): BlobData;
 
-/**
- * Called by a background function to convert a request ID into a Replay recording ID.
- *
- * The function:
- *  1. Looks up request metadata (blob URL, commit, handler path).
- *  2. Delegates to `spawnRecordingContainer` which starts a detached Fly.io
- *     container, runs the recording script under replay-node, and uploads
- *     the resulting recording.
- *  3. Updates the request status with the recording ID.
- *
- * **Required infrastructure:** Infisical credentials and a Fly.io token/app.
- * See `ContainerInfraConfig` in types.ts for details. When these are not
- * configured the function fails with an actionable error message listing
- * the missing environment variables.
- */
-declare function ensureRequestRecording(requestId: string, options: EnsureRecordingOptions): Promise<string>;
-/**
- * Reads infrastructure config from environment variables.
- * Returns undefined if any required variable is missing.
- */
-declare function readInfraConfigFromEnv(): ContainerInfraConfig | undefined;
-
 interface RecordingResult {
     /** Whether a response mismatch was detected between capture and replay. */
     responseMismatch: boolean;
@@ -394,39 +249,49 @@ interface RecordingResult {
  */
 declare function createRequestRecording(blobUrlOrData: string | BlobData, handlerPath: string, requestInfo: RequestInfo): Promise<RecordingResult>;
 
+type SqlFunction$1 = (...args: any[]) => Promise<any[]>;
+interface BackendRequest {
+    id: string;
+    blob_data: string;
+    handler_path: string;
+    commit_sha: string;
+    branch_name: string;
+    repository_url: string | null;
+    status: string;
+    recording_id: string | null;
+    error_message: string | null;
+    created_at: string;
+    updated_at: string;
+}
 /**
- * Options for spawning a recording container from a blob URL.
- * This is the core building block — it knows nothing about request IDs or databases.
+ * Creates the `backend_requests` table. Call during schema initialization.
+ *
+ * Each package client stores captured request data in its own database
+ * using this table. The blob data (captured network calls, env reads, etc.)
+ * is stored directly in the `blob_data` column rather than in external
+ * blob storage.
  */
-interface SpawnRecordingContainerOptions {
-    /** URL (or data: URI) of the captured request blob JSON. */
-    blobUrl: string;
-    /** Handler file path relative to the app root (e.g. "netlify/functions/generate-haiku"). */
+declare function backendRequestsEnsureTable(sql: SqlFunction$1): Promise<void>;
+declare function backendRequestsInsert(sql: SqlFunction$1, data: {
+    id?: string;
+    blobData: string;
     handlerPath: string;
-    /** Git commit SHA to check out inside the container. */
     commitSha: string;
-    /** Git branch to clone. */
     branchName: string;
-    /** Git repository URL for the app. */
-    repositoryUrl: string;
-    /** Infrastructure credentials for Fly.io + Infisical. */
-    infraConfig: ContainerInfraConfig;
-    /** Optional webhook URL the container can POST log events to. */
-    logWebhookUrl?: string;
-    /** Optional callback for structured log entries. */
-    onLog?: (level: "info" | "warn" | "error", message: string) => Promise<void>;
-}
+    repositoryUrl?: string | null;
+}): Promise<string>;
+declare function backendRequestsGet(sql: SqlFunction$1, id: string): Promise<BackendRequest | null>;
+declare function backendRequestsGetBlobData(sql: SqlFunction$1, id: string): Promise<string | null>;
+declare function backendRequestsList(sql: SqlFunction$1, filters?: {
+    status?: string;
+    limit?: number;
+}): Promise<BackendRequest[]>;
+declare function backendRequestsUpdateStatus(sql: SqlFunction$1, id: string, status: string, recordingId?: string, errorMessage?: string): Promise<void>;
 /**
- * Spawns a detached Fly.io container that:
- *  1. Clones the app repo at the correct branch
- *  2. Checks out the exact commit
- *  3. Runs `scripts/create-request-recording.ts` under replay-node
- *  4. Uploads the resulting recording
- *  5. Outputs the recording ID
- *
- * Returns the recording ID on success, or throws on failure.
+ * Convenience helper: creates `FinishRequestCallbacks` that store
+ * captured request data directly in the `backend_requests` table.
  */
-declare function spawnRecordingContainer(options: SpawnRecordingContainerOptions): Promise<string>;
+declare function databaseCallbacks(sql: SqlFunction$1): FinishRequestCallbacks;
 
 type SqlFunction = (...args: any[]) => Promise<any[]>;
 /**
@@ -451,4 +316,4 @@ declare function databaseAuditDumpLogTable(sql: SqlFunction): Promise<Record<str
 
 declare function getCurrentRequestId(): string | null;
 
-export { type BlobData, type CapturedData, type ContainerInfraConfig, type CreateRecordingRequestHandlerOptions, type EnsureRecordingOptions, type EnvRead, type FinishRequestCallbacks, type FinishRequestOptions, type HandlerResponse$1 as HandlerResponse, type NetlifyEvent, type NetlifyV2Request, type NetworkCall, type RecordingResult, type RequestContext, type RequestInfo, type SpawnRecordingContainerOptions, createRecordingRequestHandler, createRequestRecording, databaseAuditDumpLogTable, databaseAuditEnsureLogTable, databaseAuditMonitorTable, ensureRequestRecording, finishRequest, getCurrentRequestId, readInfraConfigFromEnv, redactBlobData, remoteCallbacks, spawnRecordingContainer, startRequest };
+export { type BackendRequest, type BlobData, type CapturedData, type CreateRecordingRequestHandlerOptions, type EnvRead, type FinishRequestCallbacks, type FinishRequestOptions, type HandlerResponse$1 as HandlerResponse, type NetlifyEvent, type NetlifyV2Request, type NetworkCall, type RecordingResult, type RequestContext, type RequestInfo, backendRequestsEnsureTable, backendRequestsGet, backendRequestsGetBlobData, backendRequestsInsert, backendRequestsList, backendRequestsUpdateStatus, createRecordingRequestHandler, createRequestRecording, databaseAuditDumpLogTable, databaseAuditEnsureLogTable, databaseAuditMonitorTable, databaseCallbacks, finishRequest, getCurrentRequestId, redactBlobData, startRequest };

package/dist/index.js

@@ -490,7 +490,6 @@ function redactBlobData(blobData) {
 
 // src/finishRequest.ts
 var SLOW_THRESHOLD_MS = 2e3;
-var SLOW_STEP_THRESHOLD_MS = 1e3;
 async function finishRequest(requestContext, callbacks, response, options) {
   const finishStart = Date.now();
   requestContext.cleanup();
@@ -535,34 +534,20 @@ async function finishRequest(requestContext, callbacks, response, options) {
   };
   const blobData = redactBlobData(rawBlobData);
   const blobContent = JSON.stringify(blobData);
-  const uploadStart = Date.now();
-  const blobUrl = await callbacks.uploadBlob(blobContent);
-  const uploadDuration = Date.now() - uploadStart;
-  if (uploadDuration > SLOW_STEP_THRESHOLD_MS) {
-    console.warn(
-      `netlify-recorder: uploadBlob took ${uploadDuration}ms (handler: ${handlerPath})`
-    );
-  }
   const storeStart = Date.now();
-  const storedRequestId = await callbacks.storeRequestData({
-    blobUrl,
+  const storedRequestId = await callbacks.storeRequest({
+    blobData: blobContent,
     commitSha,
     branchName,
     repositoryUrl,
     handlerPath,
-    requestId: options?.requestId,
-    secret: options?.secret
+    requestId: options?.requestId
   });
   const storeDuration = Date.now() - storeStart;
-  if (storeDuration > SLOW_STEP_THRESHOLD_MS) {
-    console.warn(
-      `netlify-recorder: storeRequestData took ${storeDuration}ms (handler: ${handlerPath})`
-    );
-  }
   const totalDuration = Date.now() - finishStart;
   if (totalDuration > SLOW_THRESHOLD_MS) {
     console.warn(
-      `netlify-recorder: finishRequest took ${totalDuration}ms total (upload: ${uploadDuration}ms, store: ${storeDuration}ms, handler: ${handlerPath})`
+      `netlify-recorder: finishRequest took ${totalDuration}ms total (store: ${storeDuration}ms, handler: ${handlerPath})`
     );
   }
   return {
@@ -618,284 +603,6 @@ function createRecordingRequestHandler(handler, options) {
   };
 }
 
-// src/remoteCallbacks.ts
-function remoteCallbacks(serviceUrl) {
-  const base = serviceUrl.replace(/\/+$/, "");
-  let pendingBlobData;
-  return {
-    uploadBlob: async (data) => {
-      pendingBlobData = data;
-      return "__pending__";
-    },
-    storeRequestData: async (metadata) => {
-      const blobData = pendingBlobData;
-      pendingBlobData = void 0;
-      if (!blobData) {
-        throw new Error(
-          "remoteCallbacks: uploadBlob must be called before storeRequestData"
-        );
-      }
-      const res = await fetch(
-        `${base}/api/store-request`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({
-            blobData,
-            handlerPath: metadata.handlerPath,
-            commitSha: metadata.commitSha,
-            branchName: metadata.branchName,
-            repositoryUrl: metadata.repositoryUrl,
-            requestId: metadata.requestId,
-            secret: metadata.secret
-          })
-        }
-      );
-      if (!res.ok) {
-        const errBody = await res.text().catch(() => "(unreadable)");
-        throw new Error(
-          `Netlify Recorder store-request failed: ${res.status} ${errBody}`
-        );
-      }
-      const result = await res.json();
-      return result.requestId;
-    }
-  };
-}
-
-// src/spawnRecordingContainer.ts
-async function spawnRecordingContainer(options) {
-  const {
-    blobUrl,
-    handlerPath,
-    commitSha,
-    branchName,
-    repositoryUrl,
-    infraConfig,
-    logWebhookUrl,
-    onLog
-  } = options;
-  const emit = async (level, message) => {
-    if (onLog) {
-      try {
-        await onLog(level, message);
-      } catch {
-      }
-    }
-  };
-  await emit("info", "Logging in to Infisical");
-  const {
-    infisicalLogin,
-    startContainer,
-    FileContainerRegistry,
-    httpGet,
-    httpOptsFor
-  } = await import("@replayio/app-building");
-  const infisicalToken = await infisicalLogin(
-    infraConfig.infisicalClientId,
-    infraConfig.infisicalClientSecret
-  );
-  const infisicalConfig = {
-    token: infisicalToken,
-    projectId: infraConfig.infisicalProjectId,
-    environment: infraConfig.infisicalEnvironment
-  };
-  const registry = new FileContainerRegistry("/tmp/netlify-recorder-containers.json");
-  const initialPrompt = [
-    `IMPORTANT: Follow these steps EXACTLY. Run each command as shown. Print ALL output.`,
-    `Do NOT explore the codebase, read AGENTS.md, or deviate from these steps.`,
-    `Do NOT attempt to debug, fix, shim, or work around ANY errors. If a command fails,`,
-    `print the full error output and move on to the next step. Errors during handler replay`,
-    `(like "No more recorded network calls" or DB errors) are EXPECTED and harmless.`,
-    ``,
-    `=== Step 1: Install dependencies ===`,
-    `cd /repo/apps/netlify-recorder && npm install 2>&1`,
-    ``,
-    `=== Step 2: Checkout the exact commit ===`,
-    `git fetch origin ${commitSha} 2>&1 || git fetch --all 2>&1`,
-    `git checkout ${commitSha} 2>&1`,
-    ``,
-    `=== Step 3: Verify recording script exists ===`,
-    `ls -la /repo/apps/netlify-recorder/scripts/create-request-recording.ts`,
-    `If the file does NOT exist, print "ERROR: create-request-recording.ts not found" and STOP.`,
-    ``,
-    `=== Step 4: Pre-compile for replay-node (Node v16) ===`,
-    `replay-node is Node v16 \u2014 it cannot run TypeScript or use modern APIs directly.`,
-    `You MUST compile everything with esbuild first. Run these commands exactly:`,
-    ``,
-    `# Install undici for web API polyfills (fetch, Headers, Response):`,
-    `cd /repo/apps/netlify-recorder && npm install undici@5 2>&1`,
-    ``,
-    `# Create the polyfill loader:`,
-    `cat > /tmp/web-polyfill.cjs << 'POLYFILL'`,
-    `try {`,
-    `  var u = require("undici");`,
-    `  if (!globalThis.fetch) globalThis.fetch = u.fetch;`,
-    `  if (!globalThis.Headers) globalThis.Headers = u.Headers;`,
-    `  if (!globalThis.Response) globalThis.Response = u.Response;`,
-    `  if (!globalThis.Request) globalThis.Request = u.Request;`,
-    `} catch(e) { console.error("polyfill warning:", e.message); }`,
-    `POLYFILL`,
-    ``,
-    `# Compile the recording script (bundles all local TS dependencies):`,
-    `npx esbuild scripts/create-request-recording.ts \\`,
-    `  --bundle --platform=node --target=node16 --format=cjs \\`,
-    `  --outfile=/tmp/create-recording.cjs 2>&1`,
-    ``,
-    `# Compile the handler (bundles everything including node_modules):`,
-    `npx esbuild ${handlerPath}.ts \\`,
-    `  --bundle --platform=node --target=node16 --format=cjs \\`,
-    `  --outfile=/tmp/handler.cjs 2>&1`,
-    ``,
-    `=== Step 5: Run under replay-node ===`,
-    `This MUST use replay-node so the execution is recorded. Run exactly:`,
-    ``,
-    `cd /repo/apps/netlify-recorder && npx @replayio/node \\`,
-    `  -r /tmp/web-polyfill.cjs /tmp/create-recording.cjs \\`,
-    `  --blob-url '${blobUrl}' \\`,
-    `  --handler-path '/tmp/handler.cjs' 2>&1`,
-    ``,
-    `The output will show captured data being replayed. Errors like "No more recorded`,
-    `network calls" or "DATABASE_URL" errors are EXPECTED \u2014 they come from post-handler`,
-    `DB operations that were not in the original blob. Do NOT try to fix these.`,
-    ``,
-    `=== Step 6: Upload the recording ===`,
-    `exec-secrets RECORD_REPLAY_API_KEY -- npx replayio upload --all 2>&1`,
-    ``,
-    `Find the recording ID (UUID) in the upload output and print:`,
-    `  recording: <recording-id>`,
-    ``,
-    `Then output <DONE>.`
-  ].join("\n");
-  await emit("info", "Starting detached container on Fly.io");
-  const state = await startContainer(
-    {
-      infisical: infisicalConfig,
-      registry,
-      flyToken: infraConfig.flyToken,
-      flyApp: infraConfig.flyApp,
-      detached: true,
-      initialPrompt,
-      webhookUrl: logWebhookUrl
-    },
-    {
-      repoUrl: repositoryUrl,
-      cloneBranch: branchName
-    }
-  );
-  await emit("info", `Container started: ${state.containerName} at ${state.baseUrl}`);
-  const maxWaitMs = 10 * 60 * 1e3;
-  const pollIntervalMs = 1e4;
-  const deadline = Date.now() + maxWaitMs;
-  let containerDone = false;
-  while (Date.now() < deadline) {
-    try {
-      const status = await httpGet(`${state.baseUrl}/status`, httpOptsFor(state));
-      if (status?.state === "stopped" || status?.state === "stopping") {
-        containerDone = true;
-        break;
-      }
-    } catch {
-      containerDone = true;
-      break;
-    }
-    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
-  }
-  if (!containerDone) {
-    await emit("warn", "Container did not finish within 10 minutes");
-  }
-  let recordingId = null;
-  try {
-    const logs = await httpGet(`${state.baseUrl}/logs?offset=0`, httpOptsFor(state));
-    if (typeof logs === "string") {
-      const match = logs.match(/recording[:\s]+([a-f0-9-]{36})/i);
-      if (match?.[1]) {
-        recordingId = match[1];
-      }
-    }
-  } catch {
-    await emit("warn", "Could not read container logs after exit");
-  }
-  if (!recordingId) {
-    await emit("error", "Container completed but no recording ID was found in output");
-    throw new Error("Recording creation failed: no recording ID returned from container");
-  }
-  await emit("info", `Container completed \u2014 recording ID: ${recordingId}`);
-  return recordingId;
-}
-
-// src/ensureRequestRecording.ts
-async function ensureRequestRecording(requestId, options) {
-  const { repositoryUrl, infraConfig, webhookUrl, lookupRequest, updateStatus, onLog } = options;
-  const emit = async (level, message) => {
-    if (onLog) {
-      try {
-        await onLog(level, message);
-      } catch {
-      }
-    }
-  };
-  await updateStatus(requestId, "processing");
-  try {
-    if (!infraConfig) {
-      const missing = getMissingInfraVars();
-      throw new Error(
-        `Container infrastructure not configured. Missing environment variables: ${missing.join(", ")}. These must be set on the Netlify site for recording creation to work.`
-      );
-    }
-    const requestData = await lookupRequest(requestId);
-    await emit("info", `Request data retrieved \u2014 handler: ${requestData.handlerPath}, branch: ${requestData.branchName}, commit: ${requestData.commitSha}`);
-    const recordingId = await spawnRecordingContainer({
-      blobUrl: requestData.blobUrl,
-      handlerPath: requestData.handlerPath,
-      commitSha: requestData.commitSha,
-      branchName: requestData.branchName,
-      repositoryUrl,
-      infraConfig,
-      logWebhookUrl: webhookUrl,
-      onLog
-    });
-    await emit("info", `Recording created successfully: ${recordingId}`);
-    await updateStatus(requestId, "recorded", recordingId);
-    return recordingId;
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    await emit("error", `Recording creation failed: ${message}`);
-    await updateStatus(requestId, "failed");
-    throw err;
-  }
-}
-function getMissingInfraVars() {
-  const required = [
-    "INFISICAL_CLIENT_ID",
-    "INFISICAL_CLIENT_SECRET",
-    "INFISICAL_PROJECT_ID",
-    "INFISICAL_ENVIRONMENT",
-    "FLY_API_TOKEN",
-    "FLY_APP_NAME"
-  ];
-  return required.filter((name) => !process.env[name]);
-}
-function readInfraConfigFromEnv() {
-  const clientId = process.env.INFISICAL_CLIENT_ID;
-  const clientSecret = process.env.INFISICAL_CLIENT_SECRET;
-  const projectId = process.env.INFISICAL_PROJECT_ID;
-  const environment = process.env.INFISICAL_ENVIRONMENT;
-  const flyToken = process.env.FLY_API_TOKEN;
-  const flyApp = process.env.FLY_APP_NAME;
-  if (!clientId || !clientSecret || !projectId || !environment || !flyToken || !flyApp) {
-    return void 0;
-  }
-  return {
-    infisicalClientId: clientId,
-    infisicalClientSecret: clientSecret,
-    infisicalProjectId: projectId,
-    infisicalEnvironment: environment,
-    flyToken,
-    flyApp
-  };
-}
-
 // src/createRequestRecording.ts
 async function createRequestRecording(blobUrlOrData, handlerPath, requestInfo) {
   let blobData;
@@ -1203,6 +910,131 @@ async function createRequestRecording(blobUrlOrData, handlerPath, requestInfo) {
   return result;
 }
 
+// src/backendRequests.ts
+async function backendRequestsEnsureTable(sql) {
+  await sql`
+    CREATE TABLE IF NOT EXISTS backend_requests (
+      id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+      blob_data TEXT NOT NULL,
+      handler_path TEXT NOT NULL,
+      commit_sha TEXT NOT NULL,
+      branch_name TEXT NOT NULL DEFAULT 'main',
+      repository_url TEXT,
+      status TEXT NOT NULL DEFAULT 'captured'
+        CHECK (status IN ('captured', 'queued', 'processing', 'recorded', 'failed')),
+      recording_id TEXT,
+      error_message TEXT,
+      created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+      updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+    )
+  `;
+  await sql`
+    CREATE INDEX IF NOT EXISTS idx_backend_requests_status ON backend_requests (status)
+  `;
+  await sql`
+    CREATE INDEX IF NOT EXISTS idx_backend_requests_created_at ON backend_requests (created_at DESC)
+  `;
+}
+async function backendRequestsInsert(sql, data) {
+  if (data.id) {
+    await sql`
+      INSERT INTO backend_requests (id, blob_data, handler_path, commit_sha, branch_name, repository_url)
+      VALUES (
+        ${data.id}::uuid,
+        ${data.blobData},
+        ${data.handlerPath},
+        ${data.commitSha},
+        ${data.branchName},
+        ${data.repositoryUrl ?? null}
+      )
+    `;
+    return data.id;
+  }
+  const rows = await sql`
+    INSERT INTO backend_requests (blob_data, handler_path, commit_sha, branch_name, repository_url)
+    VALUES (
+      ${data.blobData},
+      ${data.handlerPath},
+      ${data.commitSha},
+      ${data.branchName},
+      ${data.repositoryUrl ?? null}
+    )
+    RETURNING id
+  `;
+  return rows[0]?.id ?? "";
+}
+async function backendRequestsGet(sql, id) {
+  const rows = await sql`
+    SELECT id, blob_data, handler_path, commit_sha, branch_name, repository_url,
+           status, recording_id, error_message, created_at, updated_at
+    FROM backend_requests WHERE id = ${id}
+  `;
+  return rows[0] ?? null;
+}
+async function backendRequestsGetBlobData(sql, id) {
+  const rows = await sql`
+    SELECT blob_data FROM backend_requests WHERE id = ${id}
+  `;
+  return rows[0]?.blob_data ?? null;
+}
+async function backendRequestsList(sql, filters) {
+  const limit = filters?.limit ?? 50;
+  if (filters?.status) {
+    const rows2 = await sql`
+      SELECT id, blob_data, handler_path, commit_sha, branch_name, repository_url,
+             status, recording_id, error_message, created_at, updated_at
+      FROM backend_requests
+      WHERE status = ${filters.status}
+      ORDER BY created_at DESC
+      LIMIT ${limit}
+    `;
+    return rows2;
+  }
+  const rows = await sql`
+    SELECT id, blob_data, handler_path, commit_sha, branch_name, repository_url,
+           status, recording_id, error_message, created_at, updated_at
+    FROM backend_requests
+    ORDER BY created_at DESC
+    LIMIT ${limit}
+  `;
+  return rows;
+}
+async function backendRequestsUpdateStatus(sql, id, status, recordingId, errorMessage) {
+  if (recordingId) {
+    await sql`
+      UPDATE backend_requests
+      SET status = ${status}, recording_id = ${recordingId}, updated_at = NOW()
+      WHERE id = ${id}
+    `;
+  } else if (errorMessage) {
+    await sql`
+      UPDATE backend_requests
+      SET status = ${status}, error_message = ${errorMessage}, updated_at = NOW()
+      WHERE id = ${id}
+    `;
+  } else {
+    await sql`
+      UPDATE backend_requests
+      SET status = ${status}, updated_at = NOW()
+      WHERE id = ${id}
+    `;
+  }
+}
+function databaseCallbacks(sql) {
+  return {
+    storeRequest: async (data) => {
+      return backendRequestsInsert(sql, {
+        id: data.requestId,
+        blobData: data.blobData,
+        handlerPath: data.handlerPath,
+        commitSha: data.commitSha,
+        branchName: data.branchName,
+        repositoryUrl: data.repositoryUrl
+      });
+    }
+  };
+}
+
 // src/databaseAudit.ts
 async function databaseAuditEnsureLogTable(sql) {
   await sql`
@@ -1283,17 +1115,20 @@ async function databaseAuditDumpLogTable(sql) {
   return rows;
 }
 export {
+  backendRequestsEnsureTable,
+  backendRequestsGet,
+  backendRequestsGetBlobData,
+  backendRequestsInsert,
+  backendRequestsList,
+  backendRequestsUpdateStatus,
   createRecordingRequestHandler,
   createRequestRecording,
   databaseAuditDumpLogTable,
   databaseAuditEnsureLogTable,
   databaseAuditMonitorTable,
-  ensureRequestRecording,
+  databaseCallbacks,
   finishRequest,
   getCurrentRequestId,
-  readInfraConfigFromEnv,
   redactBlobData,
-  remoteCallbacks,
-  spawnRecordingContainer,
   startRequest
 };

package/package.json

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