@sanity/client 7.26.2 → 8.0.0

package/src/http/browserUpload.ts

@@ -0,0 +1,162 @@
+import {createDebug} from 'obug'
+import {Observable} from 'rxjs'
+
+import type {UploadEvent} from '../types'
+import {ClientError, httpResponseFromFetch, ServerError} from './errors'
+import {parseJsonText} from './request'
+
+const log = createDebug('sanity:client')
+
+let nextRequestId = 1
+
+/**
+ * Options for a browser-side asset upload that needs progress events.
+ *
+ * @internal
+ */
+export interface BrowserUploadOptions {
+  url: string
+  method: string
+  headers: Record<string, string>
+  body: unknown
+  withCredentials: boolean
+  /** Milliseconds before the upload is aborted; `false` and `0` both disable the timeout. */
+  timeout?: number | false
+  signal?: AbortSignal
+}
+
+/**
+ * Run an asset upload through `XMLHttpRequest` so we can surface per-chunk
+ * upload progress events. get-it v9 / fetch has no equivalent hook in the
+ * browser, so the observable asset-upload API falls back to this path when
+ * `XMLHttpRequest` is available.
+ *
+ * @internal
+ */
+export function uploadWithProgress<T>(options: BrowserUploadOptions): Observable<UploadEvent<T>> {
+  return new Observable<UploadEvent<T>>((subscriber) => {
+    const xhr = new XMLHttpRequest()
+    const requestId = nextRequestId++
+    const {url, method, headers, body, withCredentials, timeout, signal} = options
+
+    log('[%d] %s %s (XHR upload with progress)', requestId, method, url)
+
+    xhr.open(method, url)
+    xhr.withCredentials = withCredentials
+    if (typeof timeout === 'number' && timeout > 0) {
+      xhr.timeout = timeout
+    }
+
+    for (const [key, value] of Object.entries(headers)) {
+      xhr.setRequestHeader(key, value)
+    }
+
+    xhr.upload.onprogress = (e) => {
+      subscriber.next({
+        type: 'progress',
+        stage: 'upload',
+        percent: e.lengthComputable ? Math.round((e.loaded / e.total) * 100) : 0,
+        total: e.total || undefined,
+        loaded: e.loaded,
+        lengthComputable: e.lengthComputable,
+      })
+    }
+
+    xhr.onload = () => {
+      log('[%d] %s %s — %d', requestId, method, url, xhr.status)
+
+      if (xhr.status >= 400) {
+        // Same typed errors as the fetch transport, so consumers can keep
+        // detecting `ClientError`/`ServerError` and reading `statusCode`,
+        // `responseBody` and the structured API `details` on failed uploads.
+        const errorHeaders = parseXhrResponseHeaders(xhr.getAllResponseHeaders())
+        const canonical = httpResponseFromFetch(
+          {
+            status: xhr.status,
+            statusText: xhr.statusText,
+            headers: errorHeaders,
+            body: parseJsonText(xhr.responseText, errorHeaders),
+          },
+          url,
+          method,
+        )
+        subscriber.error(
+          xhr.status >= 500 ? new ServerError(canonical) : new ClientError(canonical),
+        )
+        return
+      }
+
+      let responseBody: T
+      try {
+        responseBody = JSON.parse(xhr.responseText) as T
+      } catch {
+        subscriber.error(new Error('Failed to parse upload response as JSON'))
+        return
+      }
+
+      subscriber.next({type: 'response', body: responseBody})
+      subscriber.complete()
+    }
+
+    xhr.onerror = () => {
+      log('[%d] %s %s — network error', requestId, method, url)
+      subscriber.error(new Error('XHR upload network error'))
+    }
+
+    xhr.ontimeout = () => {
+      log('[%d] %s %s — timed out after %dms', requestId, method, url, timeout)
+      // Same error shape as the fetch transport's timeout rejection.
+      subscriber.error(
+        new DOMException(
+          `The operation timed out after ${timeout}ms while attempting to reach ${url}`,
+          'TimeoutError',
+        ),
+      )
+    }
+
+    xhr.onabort = () => {
+      subscriber.error(new DOMException('Upload aborted', 'AbortError'))
+    }
+
+    const onSignalAbort = () => xhr.abort()
+    if (signal) {
+      if (signal.aborted) {
+        // `xhr.abort()` before `send()` fires no `abort` event per spec, so
+        // error out directly instead of relying on `onabort`.
+        subscriber.error(new DOMException('Upload aborted', 'AbortError'))
+        return undefined
+      }
+      signal.addEventListener('abort', onSignalAbort, {once: true})
+    }
+
+    xhr.send(body as XMLHttpRequestBodyInit)
+
+    // Unsubscribing cancels the in-flight upload, mirroring how the fetch
+    // path aborts its request (`_observe`). After settle this is a no-op —
+    // except for detaching from the caller's signal, which may be long-lived
+    // and must not accumulate a listener per upload.
+    return () => {
+      signal?.removeEventListener('abort', onSignalAbort)
+      xhr.abort()
+    }
+  })
+}
+
+/**
+ * Parse `XMLHttpRequest.getAllResponseHeaders()` output (CRLF-separated
+ * `name: value` lines) into a `Headers` instance.
+ */
+function parseXhrResponseHeaders(raw: string): Headers {
+  const headers = new Headers()
+  for (const line of raw.split('\r\n')) {
+    const separator = line.indexOf(':')
+    if (separator <= 0) continue
+    try {
+      headers.append(line.slice(0, separator).trim(), line.slice(separator + 1).trim())
+    } catch {
+      // Skip header lines the Headers constructor rejects — better a partial
+      // header record on the error than no error details at all.
+    }
+  }
+  return headers
+}

