@sanity/client 7.26.2 → 8.1.0

package/src/data/eventsource.ts

@@ -1,21 +1,23 @@
+import type {ErrorEvent, EventSourceConstructor} from 'eventsource'
 import {defer, isObservable, mergeMap, Observable, of} from 'rxjs'
 
 import {formatQueryParseError, isQueryParseError} from '../http/errors'
-import {type Any} from '../types'
+import {isRecord} from '../util/isRecord'
 
 /**
- * @public
  * Thrown when the EventSource connection could not be established, or was rejected by the server.
  * Transient failures (network drops, 5xx, 408, 429) are reconnected internally and emitted as
  * `reconnect` events; a permanent rejection (any other 4xx, eg an expired token) errors the
  * stream with this class so consumers can react — check `status` for the rejection code.
+ *
+ * @public
  */
 export class ConnectionFailedError extends Error {
   readonly name = 'ConnectionFailedError'
   /**
    * HTTP status code of the rejected connection attempt, if known.
-   * Only set when the EventSource implementation exposes it — the polyfill used in
-   * Node.js and when custom headers (eg authorization) are required does, while
+   * Only set when the EventSource implementation exposes it — the `eventsource`
+   * package used by the client does (as `code` on its error events), while
    * native EventSource implementations (browser and Node.js) do not.
    */
   readonly status?: number
@@ -28,8 +30,9 @@ export class ConnectionFailedError extends Error {
 
 /**
  * The listener has been told to explicitly disconnect.
- *  This is a rare situation, but may occur if the API knows reconnect attempts will fail,
- *  eg in the case of a deleted dataset, a blocked project or similar events.
+ * This is a rare situation, but may occur if the API knows reconnect attempts will fail,
+ * eg in the case of a deleted dataset, a blocked project or similar events.
+ *
  * @public
  */
 export class DisconnectError extends Error {
@@ -42,8 +45,9 @@ export class DisconnectError extends Error {
 }
 
 /**
- * @public
  * The server sent a `channelError` message. Usually indicative of a bad or malformed request
+ *
+ * @public
  */
 export class ChannelError extends Error {
   readonly name = 'ChannelError'
@@ -55,8 +59,9 @@ export class ChannelError extends Error {
 }
 
 /**
- * @public
  * The server sent an `error`-event to tell the client that an unexpected error has happened.
+ *
+ * @public
  */
 export class MessageError extends Error {
   readonly name = 'MessageError'
@@ -68,8 +73,9 @@ export class MessageError extends Error {
 }
 
 /**
- * @public
  * An error occurred while parsing the message sent by the server as JSON. Should normally not happen.
+ *
+ * @public
  */
 export class MessageParseError extends Error {
   readonly name = 'MessageParseError'
@@ -95,7 +101,7 @@ export type EventSourceEvent<Name extends string> = ServerSentEvent<Name>
 /**
  * @internal
  */
-export type EventSourceInstance = InstanceType<typeof globalThis.EventSource>
+export type EventSourceInstance = InstanceType<EventSourceConstructor>
 
 /**
  * Sanity API specific EventSource handler shared between the listen and live APIs
@@ -123,9 +129,7 @@ export function connectEventSource<EventName extends string>(
   return defer(() => {
     const es = initEventSource()
     return isObservable(es) ? es : of(es)
-  }).pipe(mergeMap((es) => connectWithESInstance(es, events))) as Observable<
-    ServerSentEvent<EventName>
-  >
+  }).pipe(mergeMap((es) => connectWithESInstance(es, events)))
 }
 
 /**
@@ -140,19 +144,30 @@ function connectWithESInstance<EventTypeName extends string>(
   events: EventTypeName[],
 ) {
   return new Observable<EventSourceEvent<EventTypeName>>((observer) => {
-    const emitOpen = (events as string[]).includes('open')
-    const emitReconnect = (events as string[]).includes('reconnect')
+    // Events actually requested by the caller. Backs `isRequestedEvent`, the type
+    // guard used below to narrow plain strings (eg `message.type`) to `EventTypeName`
+    // without a cast.
+    const requestedEvents = new Set<string>(events)
+    const isRequestedEvent = (type: string): type is EventTypeName => requestedEvents.has(type)
+    const emitOpen = isRequestedEvent('open')
 
     // EventSource will emit a regular Event if it fails to connect, however the API may also emit an `error` MessageEvent
     // So we need to handle both cases
-    function onError(evt: MessageEvent | Event) {
+    function onError(evt: ErrorEvent | MessageEvent) {
       // If the event has a `data` property, then it`s a MessageEvent emitted by the API and we should forward the error
       if ('data' in evt) {
-        const [parseError, event] = parseEvent(evt as MessageEvent)
+        const [parseError, event] = parseEvent(evt)
         observer.error(
-          parseError
-            ? new MessageParseError('Unable to parse EventSource error message', {cause: event})
-            : new MessageError((event?.data as {message: string}).message, event),
+          parseError || !event
+            ? new MessageParseError('Unable to parse EventSource error message', {
+                cause: parseError,
+              })
+            : new MessageError(
+                isRecord(event.data) && typeof event.data.message === 'string'
+                  ? event.data.message
+                  : '',
+                event,
+              ),
         )
         return
       }
@@ -161,34 +176,41 @@ function connectWithESInstance<EventTypeName extends string>(
       // automatically, but in some cases (like when a laptop lid is closed), it will trigger onError
       // if it can't reconnect.
       // see https://html.spec.whatwg.org/multipage/server-sent-events.html#sse-processing-model
-      // The polyfills expose the HTTP status of a rejected connection on the error event
-      // (native EventSource implementations do not). A status means the server rejected the
-      // connection attempt, so error out regardless of readyState — the polyfills disagree
-      // on whether the connection closes before or after the error event is dispatched —
-      // and let `reconnectOnConnectionFailure` classify it (4xx fatal, otherwise retried).
-      const rawStatus = (evt as {status?: unknown}).status
-      const status = typeof rawStatus === 'number' ? rawStatus : undefined
-      if (status !== undefined) {
-        observer.error(new ConnectionFailedError('EventSource connection failed', {status}))
+      // The `eventsource` package exposes the HTTP status of a rejected connection as
+      // `code` on the error event (native EventSource implementations expose nothing).
+      // A status means the server rejected the connection attempt, so error out
+      // regardless of readyState — implementations disagree on whether the connection
+      // closes before or after the error event is dispatched — and let
+      // `reconnectOnConnectionFailure` classify it (4xx fatal, otherwise retried).
+      if (evt.code !== undefined) {
+        observer.error(
+          new ConnectionFailedError('EventSource connection failed', {status: evt.code}),
+        )
         return
       }
 
       if (es.readyState === es.CLOSED) {
         // In these cases we'll signal to consumers (via the error path) that a retry/reconnect is needed.
         observer.error(new ConnectionFailedError('EventSource connection failed'))
-      } else if (emitReconnect) {
-        observer.next({type: 'reconnect' as EventTypeName})
+      } else {
+        const type = 'reconnect'
+        if (isRequestedEvent(type)) {
+          observer.next({type})
+        }
       }
     }
 
     function onOpen() {
       // The open event of the EventSource API is fired when a connection with an event source is opened.
-      observer.next({type: 'open' as EventTypeName})
+      const type = 'open'
+      if (isRequestedEvent(type)) {
+        observer.next({type})
+      }
     }
 
     function onMessage(message: MessageEvent) {
       const [parseError, event] = parseEvent(message)
-      if (parseError) {
+      if (parseError || !event) {
         observer.error(
           new MessageParseError('Unable to parse EventSource message', {cause: parseError}),
         )
@@ -209,17 +231,25 @@ function connectWithESInstance<EventTypeName extends string>(
         observer.error(
           new DisconnectError(
             `Server disconnected client: ${
-              (event.data as {reason?: string})?.reason || 'unknown error'
+              (isRecord(event.data) &&
+                typeof event.data.reason === 'string' &&
+                event.data.reason) ||
+              'unknown error'
             }`,
           ),
         )
         return
       }
-      observer.next({
-        type: message.type as EventTypeName,
-        id: message.lastEventId,
-        ...(event.data ? {data: event.data} : {}),
-      })
+      // `onMessage` is only ever registered for `REQUIRED_EVENTS` (handled above, and always
+      // returned from before reaching here) and the caller-requested `events` (see
+      // `cleanedEvents` below), so `message.type` is guaranteed to be a requested event here.
+      if (isRequestedEvent(message.type)) {
+        observer.next({
+          type: message.type,
+          id: message.lastEventId,
+          ...(event.data ? {data: event.data} : {}),
+        })
+      }
     }
 
     es.addEventListener('error', onError)
@@ -248,7 +278,7 @@ function connectWithESInstance<EventTypeName extends string>(
 
 function parseEvent(
   message: MessageEvent,
-): [null, {type: string; id: string; data?: unknown}] | [Error, null] {
+): [null, {type: string; id: string; data?: unknown}] | [unknown, null] {
   try {
     const data = typeof message.data === 'string' && JSON.parse(message.data)
     return [
@@ -260,23 +290,26 @@ function parseEvent(
       },
     ]
   } catch (err) {
-    return [err as Error, null]
+    return [err, null]
   }
 }
 
-function extractErrorMessage(err: Any, tag?: string | null) {
-  const error = err.error
+function extractErrorMessage(err: unknown, tag?: string | null): string {
+  const error = isRecord(err) ? err.error : undefined
 
   if (!error) {
-    return err.message || 'Unknown listener error'
+    const message = isRecord(err) ? err.message : undefined
+    return (typeof message === 'string' && message) || 'Unknown listener error'
   }
 
-  if (isQueryParseError(error)) {
-    return formatQueryParseError(error, tag)
-  }
+  if (isRecord(error)) {
+    if (isQueryParseError(error)) {
+      return formatQueryParseError(error, tag)
+    }
 
-  if (error.description) {
-    return error.description
+    if (typeof error.description === 'string') {
+      return error.description
+    }
   }
 
   return typeof error === 'string' ? error : JSON.stringify(error, null, 2)

package/src/data/listen.ts

@@ -1,4 +1,5 @@
-import {Observable, of, throwError} from 'rxjs'
+import {EventSource} from 'eventsource'
+import {Observable, throwError} from 'rxjs'
 import {filter, map} from 'rxjs/operators'
 
 import type {ObservableSanityClient, SanityClient} from '../SanityClient'
@@ -22,8 +23,8 @@ import {pick} from '../util/pick'
 import {_getDataUrl} from './dataMethods'
 import {encodeQueryString} from './encodeQueryString'
 import {connectEventSource} from './eventsource'
-import {eventSourcePolyfill} from './eventsourcePolyfill'
 import {reconnectOnConnectionFailure} from './reconnectOnConnectionFailure'
+import {resolveEventSourceFetch} from './resolveEventSourceFetch'
 
 // Limit is 16K for a _request_, eg including headers. Have to account for an
 // unknown range of headers, but an average EventSource request from Chrome seems
@@ -57,7 +58,8 @@ const defaultOptions = {
 export type MapListenEventNamesToListenEvents<
   R extends Record<string, Any> = Record<string, Any>,
   Events extends (ResumableListenEventNames | ListenEventName)[] = (
-    ResumableListenEventNames | ListenEventName
+    | ResumableListenEventNames
+    | ListenEventName
   )[],
 > = Events extends (infer E)[]
   ? E extends 'welcome'
@@ -134,7 +136,8 @@ export function _listen<
   params?: ListenParams,
   opts: Opts = {} as Opts,
 ): Observable<ListenEventFromOptions<R, Opts>> {
-  const {url, token, withCredentials, requestTagPrefix, headers: configHeaders} = this.config()
+  const config = this.config()
+  const {url, token, withCredentials, requestTagPrefix, headers: configHeaders} = config
   const tag = opts.tag && requestTagPrefix ? [requestTagPrefix, opts.tag].join('.') : opts.tag
   const options = {...defaults(opts, defaultOptions), tag}
   const listenOpts = pick(options, possibleOptions)
@@ -147,29 +150,21 @@ export function _listen<
 
   const listenFor = (options.events ? options.events : ['mutation']) satisfies Opts['events']
 
-  const esOptions: EventSourceInit & {headers?: Record<string, string>} = {}
-  if (withCredentials) {
-    esOptions.withCredentials = true
+  const headers: Record<string, string> = {}
+  if (token) {
+    headers.Authorization = `Bearer ${token}`
   }
-
-  if (token || configHeaders) {
-    esOptions.headers = {}
-
-    if (token) {
-      esOptions.headers.Authorization = `Bearer ${token}`
-    }
-
-    if (configHeaders) {
-      Object.assign(esOptions.headers, configHeaders)
-    }
+  if (configHeaders) {
+    Object.assign(headers, configHeaders)
   }
 
   const initEventSource = () =>
-    // use polyfill if there is no global EventSource or if we need to set headers
-    (typeof EventSource === 'undefined' || esOptions.headers
-      ? eventSourcePolyfill
-      : of(EventSource)
-    ).pipe(map((EventSource) => new EventSource(uri, esOptions)))
+    new EventSource(uri, {
+      fetch: resolveEventSourceFetch(config, {
+        headers: Object.keys(headers).length ? headers : undefined,
+        withCredentials,
+      }),
+    })
 
   return connectEventSource(initEventSource, listenFor).pipe(
     reconnectOnConnectionFailure(),

package/src/data/live.ts

@@ -1,9 +1,12 @@
+import {EventSource} from 'eventsource'
+import type {FetchFunction} from 'get-it'
 import {catchError, mergeMap, Observable, of, throwError} from 'rxjs'
 import {finalize, map} from 'rxjs/operators'
 
 import {CorsOriginError} from '../http/errors'
 import type {ObservableSanityClient, SanityClient} from '../SanityClient'
 import type {
+  InitializedClientConfig,
   LiveEvent,
   LiveEventGoAway,
   LiveEventMessage,
@@ -12,11 +15,12 @@ import type {
   LiveEventWelcome,
   SyncTag,
 } from '../types'
+import {isRecord} from '../util/isRecord'
 import {shareReplayLatest} from '../util/shareReplayLatest'
 import {_getDataUrl} from './dataMethods'
 import {connectEventSource} from './eventsource'
-import {eventSourcePolyfill} from './eventsourcePolyfill'
 import {reconnectOnConnectionFailure} from './reconnectOnConnectionFailure'
+import {pickBaseFetch, resolveEventSourceFetch} from './resolveEventSourceFetch'
 
 const requiredApiVersion = '2021-03-25'
 
@@ -50,6 +54,7 @@ export class LiveClient {
      */
     waitFor?: 'function'
   } = {}): Observable<LiveEvent> {
+    const config = this.#client.config()
     const {
       projectId,
       apiVersion: _apiVersion,
@@ -57,7 +62,7 @@ export class LiveClient {
       withCredentials,
       requestTagPrefix,
       headers: configHeaders,
-    } = this.#client.config()
+    } = config
     const apiVersion = _apiVersion.replace(/^v/, '')
     if (apiVersion !== 'X' && apiVersion < requiredApiVersion) {
       throw new Error(
@@ -83,36 +88,39 @@ export class LiveClient {
     if (waitFor) {
       url.searchParams.set('waitFor', waitFor)
     }
-    const esOptions: EventSourceInit & {headers?: Record<string, string>} = {}
-    if (includeDrafts && withCredentials) {
-      esOptions.withCredentials = true
+    const eventSourceHeaders: Record<string, string> = {}
+    if (includeDrafts && token) {
+      eventSourceHeaders.Authorization = `Bearer ${token}`
     }
-
-    if ((includeDrafts && token) || configHeaders) {
-      esOptions.headers = {}
-
-      if (includeDrafts && token) {
-        esOptions.headers.Authorization = `Bearer ${token}`
-      }
-
-      if (configHeaders) {
-        Object.assign(esOptions.headers, configHeaders)
-      }
+    if (configHeaders) {
+      Object.assign(eventSourceHeaders, configHeaders)
     }
+    const eventSourceWithCredentials = Boolean(includeDrafts && withCredentials)
 
-    const key = `${url.href}::${JSON.stringify(esOptions)}`
-    const existing = eventsCache.get(key)
+    let transportCache = eventsCache.get(config.resolveFetch)
+    if (!transportCache) {
+      transportCache = new Map()
+      eventsCache.set(config.resolveFetch, transportCache)
+    }
+    const cacheKey = JSON.stringify([
+      url.href,
+      typeof config.proxy === 'string' ? config.proxy : null,
+      eventSourceHeaders,
+      eventSourceWithCredentials,
+    ])
+    const existing = transportCache.get(cacheKey)
 
     if (existing) {
       return existing
     }
 
     const initEventSource = () =>
-      // use polyfill if there is no global EventSource or if we need to set headers
-      (typeof EventSource === 'undefined' || esOptions.headers
-        ? eventSourcePolyfill
-        : of(EventSource)
-      ).pipe(map((EventSource) => new EventSource(url.href, esOptions)))
+      new EventSource(url.href, {
+        fetch: resolveEventSourceFetch(config, {
+          headers: Object.keys(eventSourceHeaders).length ? eventSourceHeaders : undefined,
+          withCredentials: eventSourceWithCredentials,
+        }),
+      })
 
     const events = connectEventSource(initEventSource, [
       'message',
@@ -125,7 +133,8 @@ export class LiveClient {
     const checkCors = checkCorsObservable(
       new URL(this.#client.getUrl('/check/cors', false)),
       projectId,
-      esOptions.withCredentials === true,
+      eventSourceWithCredentials,
+      pickBaseFetch(config),
     )
 
     const observable = events
@@ -162,12 +171,15 @@ export class LiveClient {
         }),
       )
       .pipe(
-        finalize(() => eventsCache.delete(key)),
+        finalize(() => {
+          transportCache.delete(cacheKey)
+          if (transportCache.size === 0) eventsCache.delete(config.resolveFetch)
+        }),
         shareReplayLatest({
           predicate: (event) => event.type === 'welcome',
         }),
       )
-    eventsCache.set(key, observable)
+    transportCache.set(cacheKey, observable)
     return observable
   }
 }
@@ -212,35 +224,40 @@ function checkCorsObservable(
   url: URL,
   projectId: string | undefined,
   requireCredentials: boolean,
+  fetcher: FetchFunction,
 ): Observable<void> {
   return new Observable<void>((observer) => {
     const controller = new AbortController()
     const {signal} = controller
-    fetch(url, {method: 'GET', mode: 'cors', credentials: 'omit', signal})
+    fetcher(url.href, {method: 'GET', credentials: 'omit', signal})
       .then((response) => {
         // Aborted or non-2xx: not a confirmed CORS rejection. Fall through with
         // an undefined body so the next step takes the silent-completion path.
-        if (signal.aborted || !response.ok) return
-        return response.json() as Promise<{
-          result?: {allowed?: boolean; withCredentials?: boolean}
-        }>
+        if (signal.aborted || !response.ok) return undefined
+        return response.text()
       })
-      .then((body) => {
+      .then((text) => {
         if (signal.aborted) return
+        // `get-it`'s `FetchResponse` only guarantees `.text()`/`.arrayBuffer()`,
+        // not `.json()`, so the body is parsed by hand here. An empty/aborted
+        // fall-through (`text === undefined`) and malformed JSON both leave
+        // `result` unresolved, taking the same "no signal either way" path.
+        const parsed: unknown = text === undefined ? undefined : JSON.parse(text)
+        const result = isRecord(parsed) ? parsed.result : undefined
         // Check the credentialed case first: if the EventSource was about to
         // send credentials but the project's CORS config doesn't permit them,
         // the credentialed request would fail with a missing
         // `access-control-allow-credentials` header. Surface this as a CORS
         // rejection with `credentials: true` so the deep-link pre-selects the
         // "Allow credentials" toggle.
-        if (requireCredentials && body?.result?.withCredentials === false) {
+        if (requireCredentials && isRecord(result) && result.withCredentials === false) {
           observer.error(new CorsOriginError({projectId, credentials: true}))
           return
         }
         // Generic case: the server actively rejected this origin. Propagate
         // `credentials: requireCredentials` so the deep-link still pre-selects
         // credentials when the caller needed them.
-        if (body?.result?.allowed === false) {
+        if (isRecord(result) && result.allowed === false) {
           observer.error(new CorsOriginError({projectId, credentials: requireCredentials}))
           return
         }
@@ -262,4 +279,12 @@ function checkCorsObservable(
   })
 }
 
-const eventsCache = new Map<string, Observable<LiveEvent>>()
+/**
+ * Cached observables capture their transport (`initEventSource` closes over
+ * `config.resolveFetch` and `config.proxy`), so the cache is scoped per
+ * resolver — `undefined` covers the `globalThis.fetch` fallback.
+ */
+const eventsCache = new Map<
+  InitializedClientConfig['resolveFetch'],
+  Map<string, Observable<LiveEvent>>
+>()

package/src/data/resolveEventSourceFetch.ts

@@ -0,0 +1,104 @@
+import type {EventSourceFetchInit, FetchLikeResponse} from 'eventsource'
+import type {FetchFunction, FetchInit} from 'get-it'
+
+import type {InitializedClientConfig} from '../types'
+
+/** @internal */
+export interface EventSourceFetchOptions {
+  /**
+   * Headers that must be merged into every EventSource request. Used for
+   * the `Authorization` token, custom `headers` from the client config,
+   * etc. — things the native EventSource API has no equivalent for.
+   */
+  headers?: Record<string, string>
+  /**
+   * If the client was configured with `withCredentials: true`, the
+   * resolved fetch forwards `credentials: 'include'` so the browser
+   * attaches cookies to the SSE request.
+   */
+  withCredentials?: boolean
+}
+
+/**
+ * Build a `fetch` implementation suitable for the `eventsource` package's
+ * `fetch` option. Routes the EventSource connection through the same
+ * transport layer the rest of the client uses, so things like the
+ * test-fetch override, the per-request `proxy` config, and `HTTPS_PROXY`
+ * env-var support apply to SSE too.
+ *
+ * Resolution order on each request:
+ *
+ *   1. `config.resolveFetch(config.proxy)` if set — the client's fetch
+ *      resolver, so SSE uses the same transport as regular requests:
+ *      custom fetch variants (incl. the test suite's injected mock),
+ *      undici configuration, an explicit `proxy` config, and env-proxy
+ *      support all apply to SSE too. The Node entry supplies get-it's
+ *      undici-backed fetch (threading the resolver through the env
+ *      instead of importing `get-it/node` directly keeps `undici` out of
+ *      the browser bundle); the browser entry leaves it unset.
+ *   2. `globalThis.fetch`. Note that Node's global fetch does NOT read
+ *      proxy env vars (that is opt-in via `NODE_USE_ENV_PROXY`), which
+ *      is one of the reasons step 1 exists.
+ *
+ * The returned fetch always merges `options.headers` into the outgoing
+ * request, regardless of which underlying fetch was picked.
+ *
+ * @internal
+ */
+export function resolveEventSourceFetch(
+  config: InitializedClientConfig,
+  options: EventSourceFetchOptions = {},
+): EventSourceFetch {
+  const extraHeaders = options.headers
+  const credentials: FetchInit['credentials'] = options.withCredentials ? 'include' : undefined
+
+  return function eventSourceFetch(url, init) {
+    const baseFetch = pickBaseFetch(config)
+
+    // Extra `EventSourceFetchInit` fields get-it's `FetchInit` doesn't
+    // declare (`mode`, `cache`) survive the spread and reach whichever
+    // fetch implementation is effective.
+    const mergedInit: FetchInit = {...init}
+    if (extraHeaders) {
+      const headers = new Headers(init?.headers)
+      for (const [key, value] of Object.entries(extraHeaders)) {
+        headers.set(key, value)
+      }
+      mergedInit.headers = headers
+    }
+    if (credentials !== undefined) {
+      mergedInit.credentials = credentials
+    }
+    // get-it's `FetchResponse` is a structural superset of the package's
+    // `FetchLikeResponse`, so it can be handed over as-is.
+    return baseFetch(typeof url === 'string' ? url : url.href, mergedInit)
+  }
+}
+
+/**
+ * The fetch shape handed to the `eventsource` package: accepts what its
+ * `FetchLike` passes in, requires only what get-it's `FetchFunction`
+ * guarantees back — the full `typeof fetch` contract is not needed anywhere
+ * in this chain.
+ *
+ * @internal
+ */
+export type EventSourceFetch = (
+  url: string | URL,
+  init?: EventSourceFetchInit,
+) => Promise<FetchLikeResponse>
+
+/**
+ * The fetch the client's own transport resolves for this config: the
+ * configured `resolveFetch` (honouring an explicit `proxy`) if present,
+ * otherwise the global fetch. Shared by the EventSource connection and the
+ * `/check/cors` probe so both resolve identically.
+ *
+ * @internal
+ */
+export function pickBaseFetch(config: InitializedClientConfig): FetchFunction {
+  if (config.resolveFetch) {
+    return config.resolveFetch(typeof config.proxy === 'string' ? config.proxy : undefined)
+  }
+  return globalThis.fetch.bind(globalThis)
+}