feat: parseJson(text, ctx) — request/response context for routing parsers

Inspired by ky [PR #849](sindresorhus/ky#849).
The parseJson option now receives an optional second argument with the
request and response, so a single shared parser can route on URL or
content-type:

\`\`\`ts
createMisina({
  parseJson: (text, ctx) => {
    if (ctx?.response.headers.get('x-format') === 'bigint') {
      return JSON.parse(text, bigintReviver)
    }
    return JSON.parse(text)
  },
})
\`\`\`

The previous one-arg signature still works — the second arg is optional
and the existing tests (which pass a one-arg callback) continue to pass.

### test/init-isolation.test.ts
Two new tests covering ky [PR #861](sindresorhus/ky#861
spirit: per-request init hook isolation.
- Concurrent requests don't share a counter through options.headers.
- A defaults.headers value mutated inside init doesn't compound across
  later requests.

Both pass — verifies that resolveOptions() builds a fresh per-request
options object each time, so default state isn't leaked or compounded.

### test/parsejson-context.test.ts
Two new tests for the new signature:
- ctx?.request.url and ctx?.response.headers.get(...) are observable.
- The original one-arg form keeps working.

117/117 tests pass; lint, typecheck, build, bundle budget all clean.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: productdevbook

src/_body.ts

@@ -95,8 +95,9 @@ const JSON_RE = /^application\/(?:[\w!#$%&*.^`~-]*\+)?json(;.+)?$/i
 export async function parseResponseBody(
   response: Response,
   method: string,
-  parseJson: (text: string) => unknown,
+  parseJson: (text: string, ctx?: { request: Request; response: Response }) => unknown,
   responseType?: "json" | "text" | "arrayBuffer" | "blob" | "stream",
+  request?: Request,
 ): Promise<unknown> {
   if (isBodylessResponse(response, method)) {
     if (responseType === "text") return ""
@@ -115,7 +116,7 @@ export async function parseResponseBody(
   if (responseType === "json" || JSON_RE.test(ct)) {
     const text = await response.text()
     if (text === "") return undefined
-    return parseJson(text)
+    return parseJson(text, request ? { request, response } : undefined)
   }
   if (ct.startsWith("text/")) return response.text()
   return response.arrayBuffer()

src/misina.ts

@@ -147,6 +147,7 @@ export function createMisina(defaults: MisinaOptions = {}): Misina {
           options.method,
           options.parseJson,
           options.responseType,
+          ctx.request,
         )
         const httpError = new HTTPError(response, ctx.request, data)
         ctx.error = httpError
@@ -200,6 +201,7 @@ export function createMisina(defaults: MisinaOptions = {}): Misina {
       options.method,
       options.parseJson,
       options.responseType,
+      ctx.request,
     )
 
     if (options.validateResponse) {
@@ -334,11 +336,15 @@ function resolveOptions(
     redirectAllowDowngrade: init.redirectAllowDowngrade ?? defaults.redirectAllowDowngrade ?? false,
     throwHttpErrors: init.throwHttpErrors ?? defaults.throwHttpErrors ?? true,
     validateResponse: init.validateResponse ?? defaults.validateResponse,
-    parseJson: init.parseJson ?? defaults.parseJson ?? JSON.parse,
+    parseJson: init.parseJson ?? defaults.parseJson ?? defaultParseJson,
     stringifyJson: init.stringifyJson ?? defaults.stringifyJson ?? JSON.stringify,
   }
 }
 
+function defaultParseJson(text: string): unknown {
+  return JSON.parse(text)
+}
+
 function mergeHeaders(
   a: Record<string, string> | undefined,
   b: Record<string, string> | undefined,

src/types.ts

@@ -165,8 +165,12 @@ export interface MisinaOptions {
   redirectMaxCount?: number
   /** Allow https → http redirect. Default: false. */
   redirectAllowDowngrade?: boolean
-  /** Custom JSON parser. Default: JSON.parse. */
-  parseJson?: (text: string) => unknown
+  /**
+   * Custom JSON parser. Default: JSON.parse. Optional context (request +
+   * response) lets advanced parsers route on URL or content-type
+   * (matches ky [PR #849](https://github.com/sindresorhus/ky/pull/849)).
+   */
+  parseJson?: (text: string, ctx?: { request: Request; response: Response }) => unknown
   /** Custom JSON serializer for request bodies. Default: JSON.stringify. */
   stringifyJson?: (value: unknown) => string
   /** How arrays in `query` are serialized. Default: 'repeat'. */
@@ -259,7 +263,7 @@ export interface MisinaResolvedOptions {
         response: Response
       }) => boolean | Error)
     | undefined
-  parseJson: (text: string) => unknown
+  parseJson: (text: string, ctx?: { request: Request; response: Response }) => unknown
   stringifyJson: (value: unknown) => string
 }
 

test/init-isolation.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it } from "vitest"
+import { createMisina } from "../src/index.ts"
+import mockDriverFactory, { getMockApi } from "../src/driver/mock.ts"
+
+function jsonResponse(body: unknown): Response {
+  return new Response(JSON.stringify(body), {
+    headers: { "content-type": "application/json" },
+  })
+}
+
+describe("init hook — per-request isolation (ky #861)", () => {
+  it("mutating headers in init does not leak to a sibling concurrent request", async () => {
+    const driver = mockDriverFactory({ response: jsonResponse({}) })
+
+    let counter = 0
+    const m = createMisina({
+      driver,
+      retry: 0,
+      hooks: {
+        init: (options) => {
+          // Each request increments and writes its own value. If options
+          // were shared, both requests would see the same final value.
+          counter++
+          options.headers["x-counter"] = String(counter)
+        },
+      },
+    })
+
+    await Promise.all([m.get("https://api.test/a"), m.get("https://api.test/b")])
+
+    const calls = getMockApi(driver)?.calls
+    expect(calls).toHaveLength(2)
+    const counterA = calls?.[0]?.headers["x-counter"]
+    const counterB = calls?.[1]?.headers["x-counter"]
+    // Each request gets its own value; they shouldn't be identical and
+    // should be 1 and 2 in some order.
+    expect(new Set([counterA, counterB])).toEqual(new Set(["1", "2"]))
+  })
+
+  it("mutating defaults.headers from init does not affect future requests", async () => {
+    const driver = mockDriverFactory({ response: jsonResponse({}) })
+
+    const m = createMisina({
+      driver,
+      retry: 0,
+      headers: { "x-base": "first" },
+      hooks: {
+        init: (options) => {
+          // If options.headers shared the defaults reference, this would
+          // mutate the *defaults* and persist across calls.
+          options.headers["x-base"] = "mutated"
+        },
+      },
+    })
+
+    await m.get("https://api.test/")
+    await m.get("https://api.test/")
+
+    const calls = getMockApi(driver)?.calls
+    // Both requests see 'mutated' because init runs each time, but the
+    // mutation should NOT compound (e.g. become 'mutatedmutated').
+    expect(calls?.[0]?.headers["x-base"]).toBe("mutated")
+    expect(calls?.[1]?.headers["x-base"]).toBe("mutated")
+  })
+})

test/parsejson-context.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vitest"
+import { createMisina } from "../src/index.ts"
+import mockDriverFactory from "../src/driver/mock.ts"
+
+describe("parseJson context (ky #849)", () => {
+  it("optional ctx receives request and response for routing decisions", async () => {
+    const driver = mockDriverFactory({
+      response: new Response(JSON.stringify({ raw: 1 }), {
+        headers: { "content-type": "application/json", "x-route": "v2" },
+      }),
+    })
+
+    let observedUrl: string | undefined
+    let observedHeader: string | null | undefined
+
+    const m = createMisina({
+      driver,
+      retry: 0,
+      parseJson: (text, ctx) => {
+        observedUrl = ctx?.request.url
+        observedHeader = ctx?.response.headers.get("x-route")
+        return JSON.parse(text)
+      },
+    })
+
+    await m.get("https://api.test/items")
+
+    expect(observedUrl).toBe("https://api.test/items")
+    expect(observedHeader).toBe("v2")
+  })
+
+  it("works without context (backward-compatible)", async () => {
+    const driver = mockDriverFactory({
+      response: new Response('{"a":1}', {
+        headers: { "content-type": "application/json" },
+      }),
+    })
+
+    const m = createMisina({
+      driver,
+      retry: 0,
+      parseJson: (text) => JSON.parse(text),
+    })
+
+    const res = await m.get<{ a: number }>("https://api.test/")
+    expect(res.data).toEqual({ a: 1 })
+  })
+})