package/src/http/errors.ts

@@ -1,11 +1,66 @@
-import type {HttpContext} from 'get-it'
-
 import type {ActionError, Any, ErrorProps, MutationError, QueryParseError} from '../types'
 import {codeFrame} from '../util/codeFrame'
 import {isRecord} from '../util/isRecord'
 
 const MAX_ITEMS_IN_ERROR_MESSAGE = 5
 
+/**
+ * Canonical HTTP response shape used internally to build {@link ClientError}
+ * and {@link ServerError}. Decouples the error layer from any particular
+ * transport library — adapters in the HTTP layer (e.g. `httpResponseFromGetIt`)
+ * project transport-specific response shapes into this stable form before
+ * constructing errors.
+ *
+ * Matches the public {@link HttpError.response} shape so consumers see no
+ * difference in error properties when the underlying transport changes.
+ *
+ * @internal
+ */
+export interface CanonicalHttpResponse {
+  statusCode: number
+  statusMessage: string | null
+  headers: Record<string, string>
+  body: unknown
+  url: string
+  method: string
+}
+
+/**
+ * Adapter for buffered responses from get-it v9 (`BufferedResponse`-shaped).
+ *
+ * The URL and method aren't on the response itself in v9, so the request
+ * options must be passed alongside.
+ *
+ * @internal
+ */
+export function httpResponseFromFetch(
+  res: {
+    status: number
+    statusText: string
+    headers: Headers
+    body: unknown
+  },
+  reqUrl: string,
+  reqMethod: string,
+): CanonicalHttpResponse {
+  return {
+    statusCode: res.status,
+    statusMessage: res.statusText || null,
+    headers: headersToRecord(res.headers),
+    body: res.body,
+    url: reqUrl,
+    method: reqMethod,
+  }
+}
+
+function headersToRecord(headers: Headers): Record<string, string> {
+  const out: Record<string, string> = {}
+  headers.forEach((value, key) => {
+    out[key] = value
+  })
+  return out
+}
+
 /**
  * Shared properties for HTTP errors (eg both ClientError and ServerError)
  * Use `isHttpError` for type narrowing and accessing response properties.
@@ -67,8 +122,8 @@ export class ClientError extends Error {
   traceId: ErrorProps['traceId']
   details: ErrorProps['details']
 
-  constructor(res: Any, context?: HttpContext) {
-    const props = extractErrorProps(res, context)
+  constructor(res: Any, tag?: string) {
+    const props = extractErrorProps(res, tag)
     super(props.message)
     Object.assign(this, props)
   }
@@ -89,7 +144,7 @@ export class ServerError extends Error {
   }
 }
 
-function extractErrorProps(res: Any, context?: HttpContext): ErrorProps {
+function extractErrorProps(res: Any, tag?: string): ErrorProps {
   const body = res.body
   const props = {
     response: res,
@@ -144,7 +199,6 @@ function extractErrorProps(res: Any, context?: HttpContext): ErrorProps {
 
   // Query parse errors
   if (isQueryParseError(error)) {
-    const tag = context?.options?.query?.tag
     props.message = formatQueryParseError(error, tag, props.traceId)
     props.details = body.error
     return props

package/src/http/nodeMiddleware.ts

@@ -1,41 +1,105 @@
-import type {Middleware, RequestOptions} from 'get-it'
-import {agent, debug, headers} from 'get-it/middleware'
+import {Readable} from 'node:stream'
+
+import type {FetchFunction} from 'get-it'
+import {debug} from 'get-it/middleware'
+import {createNodeFetch} from 'get-it/node'
+import {createDebug} from 'obug'
 
 import {name, version} from '../../package.json'
+import type {EnvironmentOptions, LegacyMiddleware} from './request'
+
+const log = createDebug('sanity:client')
+
+function isNodeReadableStream(value: unknown): value is Readable {
+  if (typeof value !== 'object' || value === null) return false
+  if (!('pipe' in value)) return false
+  return typeof value.pipe === 'function'
+}
+
+// One undici-backed fetch per (proxy URL) so callers don't pay the cost of
+// rebuilding a dispatcher on every request when they use the same proxy.
+const proxyFetchCache = new Map<string, ReturnType<typeof createNodeFetch>>()
+
+function getProxyFetch(proxyUrl: string): ReturnType<typeof createNodeFetch> {
+  const cached = proxyFetchCache.get(proxyUrl)
+  if (cached) return cached
+  const fetch = createNodeFetch({proxy: proxyUrl, connections: 30})
+  proxyFetchCache.set(proxyUrl, fetch)
+  return fetch
+}
+
+// The environment's default fetch, shared by all SSE connections that have no
+// explicit proxy configured. Built lazily so clients that never use
+// `listen()`/`live.events()` don't pay for the dispatcher.
+let envDefaultFetch: ReturnType<typeof createNodeFetch> | undefined
 
-const middleware: Middleware[] = [
-  debug({verbose: true, namespace: 'sanity:client'}),
-  headers({'User-Agent': `${name} ${version}`}),
+/**
+ * Exposed via `EnvironmentOptions.resolveFetch` so EventSource connections
+ * use the same transport as regular requests instead of falling back to
+ * `globalThis.fetch`. Everything get-it's Node fetch provides then applies
+ * to SSE too: the undici dispatcher configuration, an explicit `proxy`
+ * config (pass the URL), and env-proxy support
+ * (`HTTP_PROXY`/`HTTPS_PROXY`/`NO_PROXY`, which Node's own global fetch does
+ * not read — that is opt-in via `NODE_USE_ENV_PROXY`, and not on our 22.12
+ * floor). Reached via the env rather than a direct import so `get-it/node`
+ * (and with it `undici`) stays out of the browser bundle.
+ *
+ * @internal
+ */
+function resolveFetch(proxyUrl?: string): FetchFunction {
+  if (typeof proxyUrl === 'string') {
+    return getProxyFetch(proxyUrl)
+  }
+  envDefaultFetch ??= createNodeFetch()
+  return envDefaultFetch
+}
 
