@sixb/sqlite 0.1.1 → 0.1.2

package/src/sync-run-storage.ts

@@ -1,17 +1,24 @@
 import type { Database } from "bun:sqlite"
 import type { JsonValue } from "@sixb/core"
+import { parseSixbFailure, serializeSixbFailure } from "@sixb/core/internal/errors"
+import { assertSyncRunExecution } from "@sixb/core/internal/sync-run-storage-provider"
 import type {
+  ExecutionStorage,
   FinishSyncRunInput,
   ListLatestSyncRunsInput,
   ListLatestSyncRunsResult,
   ListSyncRunsInput,
   ListSyncRunsResult,
+  QueueSyncRunInput,
   StartSyncRunInput,
-  SyncRunFailure,
   SyncRunRecord,
   SyncRunStorage,
 } from "@sixb/core/storage"
-import { SyncRunError } from "@sixb/core/storage"
+import {
+  canRequeueSyncRunAfterEnqueueFailure,
+  SYNC_RUN_FAILURE_CODES,
+  SyncRunError,
+} from "@sixb/core/storage"
 import { queryLatestRunsByOwnerId } from "./latest-run-query"
 import { installFreshSqliteSchema } from "./migrations"
 import {
@@ -27,6 +34,8 @@ import {
 } from "./transactions"
 
 export interface SqliteSyncRunStorageOptions {
+  /** Execution lookup sharing the same provider transaction. */
+  executions: ExecutionStorage
   /** Path to SQLite database file. Defaults to ':memory:' for in-memory database. */
   path?: string
   /** Internal shared connection used by bundled SqliteStorage. */
@@ -36,18 +45,27 @@ export interface SqliteSyncRunStorageOptions {
 export class SqliteSyncRunStorage implements SyncRunStorage {
   private readonly connection: SqliteStoreConnection
   private readonly db: Database
+  private readonly executions: ExecutionStorage
 
-  constructor(options: SqliteSyncRunStorageOptions = {}) {
+  constructor(options: SqliteSyncRunStorageOptions) {
     this.connection = openSqliteStoreConnection(options)
     this.db = this.connection.db
+    this.executions = options.executions
 
     if (this.connection.installFreshSchema) {
       installFreshSqliteSchema(this.db)
     }
   }
 
-  async start(input: StartSyncRunInput): Promise<SyncRunRecord> {
-    const startedAt = input.startedAt ?? new Date()
+  async queue(input: QueueSyncRunInput): Promise<SyncRunRecord> {
+    const queuedAt = input.queuedAt ?? new Date()
+    await assertSyncRunExecution({
+      executions: this.executions,
+      projectId: input.projectId,
+      executionId: input.executionId,
+      runId: input.id,
+      syncId: input.syncId,
+    })
 
     try {
       this.db
@@ -56,32 +74,33 @@ export class SqliteSyncRunStorage implements SyncRunStorage {
           INSERT INTO sync_runs (
             project_id,
             id,
+            execution_id,
             sync_id,
             dataset_id,
             mode,
             status,
+            queued_at,
             started_at,
             expected_latest_version_id,
             commit_message
-          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)
         `
         )
         .run(
           input.projectId,
           input.id,
+          input.executionId,
           input.syncId,
           input.datasetId,
           input.mode,
-          "running",
-          startedAt.toISOString(),
+          "queued",
+          queuedAt.toISOString(),
           input.expectedLatestVersionId ?? null,
           input.commitMessage ?? null
         )
     } catch (error) {
       if (isUniqueConstraintError(error)) {
-        throw new SyncRunError(
-          `[SixbSqlite] Sync run '${input.id}' already exists for project '${input.projectId}'.`
-        )
+        return this.requeueAfterEnqueueFailure(input, queuedAt)
       }
 
       throw error
@@ -97,6 +116,70 @@ export class SqliteSyncRunStorage implements SyncRunStorage {
     return record
   }
 
+  private async requeueAfterEnqueueFailure(
+    input: QueueSyncRunInput,
+    queuedAt: Date
+  ): Promise<SyncRunRecord> {
+    return this.db.transaction(() => {
+      const existing = this.db
+        .query("SELECT * FROM sync_runs WHERE project_id = ? AND id = ?")
+        .get(input.projectId, input.id) as DatabaseRow | null
+      if (!existing || !canRequeueSyncRunAfterEnqueueFailure(rowToSyncRunRecord(existing), input)) {
+        throw new SyncRunError(
+          `[SixbSqlite] Sync run '${input.id}' already exists for project '${input.projectId}'.`
+        )
+      }
+
+      this.db
+        .query(
+          `
+          UPDATE sync_runs
+          SET status = ?, queued_at = ?, started_at = NULL, finished_at = NULL,
+              rows_read = NULL, output_version_id = NULL, error = NULL, checkpoint = NULL
+          WHERE project_id = ? AND id = ?
+        `
+        )
+        .run("queued", queuedAt.toISOString(), input.projectId, input.id)
+
+      const updated = this.db
+        .query("SELECT * FROM sync_runs WHERE project_id = ? AND id = ?")
+        .get(input.projectId, input.id) as DatabaseRow
+      return rowToSyncRunRecord(updated)
+    })()
+  }
+
+  async start(input: StartSyncRunInput): Promise<SyncRunRecord> {
+    const result = this.db
+      .query(
+        `
+        UPDATE sync_runs
+        SET status = ?, started_at = ?, error = NULL
+        WHERE project_id = ? AND id = ? AND status = ?
+      `
+      )
+      .run(
+        "running",
+        (input.startedAt ?? new Date()).toISOString(),
+        input.projectId,
+        input.id,
+        "queued"
+      )
+    if (result.changes > 0) {
+      const record = await this.getById({ projectId: input.projectId, id: input.id })
+      if (record) return record
+    }
+
+    const existing = await this.getById({ projectId: input.projectId, id: input.id })
+    if (!existing) {
+      throw new SyncRunError(
+        `[SixbSqlite] Sync run '${input.id}' not found for project '${input.projectId}'.`
+      )
+    }
+    throw new SyncRunError(
+      `[SixbSqlite] Sync run '${input.id}' cannot start from status '${existing.status}'.`
+    )
+  }
+
   async finish(input: FinishSyncRunInput): Promise<SyncRunRecord> {
     return this.db.transaction(() => {
       const existing = this.db
@@ -109,6 +192,17 @@ export class SqliteSyncRunStorage implements SyncRunStorage {
         )
       }
 
+      const enqueueFailure =
+        input.status === "failed" && input.error.code === "queue.enqueue_failed"
+      if (
+        (enqueueFailure && existing.status !== "queued") ||
+        (!enqueueFailure && existing.status !== "running")
+      ) {
+        throw new SyncRunError(
+          `[SixbSqlite] Sync run '${input.id}' cannot finish from status '${existing.status}'.`
+        )
+      }
+
       if (input.status === "succeeded") {
         if (input.output && input.output.datasetId !== existing.dataset_id) {
           throw new SyncRunError(
@@ -131,8 +225,7 @@ export class SqliteSyncRunStorage implements SyncRunStorage {
             finished_at = ?,
             rows_read = ?,
             output_version_id = ?,
-            error_name = ?,
-            error_message = ?,
+            error = ?,
             checkpoint = ?
           WHERE project_id = ? AND id = ?
         `
@@ -144,8 +237,9 @@ export class SqliteSyncRunStorage implements SyncRunStorage {
             ? input.rowsRead
             : (input.rowsRead ?? existing.rows_read ?? null),
           input.status === "succeeded" ? (input.output?.versionId ?? null) : null,
-          input.status === "succeeded" ? null : (input.error?.name ?? null),
-          input.status === "succeeded" ? null : (input.error?.message ?? null),
+          input.status === "succeeded" || input.error === undefined
+            ? null
+            : serializeSixbFailure(input.error, SYNC_RUN_FAILURE_CODES),
           input.status === "succeeded" ? serializeCheckpoint(input.checkpoint) : null,
           input.projectId,
           input.id
@@ -194,7 +288,7 @@ export class SqliteSyncRunStorage implements SyncRunStorage {
       args.push(input.datasetId)
     }
 
-    appendRunListFilters(whereClauses, args, input)
+    appendRunListFilters(whereClauses, args, input, "COALESCE(started_at, queued_at)")
 
     const { rows, total, hasMore } = queryRunList<DatabaseRow>({
       db: this.db,
@@ -241,26 +335,17 @@ function parseCheckpoint(value: string | null | undefined): JsonValue | undefine
   return value != null ? (JSON.parse(value) as JsonValue) : undefined
 }
 
-function toSyncRunFailure(row: DatabaseRow): SyncRunFailure | undefined {
-  if (!row.error_message) {
-    return undefined
-  }
-
-  return {
-    name: row.error_name ?? undefined,
-    message: row.error_message,
-  }
-}
-
 function rowToSyncRunRecord(row: DatabaseRow): SyncRunRecord {
   return {
     id: row.id,
     projectId: row.project_id,
+    executionId: row.execution_id,
     syncId: row.sync_id,
     datasetId: row.dataset_id,
     mode: row.mode,
     status: row.status,
-    startedAt: new Date(row.started_at),
+    queuedAt: new Date(row.queued_at),
+    startedAt: row.started_at ? new Date(row.started_at) : undefined,
     finishedAt: row.finished_at ? new Date(row.finished_at) : undefined,
     rowsRead: row.rows_read ?? undefined,
     output: row.output_version_id
@@ -271,7 +356,7 @@ function rowToSyncRunRecord(row: DatabaseRow): SyncRunRecord {
       : undefined,
     expectedLatestVersionId: row.expected_latest_version_id ?? undefined,
     commitMessage: row.commit_message ?? undefined,
-    error: toSyncRunFailure(row),
+    error: row.error === null ? undefined : parseSixbFailure(row.error, SYNC_RUN_FAILURE_CODES),
     checkpoint: parseCheckpoint(row.checkpoint),
   }
 }
@@ -283,17 +368,18 @@ function isUniqueConstraintError(error: unknown): boolean {
 interface DatabaseRow {
   project_id: string
   id: string
+  execution_id: string
   sync_id: string
   dataset_id: string
   mode: SyncRunRecord["mode"]
   status: SyncRunRecord["status"]
-  started_at: string
+  queued_at: string
+  started_at: string | null
   finished_at: string | null
   rows_read: number | null
   output_version_id: string | null
   expected_latest_version_id: string | null
   commit_message: string | null
-  error_name: string | null
-  error_message: string | null
+  error: string | null
   checkpoint: string | null
 }

package/src/testing.ts

@@ -0,0 +1,20 @@
+export interface SqliteStorageTestingAdapter {
+  advanceConnectorConnectionTime(durationMs: number): void
+}
+
+const adapters = new WeakMap<object, SqliteStorageTestingAdapter>()
+
+export function registerSqliteStorageTestingAdapter(
+  storage: object,
+  advanceConnectorConnectionTime: (durationMs: number) => void
+): void {
+  adapters.set(storage, {
+    advanceConnectorConnectionTime,
+  })
+}
+
+export function getSqliteStorageTestingAdapter(storage: object): SqliteStorageTestingAdapter {
+  const adapter = adapters.get(storage)
+  if (!adapter) throw new Error("[SixbSqlite] Storage testing adapter is unavailable.")
+  return adapter
+}

package/src/transactions.ts

@@ -12,6 +12,7 @@ export interface SqliteStoreConnection {
 export interface SqliteStoreConnectionOptions {
   readonly path?: string
   readonly connection?: SqliteStoreConnection
+  readonly readonly?: boolean
 }
 
 export function openSqliteStoreConnection(
@@ -26,13 +27,14 @@ export function openSqliteStoreConnection(
   }
 
   const path = options.path ?? ":memory:"
-  if (path !== ":memory:") mkdirSync(dirname(path), { recursive: true })
-  const db = new SqliteDatabase(path)
+  if (path !== ":memory:" && !options.readonly) mkdirSync(dirname(path), { recursive: true })
+  const db = new SqliteDatabase(path, options.readonly ? { readonly: true } : undefined)
   db.run("PRAGMA foreign_keys = ON")
+  db.run("PRAGMA busy_timeout = 5000")
   return {
     db,
     ownsConnection: true,
-    installFreshSchema: path === ":memory:",
+    installFreshSchema: path === ":memory:" && !options.readonly,
   }
 }
 
@@ -64,6 +66,11 @@ export function runImmediateTransaction<T>(db: Database, run: () => T): T {
   }
 }
 
+/** Lets timers and request handlers run between bounded synchronous SQLite chunks. */
+export function yieldSqliteEventLoop(): Promise<void> {
+  return new Promise((resolve) => setImmediate(resolve))
+}
+
 export async function runImmediateTransactionAsync<T>(
   db: Database,
   run: () => Promise<T> | T

package/src/webhook-run-storage.ts

@@ -1,13 +1,18 @@
 import type { Database } from "bun:sqlite"
+import { parseSixbFailure, serializeSixbFailure } from "@sixb/core/internal/errors"
+import { assertWebhookRunExecution } from "@sixb/core/internal/webhook-run-storage-provider"
 import type {
+  ExecutionStorage,
   FinishWebhookRunInput,
+  GetWebhookRunByDeliveryInput,
   ListWebhookRunsInput,
   ListWebhookRunsResult,
+  RestartWebhookRunInput,
   StartWebhookRunInput,
   WebhookRunRecord,
   WebhookRunStorage,
 } from "@sixb/core/storage"
-import { WebhookRunError } from "@sixb/core/storage"
+import { canRetryWebhookRun, WEBHOOK_RUN_FAILURE_CODES, WebhookRunError } from "@sixb/core/storage"
 import { installFreshSqliteSchema } from "./migrations"
 import {
   appendRunListFilters,
@@ -23,6 +28,8 @@ import {
 } from "./transactions"
 
 export interface SqliteWebhookRunStorageOptions {
+  /** Execution lookup sharing the same provider transaction. */
+  executions: ExecutionStorage
   /** Path to SQLite database file. Defaults to ':memory:' for in-memory database. */
   path?: string
   /** Internal shared connection used by bundled SqliteStorage. */
@@ -32,80 +39,112 @@ export interface SqliteWebhookRunStorageOptions {
 export class SqliteWebhookRunStorage implements WebhookRunStorage {
   private readonly connection: SqliteStoreConnection
   private readonly db: Database
+  private readonly executions: ExecutionStorage
 
-  constructor(options: SqliteWebhookRunStorageOptions = {}) {
+  constructor(options: SqliteWebhookRunStorageOptions) {
     this.connection = openSqliteStoreConnection(options)
     this.db = this.connection.db
+    this.executions = options.executions
 
-    if (this.connection.installFreshSchema) {
-      installFreshSqliteSchema(this.db)
-    }
+    if (this.connection.installFreshSchema) installFreshSqliteSchema(this.db)
   }
 
   async start(input: StartWebhookRunInput): Promise<WebhookRunRecord> {
     const startedAt = input.startedAt ?? new Date()
+    await assertWebhookRunExecution({
+      executions: this.executions,
+      projectId: input.projectId,
+      executionId: input.executionId,
+      runId: input.id,
+      route: input.route,
+    })
 
     try {
       this.db
         .query(
           `
           INSERT INTO webhook_runs (
-            project_id,
-            id,
-            connector_id,
-            webhook_id,
-            status,
-            method,
-            route,
-            started_at
-          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            project_id, id, execution_id, connector_id, webhook_id, status, method, route,
+            started_at, request_body_bytes, request_body_sha256, idempotency_key
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         `
         )
         .run(
           input.projectId,
           input.id,
+          input.executionId,
           input.connectorId,
           input.webhookId,
           "running",
           input.method,
           input.route,
-          startedAt.toISOString()
+          startedAt.toISOString(),
+          input.requestBodyBytes,
+          input.requestBodySha256,
+          input.idempotencyKey ?? null
         )
     } catch (error) {
       if (isUniqueConstraintError(error)) {
         throw new WebhookRunError(
-          `[SixbSqlite] Webhook run '${input.id}' already exists for project '${input.projectId}'.`
+          `[SixbSqlite] Webhook run '${input.id}' or delivery key already exists for project '${input.projectId}'.`,
+          "duplicate_run"
         )
       }
-
       throw error
     }
 
-    const record = await this.getById({ projectId: input.projectId, id: input.id })
-    if (!record) {
-      throw new WebhookRunError(
-        `[SixbSqlite] Failed to load webhook run '${input.id}' for project '${input.projectId}'.`
-      )
-    }
+    return this.requireWebhookRun(input.projectId, input.id)
+  }
+
+  async restart(input: RestartWebhookRunInput): Promise<WebhookRunRecord> {
+    return this.db.transaction(() => {
+      const existing = this.getWebhookRunRow(input.projectId, input.id)
+      if (!existing) {
+        throw new WebhookRunError(
+          `[SixbSqlite] Webhook run '${input.id}' not found for project '${input.projectId}'.`,
+          "not_found"
+        )
+      }
+      if (!canRetryWebhookRun(rowToWebhookRunRecord(existing))) {
+        throw new WebhookRunError(
+          `[SixbSqlite] Webhook run '${input.id}' cannot restart from status '${existing.status}'.`,
+          "invalid_transition"
+        )
+      }
 
-    return record
+      const result = this.db
+        .query(
+          `
+          UPDATE webhook_runs
+          SET status = 'running', started_at = ?, finished_at = NULL,
+              response_status = NULL, error = NULL
+          WHERE project_id = ? AND id = ? AND status = 'failed'
+        `
+        )
+        .run((input.startedAt ?? new Date()).toISOString(), input.projectId, input.id)
+      if (result.changes === 0) {
+        throw new WebhookRunError(
+          `[SixbSqlite] Webhook run '${input.id}' changed while restarting.`,
+          "invalid_transition"
+        )
+      }
+      return this.requireWebhookRun(input.projectId, input.id)
+    })()
   }
 
   async finish(input: FinishWebhookRunInput): Promise<WebhookRunRecord> {
     return this.db.transaction(() => {
-      const existing = this.db
-        .query("SELECT * FROM webhook_runs WHERE project_id = ? AND id = ?")
-        .get(input.projectId, input.id) as WebhookRunDatabaseRow | null
-
+      const existing = this.getWebhookRunRow(input.projectId, input.id)
       if (!existing) {
         throw new WebhookRunError(
-          `[SixbSqlite] Webhook run '${input.id}' not found for project '${input.projectId}'.`
+          `[SixbSqlite] Webhook run '${input.id}' not found for project '${input.projectId}'.`,
+          "not_found"
         )
       }
-
       if (existing.status !== "running") {
         throw new WebhookRunError(
-          `[SixbSqlite] Webhook run '${input.id}' for project '${input.projectId}' is already terminal.`
+          `[SixbSqlite] Webhook run '${input.id}' for project '${input.projectId}' is already terminal.`,
+          "invalid_transition"
         )
       }
 
@@ -113,72 +152,63 @@ export class SqliteWebhookRunStorage implements WebhookRunStorage {
         .query(
           `
           UPDATE webhook_runs
-          SET
-            status = ?,
-            finished_at = ?,
-            request_body_bytes = ?,
-            response_status = ?,
-            idempotency_key = ?,
-            delivery_claim_result = ?,
-            error = ?
+          SET status = ?, finished_at = ?, response_status = ?, error = ?
           WHERE project_id = ? AND id = ?
         `
         )
         .run(
           input.status,
           (input.finishedAt ?? new Date()).toISOString(),
-          input.requestBodyBytes ?? null,
           input.responseStatus ?? null,
-          input.idempotencyKey ?? null,
-          input.deliveryClaimResult ?? null,
-          input.status === "succeeded" ? null : (input.error ?? null),
+          input.status === "succeeded"
+            ? null
+            : serializeSixbFailure(input.error, WEBHOOK_RUN_FAILURE_CODES),
           input.projectId,
           input.id
         )
-
-      const updated = this.db
-        .query("SELECT * FROM webhook_runs WHERE project_id = ? AND id = ?")
-        .get(input.projectId, input.id) as WebhookRunDatabaseRow
-
-      return rowToWebhookRunRecord(updated)
+      return this.requireWebhookRun(input.projectId, input.id)
     })()
   }
 
   async getById(params: { projectId: string; id: string }): Promise<WebhookRunRecord | null> {
-    const row = this.db
-      .query("SELECT * FROM webhook_runs WHERE project_id = ? AND id = ?")
-      .get(params.projectId, params.id) as WebhookRunDatabaseRow | null
+    const row = this.getWebhookRunRow(params.projectId, params.id)
+    return row ? rowToWebhookRunRecord(row) : null
+  }
 
+  async getByDelivery(input: GetWebhookRunByDeliveryInput): Promise<WebhookRunRecord | null> {
+    const row = this.db
+      .query(
+        `
+        SELECT * FROM webhook_runs
+        WHERE project_id = ? AND connector_id = ? AND webhook_id = ? AND idempotency_key = ?
+      `
+      )
+      .get(
+        input.projectId,
+        input.connectorId,
+        input.webhookId,
+        input.idempotencyKey
+      ) as WebhookRunDatabaseRow | null
     return row ? rowToWebhookRunRecord(row) : null
   }
 
   async list(input: ListWebhookRunsInput): Promise<ListWebhookRunsResult> {
-    if (hasEmptyStatuses(input)) {
-      return {
-        runs: [],
-        hasMore: false,
-        total: 0,
-      }
-    }
+    if (hasEmptyStatuses(input)) return { runs: [], hasMore: false, total: 0 }
 
     const whereClauses = ["project_id = ?"]
     const args: SqliteValue[] = [input.projectId]
-
     if (input.connectorId) {
       whereClauses.push("connector_id = ?")
       args.push(input.connectorId)
     }
-
     if (input.webhookId) {
       whereClauses.push("webhook_id = ?")
       args.push(input.webhookId)
     }
-
     if (input.idempotencyKey) {
       whereClauses.push("idempotency_key = ?")
       args.push(input.idempotencyKey)
     }
-
     appendRunListFilters(whereClauses, args, input)
 
     const { rows, total, hasMore } = queryRunList<WebhookRunDatabaseRow>({
@@ -190,23 +220,36 @@ export class SqliteWebhookRunStorage implements WebhookRunStorage {
       limit: input.limit,
       offset: input.offset,
     })
-
-    return {
-      runs: rows.map(rowToWebhookRunRecord),
-      hasMore,
-      total,
-    }
+    return { runs: rows.map(rowToWebhookRunRecord), hasMore, total }
   }
 
   close(): void {
     closeSqliteStoreConnection(this.connection)
   }
+
+  private getWebhookRunRow(projectId: string, id: string): WebhookRunDatabaseRow | null {
+    return this.db
+      .query("SELECT * FROM webhook_runs WHERE project_id = ? AND id = ?")
+      .get(projectId, id) as WebhookRunDatabaseRow | null
+  }
+
+  private requireWebhookRun(projectId: string, id: string): WebhookRunRecord {
+    const row = this.getWebhookRunRow(projectId, id)
+    if (!row) {
+      throw new WebhookRunError(
+        `[SixbSqlite] Failed to load webhook run '${id}' for project '${projectId}'.`,
+        "not_found"
+      )
+    }
+    return rowToWebhookRunRecord(row)
+  }
 }
 
 function rowToWebhookRunRecord(row: WebhookRunDatabaseRow): WebhookRunRecord {
   return {
     id: row.id,
     projectId: row.project_id,
+    executionId: row.execution_id,
     connectorId: row.connector_id,
     webhookId: row.webhook_id,
     status: row.status,
@@ -214,17 +257,18 @@ function rowToWebhookRunRecord(row: WebhookRunDatabaseRow): WebhookRunRecord {
     route: row.route,
     startedAt: new Date(row.started_at),
     finishedAt: row.finished_at ? new Date(row.finished_at) : undefined,
-    requestBodyBytes: row.request_body_bytes ?? undefined,
+    requestBodyBytes: row.request_body_bytes,
+    requestBodySha256: row.request_body_sha256,
     responseStatus: row.response_status ?? undefined,
     idempotencyKey: row.idempotency_key ?? undefined,
-    deliveryClaimResult: row.delivery_claim_result ?? undefined,
-    error: row.error ?? undefined,
+    error: row.error === null ? undefined : parseSixbFailure(row.error, WEBHOOK_RUN_FAILURE_CODES),
   }
 }
 
 interface WebhookRunDatabaseRow {
   readonly project_id: string
   readonly id: string
+  readonly execution_id: string
   readonly connector_id: string
   readonly webhook_id: string
   readonly status: WebhookRunRecord["status"]
@@ -232,9 +276,9 @@ interface WebhookRunDatabaseRow {
   readonly route: string
   readonly started_at: string
   readonly finished_at: string | null
-  readonly request_body_bytes: number | null
+  readonly request_body_bytes: number
+  readonly request_body_sha256: string
   readonly response_status: number | null
   readonly idempotency_key: string | null
-  readonly delivery_claim_result: WebhookRunRecord["deliveryClaimResult"] | null
   readonly error: string | null
 }