@atproto/xrpc 0.6.0-rc.0 → 0.6.1

package/src/util.ts

@@ -193,21 +193,21 @@ export function combineHeaders(
 
   let headers: Headers | undefined = undefined
 
-  for (const [key, getter] of defaultHeaders) {
+  for (const [name, definition] of defaultHeaders) {
     // Ignore undefined values (allowed for convenience when using
     // Object.entries).
-    if (getter === undefined) continue
+    if (definition === undefined) continue
 
     // Lazy initialization of the headers object
     headers ??= new Headers(headersInit)
 
-    if (headers.has(key)) continue
+    if (headers.has(name)) continue
 
-    const value = typeof getter === 'function' ? getter() : getter
+    const value = typeof definition === 'function' ? definition() : definition
 
-    if (typeof value === 'string') headers.set(key, value)
-    else if (value === null) headers.delete(key)
-    else throw new TypeError(`Invalid "${key}" header value: ${typeof value}`)
+    if (typeof value === 'string') headers.set(name, value)
+    else if (value === null) headers.delete(name)
+    else throw new TypeError(`Invalid "${name}" header value: ${typeof value}`)
   }
 
   return headers ?? headersInit
@@ -343,85 +343,16 @@ function iterableToReadableStream(
     return ReadableStream.from(iterable)
   }
 
-  // Note, in environments where ReadableStream is not available either, we
-  // *could* load the iterable into memory and create an Arraybuffer from it.
-  // However, this would be a bad idea for large iterables. In order to keep
-  // things simple, we'll just allow the anonymous ReadableStream constructor
-  // to throw an error in those environments, hinting the user of the lib to find
-  // an alternate solution in that case (e.g. use a Blob if available).
-
-  let generator: AsyncGenerator<unknown, void, undefined>
-  return new ReadableStream<Uint8Array>({
-    type: 'bytes',
-    start() {
-      // Wrap the iterable in an async generator to handle both sync and async
-      // iterables, and make sure that the return() method exists.
-      generator = (async function* () {
-        yield* iterable
-      })()
-    },
-    async pull(controller: ReadableStreamDefaultController) {
-      const { done, value } = await generator.next()
-      if (done) {
-        controller.close()
-      } else {
-        try {
-          const buf = toUint8Array(value)
-          if (buf) controller.enqueue(buf)
-        } catch (cause) {
-          // ReadableStream won't call cancel() if the stream is errored.
-          await generator.return()
-
-          controller.error(
-            new TypeError(
-              'Converting iterable body to ReadableStream requires Buffer, ArrayBuffer or string values',
-              { cause },
-            ),
-          )
-        }
-      }
-    },
-    async cancel() {
-      await generator.return()
-    },
-  })
-}
-
-// Browsers don't have Buffer. This syntax is to avoid bundlers from including
-// a Buffer polyfill in the bundle if it's not used elsewhere.
-const globalName = `${{ toString: () => 'Buf' }}fer` as 'Buffer'
-const Buffer =
-  typeof globalThis[globalName] === 'function'
-    ? globalThis[globalName]
-    : undefined
-
-const toUint8Array: (value: unknown) => Uint8Array | undefined = Buffer
-  ? (value) => {
-      // @ts-expect-error Buffer.from will throw if value is not a valid input
-      const buf = Buffer.isBuffer(value) ? value : Buffer.from(value)
-      return buf.byteLength ? new Uint8Array(buf) : undefined
-    }
-  : (value) => {
-      if (value instanceof ArrayBuffer) {
-        const buf = new Uint8Array(value)
-        return buf.byteLength ? buf : undefined
-      }
+  // If you see this error, consider using a polyfill for ReadableStream. For
+  // example, the "web-streams-polyfill" package:
+  // https://github.com/MattiasBuelens/web-streams-polyfill
 
-      // Simulate Buffer.from() behavior for strings and and coercion
-      if (typeof value === 'string') {
-        return value.length ? new TextEncoder().encode(value) : undefined
-      } else if (typeof value?.valueOf === 'function') {
-        const coerced = value.valueOf()
-        if (coerced instanceof ArrayBuffer) {
-          const buf = new Uint8Array(coerced)
-          return buf.byteLength ? buf : undefined
-        } else if (typeof coerced === 'string') {
-          return coerced.length ? new TextEncoder().encode(coerced) : undefined
-        }
-      }
-
-      throw new TypeError(`Unable to convert "${typeof value}" to Uint8Array`)
-    }
+  throw new TypeError(
+    'ReadableStream.from() is not supported in this environment. ' +
+      'It is required to support using iterables as the request body. ' +
+      'Consider using a polyfill or re-write your code to use a different body type.',
+  )
+}
 
 export function httpResponseBodyParse(
   mimeType: string | null,

package/src/xrpc-client.ts

@@ -1,11 +1,13 @@
 import { LexiconDoc, Lexicons, ValidationError } from '@atproto/lexicon'
 import {
   FetchHandler,
+  FetchHandlerObject,
   FetchHandlerOptions,
   buildFetchHandler,
 } from './fetch-handler'
 import {
   CallOptions,
+  Gettable,
   QueryParams,
   ResponseType,
   XRPCError,
@@ -14,6 +16,7 @@ import {
   httpResponseCodeToEnum,
 } from './types'
 import {
+  combineHeaders,
   constructMethodCallHeaders,
   constructMethodCallUrl,
   encodeMethodCallBody,
@@ -24,20 +27,32 @@ import {
 
 export class XrpcClient {
   readonly fetchHandler: FetchHandler
+  readonly headers = new Map<string, Gettable<null | string>>()
   readonly lex: Lexicons
 
   constructor(
-    fetchHandler: FetchHandler | FetchHandlerOptions,
+    fetchHandlerOpts: FetchHandler | FetchHandlerObject | FetchHandlerOptions,
+    // "Lexicons" is redundant here (because that class implements
+    // "Iterable<LexiconDoc>") but we keep it for explicitness:
     lex: Lexicons | Iterable<LexiconDoc>,
   ) {
-    this.fetchHandler =
-      typeof fetchHandler === 'function'
-        ? fetchHandler
-        : buildFetchHandler(fetchHandler)
+    this.fetchHandler = buildFetchHandler(fetchHandlerOpts)
 
     this.lex = lex instanceof Lexicons ? lex : new Lexicons(lex)
   }
 
+  setHeader(key: string, value: Gettable<null | string>): void {
+    this.headers.set(key.toLowerCase(), value)
+  }
+
+  unsetHeader(key: string): void {
+    this.headers.delete(key.toLowerCase())
+  }
+
+  clearHeaders(): void {
+    this.headers.clear()
+  }
+
   async call(
     methodNsid: string,
     params?: QueryParams,
@@ -51,7 +66,7 @@ export class XrpcClient {
       )
     }
 
-    //@TODO: should we validate the params and data here?
+    // @TODO: should we validate the params and data here?
     // this.lex.assertValidXrpcParams(methodNsid, params)
     // if (data !== undefined) {
     //   this.lex.assertValidXrpcInput(methodNsid, data)
@@ -66,7 +81,7 @@ export class XrpcClient {
     // anywhere in docs or types. See whatwg/fetch#1438, nodejs/node#46221.
     const init: RequestInit & { duplex: 'half' } = {
       method: reqMethod,
-      headers: reqHeaders,
+      headers: combineHeaders(reqHeaders, this.headers),
       body: reqBody,
       duplex: 'half',
       signal: opts?.signal,