@sanity/client 8.0.0 → 8.2.0

package/src/data/live.ts

@@ -1,4 +1,5 @@
 import {EventSource} from 'eventsource'
+import type {FetchFunction} from 'get-it'
 import {catchError, mergeMap, Observable, of, throwError} from 'rxjs'
 import {finalize, map} from 'rxjs/operators'
 
@@ -14,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 {reconnectOnConnectionFailure} from './reconnectOnConnectionFailure'
-import {resolveEventSourceFetch} from './resolveEventSourceFetch'
+import {pickBaseFetch, resolveEventSourceFetch} from './resolveEventSourceFetch'
 
 const requiredApiVersion = '2021-03-25'
 
@@ -132,6 +134,7 @@ export class LiveClient {
       new URL(this.#client.getUrl('/check/cors', false)),
       projectId,
       eventSourceWithCredentials,
+      pickBaseFetch(config),
     )
 
     const observable = events
@@ -221,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
         }

package/src/data/resolveEventSourceFetch.ts

@@ -88,7 +88,15 @@ export type EventSourceFetch = (
   init?: EventSourceFetchInit,
 ) => Promise<FetchLikeResponse>
 
-function pickBaseFetch(config: InitializedClientConfig): FetchFunction {
+/**
+ * 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)
   }

package/src/defineCreateClient.ts

@@ -1,6 +1,8 @@
 import {defineRequester, type EnvironmentOptions} from './http/request'
 import type {ClientConfig, HttpRequest} from './types'
 
+export {isTimeoutError, type TimeoutErrorLike} from 'get-it'
+
 export {validateApiPerspective} from './config'
 export {
   ChannelError,
@@ -55,10 +57,12 @@ export default function defineCreateClientExports<
     // this in `new Observable(...)` (see `_observe` in dataMethods).
     // Redirects are surfaced rather than followed unless a request opts in
     // (via the public `maxRedirects` option, translated in `requestOptions`).
-    const httpRequest: HttpRequest = async (options) => {
+    const performRequest = async (options: Parameters<HttpRequest>[0]): Promise<unknown> => {
       const event = await clientRequesterPromise({redirect: 'manual', ...options})
       return event.body
     }
+    const httpRequest: HttpRequest = (options, requestHandler) =>
+      requestHandler ? requestHandler(options, performRequest) : performRequest(options)
     // Populate `requester` on the initialized config so internal paths
     // (e.g. the asset upload event stream) can reach the underlying transport.
     // `resolveFetch` is threaded onto the config so request building and

package/src/functions/FunctionsClient.ts

@@ -0,0 +1,66 @@
+import {lastValueFrom, type Observable} from 'rxjs'
+
+import type {ObservableSanityClient, SanityClient} from '../SanityClient'
+import type {HttpRequest} from '../types'
+import {_invoke, type InvokeFunctionRequest} from './invoke'
+
+/** @public */
+export class ObservableFunctionsClient {
+  #client: ObservableSanityClient
+  #httpRequest: HttpRequest
+  constructor(client: ObservableSanityClient, httpRequest: HttpRequest) {
+    this.#client = client
+    this.#httpRequest = httpRequest
+  }
+
+  /**
+   * Invoke a deployed function by its blueprint name.
+   *
+   * The name is resolved within the stack given by `stackId` on the request or
+   * the client config. Passes the function's return value once it finishes.
+   *
+   * @param functionName - name of the function, as declared in the blueprint
+   * @param request - payload and request options
+   */
+  invoke<R = unknown>(
+    functionName: string,
+    request?: InvokeFunctionRequest,
+  ): Observable<R | undefined> {
+    return _invoke<R>(this.#client, this.#httpRequest, functionName, request)
+  }
+}
+
+/** @public */
+export class FunctionsClient {
+  #client: SanityClient
+  #httpRequest: HttpRequest
+  constructor(client: SanityClient, httpRequest: HttpRequest) {
+    this.#client = client
+    this.#httpRequest = httpRequest
+  }
+
+  /**
+   * Invoke a deployed function by its blueprint name.
+   *
+   * The name is resolved within the stack given by `stackId` on the request or
+   * the client config, which costs one extra request per call. Rejects if the
+   * stack has no function by that name, or if the name resolves to anything
+   * other than a `sanity.function.pubsub` function.
+   *
+   * The lookup is scoped to `projectId`, or to `organizationId` when one is set
+   * for a stack deployed at organization scope.
+   *
+   * The request stays open until the function finishes, and resolves with its
+   * return value, or `undefined` if it returns nothing. Long-running functions
+   * may need an explicit `timeout`.
+   *
+   * @param functionName - name of the function, as declared in the blueprint
+   * @param request - payload and request options
+   */
+  invoke<R = unknown>(
+    functionName: string,
+    request?: InvokeFunctionRequest,
+  ): Promise<R | undefined> {
+    return lastValueFrom(_invoke<R>(this.#client, this.#httpRequest, functionName, request))
+  }
+}

package/src/functions/invoke.ts

@@ -0,0 +1,176 @@
+import {defer, map, mergeMap, type Observable} from 'rxjs'
+
+import {_requestObservable} from '../data/dataMethods'
+import type {ObservableSanityClient, SanityClient} from '../SanityClient'
+import type {HttpRequest, InitializedClientConfig} from '../types'
+
+/** Function resource types in a blueprint are namespaced under this prefix. */
+const FUNCTION_RESOURCE_PREFIX = 'sanity.function.'
+const INVOKABLE_FUNCTION_TYPE = 'sanity.function.pubsub'
+
+/** @public */
+export interface InvokeFunctionEvent {
+  /**
+   * Payload handed to the function.
+   * The function receives it as `event.data`.
+   */
+  data?: unknown
+}
+
+/** @public */
+export interface InvokeFunctionRequest {
+  event?: InvokeFunctionEvent
+  /**
+   * Stack to resolve the function name against.
+   * Overrides `stackId` from the client config.
+   */
+  stackId?: string
+  /**
+   * Organization owning the stack.
+   */
+  organizationId?: string
+  /**
+   * Milliseconds to wait for the function to return.
+   */
+  timeout?: number
+  /** Abort the invocation. */
+  signal?: AbortSignal
+}
+
+/**
+ * Subset of a stack resource the client needs in order to resolve a name.
+ *
+ * @internal
+ */
+interface StackResource {
+  name: string
+  type: string
+  /** Provider-side id. For a function resource, the function id. */
+  externalId?: string
+}
+
+type Client = SanityClient | ObservableSanityClient
+
+const scopeHeaders = (
+  config: InitializedClientConfig,
+  request: InvokeFunctionRequest | undefined,
+): Record<string, string> => {
+  const organizationId = request?.organizationId || config.organizationId
+  if (organizationId) {
+    return {
+      'X-Sanity-Scope-Type': 'organization',
+      'X-Sanity-Scope-Id': organizationId,
+    }
+  }
+
+  const {projectId} = config
+  if (!projectId) {
+    throw new Error(
+      '`functions.invoke()` requires a `projectId` to be set in the client config, or an ' +
+        '`organizationId` for a stack deployed at organization scope',
+    )
+  }
+
+  return {
+    'X-Sanity-Scope-Type': 'project',
+    'X-Sanity-Scope-Id': projectId,
+  }
+}
+
+/**
+ * A per-call `stackId` overrides the one in the client config.
+ */
+const resolveStackId = (
+  config: InitializedClientConfig,
+  request: InvokeFunctionRequest | undefined,
+): string => {
+  const stackId = request?.stackId || config.stackId
+  if (!stackId) {
+    throw new Error(
+      '`functions.invoke()` requires a `stackId`, either in the client config or on the request. ' +
+        'Function names are only unique within a stack.',
+    )
+  }
+
+  return stackId
+}
+
+/**
+ * The invoke route is keyed by function id, but callers know functions by the
+ * name declared in the blueprint. Names are unique within a stack, so the stack
+ * both makes the name resolvable and confines the call to its own functions.
+ *
+ * @internal
+ */
+function _resolveFunctionId(
+  client: Client,
+  httpRequest: HttpRequest,
+  functionName: string,
+  stackId: string,
+  headers: Record<string, string>,
+  request: InvokeFunctionRequest | undefined,
+): Observable<string> {
+  return _requestObservable<{resources?: StackResource[]}>(client, httpRequest, {
+    method: 'GET',
+    url: `/blueprints/stacks/${stackId}`,
+    headers,
+    signal: request?.signal,
+  }).pipe(
+    map((stack) => {
+      const match = (stack?.resources || []).find(
+        (resource) =>
+          resource.type?.startsWith(FUNCTION_RESOURCE_PREFIX) && resource.name === functionName,
+      )
+
+      if (!match) {
+        throw new Error(`Function "${functionName}" not found in stack "${stackId}"`)
+      }
+
+      if (!match.externalId) {
+        throw new Error(
+          `Function "${functionName}" is declared in stack "${stackId}" but is not deployed`,
+        )
+      }
+
+      if (match.type !== INVOKABLE_FUNCTION_TYPE) {
+        throw new Error(`Function invocation is not supported for ${match.type}`)
+      }
+
+      return match.externalId
+    }),
+  )
+}
+
+/** @internal */
+export function _invoke<R = unknown>(
+  client: Client,
+  httpRequest: HttpRequest,
+  functionName: string,
+  request?: InvokeFunctionRequest,
+): Observable<R | undefined> {
+  // Deferred so a bad config surfaces as an error on the returned observable
+  // (and so a rejected promise) rather than throwing at the call site.
+  return defer(() => {
+    const config = client.config()
+    const headers = scopeHeaders(config, request)
+    const stackId = resolveStackId(config, request)
+
+    return _resolveFunctionId(client, httpRequest, functionName, stackId, headers, request).pipe(
+      // A function that returns nothing answers 204, which the transport parses
+      // to an `undefined` body. The status code is not observable from here —
+      // the `HttpRequest` boundary resolves to the body alone — so an empty
+      // response and a function that returned nothing both surface as
+      // `undefined`.
+      mergeMap((functionId) =>
+        _requestObservable<R | undefined>(client, httpRequest, {
+          method: 'POST',
+          url: `/functions/${functionId}/invoke`,
+          headers,
+          body: {event: {data: request?.event?.data ?? {}}},
+          timeout: request?.timeout,
+          signal: request?.signal,
+        }),
+      ),
+    )
+  })
+}

package/src/http/browserUpload.ts

@@ -76,6 +76,7 @@ export function uploadWithProgress<T>(options: BrowserUploadOptions): Observable
             statusText: xhr.statusText,
             headers: errorHeaders,
             body: parseJsonText(xhr.responseText, errorHeaders),
+            url: xhr.responseURL,
           },
           url,
           method,

package/src/http/errors.ts

@@ -39,6 +39,7 @@ export function httpResponseFromFetch(
     statusText: string
     headers: Headers
     body: unknown
+    url: string
   },
   reqUrl: string,
   reqMethod: string,
@@ -48,7 +49,7 @@ export function httpResponseFromFetch(
     statusMessage: res.statusText || null,
     headers: headersToRecord(res.headers),
     body: res.body,
-    url: reqUrl,
+    url: res.url || reqUrl,
     method: reqMethod,
   }
 }

package/src/http/request.ts

@@ -1,7 +1,7 @@
 import {
   createRequester,
   type FetchFunction,
-  HttpError as GetItHttpError,
+  isHttpError as isGetItHttpError,
   type RequestOptions as FetchRequestOptions,
   type TransformMiddleware,
   type WrappingMiddleware,
@@ -40,8 +40,9 @@ export interface ResponseEvent {
 }
 
 /**
- * Legacy "requester" type — the result of `defineHttpRequest`. Returns a
- * single-event Observable for compatibility with the rest of the codebase.
+ * Legacy "requester" type - the observable half of `defineRequester`'s
+ * result. Returns a single-event Observable for compatibility with the rest
+ * of the codebase.
  *
  * @internal
  */
@@ -163,14 +164,6 @@ export function defineRequester(
   return {promise, observable}
 }
 
-/** @internal */
-export function defineHttpRequest(
-  envOptions: EnvironmentOptions,
-  config: HttpRequestConfig = {},
-): LegacyRequester {
-  return defineRequester(envOptions, config).observable
-}
-
 /**
  * Options describing the environment-specific defaults (Node vs. browser).
  *
@@ -208,7 +201,7 @@ async function executeRequest(
   try {
     response = await requester(fetchOptions)
   } catch (err) {
-    if (err instanceof GetItHttpError) {
+    if (isGetItHttpError(err)) {
       // `err.body` is the response body as a string (get-it v9 stores the
       // already-decoded text), regardless of which response variant
       // `err.response` is.
@@ -220,6 +213,7 @@ async function executeRequest(
           statusText: err.statusText,
           headers: err.headers,
           body: errBody,
+          url: err.response.url ?? err.url,
         },
         url,
         method,
@@ -240,7 +234,7 @@ async function executeRequest(
     statusCode: response.status,
     statusMessage: response.statusText || null,
     headers: headersToRecord(response.headers),
-    url,
+    url: response.url || url,
     method,
   }
 }
@@ -291,7 +285,7 @@ function headersToRecord(headers: Headers): Record<string, string> {
 function shouldRetryRequest(err: unknown, attempt: number, options: FetchRequestOptions): boolean {
   // HTTP errors aren't usually retryable, but Content Lake gives us a few
   // status codes where retrying *is* the right move.
-  if (err instanceof GetItHttpError) {
+  if (isGetItHttpError(err)) {
     const isSafe = (options.method ?? 'GET') === 'GET' || options.method === 'HEAD'
     const isQuery = (options.url ?? '').includes('/data/query')
     const status = err.status

package/src/mediaLibrary/MediaLibraryVideoClient.ts

@@ -111,7 +111,7 @@ function isSanityReference(
  * @param assetIdentifier - The asset identifier - either a asset instance id or a Media Library GDR
  * @returns The asset instance id and library id
  */
-export function parseAssetInstanceId(assetIdentifier: MediaLibraryAssetInstanceIdentifier): {
+function parseAssetInstanceId(assetIdentifier: MediaLibraryAssetInstanceIdentifier): {
   instanceId: string
   libraryId?: string
 } {