feat(expo): intake client with idempotency-key header

Author: Ripwords

packages/expo/src/intake-client.test.ts

@@ -0,0 +1,53 @@
+import { test, expect } from "bun:test"
+import { createIntakeClient } from "./intake-client"
+
+test("POSTs to intakeUrl/reports with multipart body and Idempotency-Key header", async () => {
+  let capturedUrl = ""
+  let capturedHeaders: Record<string, string> = {}
+  const mockFetch: typeof fetch = async (input, init) => {
+    capturedUrl = typeof input === "string" ? input : (input as Request).url
+    capturedHeaders = Object.fromEntries(new Headers(init?.headers).entries())
+    return new Response(JSON.stringify({ id: "server-id" }), {
+      status: 201,
+      headers: { "content-type": "application/json" },
+    })
+  }
+  const client = createIntakeClient({
+    intakeUrl: "https://ex.com/api/intake",
+    fetchImpl: mockFetch,
+  })
+  const res = await client.submit({
+    idempotencyKey: "idem-1",
+    input: {
+      projectKey: "rp_pk_" + "a".repeat(24),
+      title: "t",
+      context: {
+        source: "expo",
+        pageUrl: "myapp://x",
+        userAgent: "u",
+        viewport: { w: 1, h: 1 },
+        timestamp: new Date().toISOString(),
+      },
+    } as never,
+    attachments: [],
+  })
+  expect(capturedUrl).toBe("https://ex.com/api/intake/reports")
+  expect(capturedHeaders["idempotency-key"]).toBe("idem-1")
+  expect(res.id).toBe("server-id")
+})
+
+const mockServerErrorFetch: typeof fetch = async () => new Response("boom", { status: 503 })
+
+test("surfaces 5xx errors to the caller", async () => {
+  const client = createIntakeClient({
+    intakeUrl: "https://ex.com/api/intake",
+    fetchImpl: mockServerErrorFetch,
+  })
+  await expect(
+    client.submit({
+      idempotencyKey: "k",
+      input: { projectKey: "rp_pk_" + "a".repeat(24), title: "t", context: {} as never } as never,
+      attachments: [],
+    }),
+  ).rejects.toMatchObject({ status: 503 })
+})

packages/expo/src/intake-client.ts

@@ -0,0 +1,51 @@
+import type { ReportIntakeInput, IntakeResponse } from "@reprojs/shared"
+import type { QueueItemAttachment } from "./queue/storage"
+
+export interface IntakeSubmitArgs {
+  idempotencyKey: string
+  input: ReportIntakeInput
+  attachments: Array<QueueItemAttachment & { contentType: string }>
+}
+
+export class IntakeError extends Error {
+  status: number
+  retryable: boolean
+  constructor(status: number, message: string) {
+    super(message)
+    this.status = status
+    this.retryable = status >= 500 || status === 429
+  }
+}
+
+export interface IntakeClient {
+  submit: (args: IntakeSubmitArgs) => Promise<IntakeResponse>
+}
+
+export function createIntakeClient(opts: {
+  intakeUrl: string
+  fetchImpl?: typeof fetch
+}): IntakeClient {
+  const f = opts.fetchImpl ?? fetch
+
+  return {
+    async submit({ idempotencyKey, input, attachments }) {
+      const form = new FormData()
+      form.append("report", new Blob([JSON.stringify(input)], { type: "application/json" }))
+      for (const a of attachments) {
+        // In RN, FormData accepts { uri, name, type } shorthand. We use it via a typed helper.
+        const part = { uri: a.uri, name: `${a.kind}.bin`, type: a.contentType } as unknown as Blob
+        form.append(a.kind, part)
+      }
+      const res = await f(`${opts.intakeUrl}/reports`, {
+        method: "POST",
+        body: form as unknown as BodyInit,
+        headers: { "idempotency-key": idempotencyKey },
+      })
+      if (res.status >= 400) {
+        const body = await res.text().catch(() => "")
+        throw new IntakeError(res.status, body || res.statusText)
+      }
+      return (await res.json()) as IntakeResponse
+    },
+  }
+}