-  // Lineage is used for recursion control/tracing and can be passed either through
-  // client constructor or through environent variable.
-  // Not used in browser environments.
+const middleware: LegacyMiddleware[] = [
+  debug({log: (message, ...args) => log(message, ...args), verbose: true}),
+
+  // Lineage is used for recursion control/tracing and can be passed either
+  // through the client config (arrives as `meta.lineage`, set by
+  // `requestOptions`) or through an environment variable. Not used in
+  // browser environments.
   {
-    processOptions(opts: RequestOptions & {lineage?: string}) {
+    beforeRequest(opts) {
+      const configLineage = typeof opts.meta?.lineage === 'string' ? opts.meta.lineage : undefined
       const lineage =
-        (typeof process !== 'undefined' && process.env.X_SANITY_LINEAGE) || opts.lineage
-
-      if (lineage) {
-        opts.headers = opts.headers || {}
-        opts.headers['x-sanity-lineage'] = lineage
-      }
-      return opts
+        (typeof process !== 'undefined' && process.env.X_SANITY_LINEAGE) || configLineage
+      if (!lineage) return opts
+      const headers = new Headers(opts.headers)
+      headers.set('x-sanity-lineage', lineage)
+      return {...opts, headers}
     },
   },
 
-  // Enable keep-alive, and in addition limit the number of sockets that can be opened.
-  // This avoids opening too many connections to the server if someone tries to execute
-  // a bunch of requests in parallel. It's recommended to have a concurrency limit
-  // at a "higher limit" (i.e. you shouldn't actually execute hundreds of requests in parallel),
-  // and this is mainly to minimize the impact for the network and server.
-  //
-  // We're currently matching the same defaults as browsers:
-  // https://stackoverflow.com/questions/26003756/is-there-a-limit-practical-or-otherwise-to-the-number-of-web-sockets-a-page-op
-  agent({
-    keepAlive: true,
-    maxSockets: 30,
-    maxTotalSockets: 256,
-  }),
+  // Asset uploads can pass a Node.js Readable stream (from
+  // `fs.createReadStream(...)`) as the body. The HTTP transport's body type
+  // guard only accepts Web streams, so we project Node streams here —
+  // undici's fetch accepts Web streams natively.
+  {
+    beforeRequest(opts) {
+      if (!isNodeReadableStream(opts.body)) return opts
+      return {...opts, body: Readable.toWeb(opts.body)}
+    },
+  },
 ]
 
-export default middleware
+/**
+ * Node-specific environment options used to wire up `createRequester`.
+ *
+ * - `User-Agent` defaults to `@sanity/client <version>`.
+ * - Falls back to get-it/node's default undici-backed fetch (which honours
+ *   `HTTP_PROXY` / `HTTPS_PROXY` / `NO_PROXY` env vars via undici's
+ *   `EnvHttpProxyAgent`). Per-request proxy overrides are wired in via the
+ *   wrapping middleware above.
+ *
+ * @internal
+ */
+const environment: EnvironmentOptions = {
+  headers: {'User-Agent': `${name} ${version}`},
+  middleware,
+  resolveFetch,
+}
+
+export default environment