@sanity/client 7.26.2 → 8.1.0

package/src/datasets/DatasetsClient.ts

@@ -1,6 +1,6 @@
-import {lastValueFrom, type Observable} from 'rxjs'
+import {type Observable} from 'rxjs'
 
-import {_request} from '../data/dataMethods'
+import {_request, _requestObservable} from '../data/dataMethods'
 import type {ObservableSanityClient, SanityClient} from '../SanityClient'
 import type {
   DatasetCreateOptions,
@@ -29,7 +29,7 @@ export class ObservableDatasetsClient {
    * @param options - Options for the dataset, including optional embeddings configuration
    */
   create(name: string, options?: DatasetCreateOptions): Observable<DatasetResponse> {
-    return _modify<DatasetResponse>(this.#client, this.#httpRequest, 'PUT', name, options)
+    return _modifyObservable<DatasetResponse>(this.#client, this.#httpRequest, 'PUT', name, options)
   }
 
   /**
@@ -39,7 +39,13 @@ export class ObservableDatasetsClient {
    * @param options - New options for the dataset
    */
   edit(name: string, options?: DatasetEditOptions): Observable<DatasetResponse> {
-    return _modify<DatasetResponse>(this.#client, this.#httpRequest, 'PATCH', name, options)
+    return _modifyObservable<DatasetResponse>(
+      this.#client,
+      this.#httpRequest,
+      'PATCH',
+      name,
+      options,
+    )
   }
 
   /**
@@ -48,7 +54,7 @@ export class ObservableDatasetsClient {
    * @param name - Name of the dataset to delete
    */
   delete(name: string): Observable<{deleted: true}> {
-    return _modify<{deleted: true}>(this.#client, this.#httpRequest, 'DELETE', name)
+    return _modifyObservable<{deleted: true}>(this.#client, this.#httpRequest, 'DELETE', name)
   }
 
   /**
@@ -58,13 +64,13 @@ export class ObservableDatasetsClient {
     validate.resourceGuard('dataset', this.#client.config())
     const config = this.#client.config()
     const projectId = config.projectId
-    let uri = '/datasets'
+    let url = '/datasets'
     if (config.useProjectHostname === false) {
-      uri = `/projects/${projectId}/datasets`
+      url = `/projects/${projectId}/datasets`
     }
 
-    return _request<DatasetsResponse>(this.#client, this.#httpRequest, {
-      uri,
+    return _requestObservable<DatasetsResponse>(this.#client, this.#httpRequest, {
+      url,
       tag: null,
     })
   }
@@ -77,8 +83,8 @@ export class ObservableDatasetsClient {
   getEmbeddingsSettings(name: string): Observable<EmbeddingsSettings> {
     validate.resourceGuard('dataset', this.#client.config())
     validate.dataset(name)
-    return _request<EmbeddingsSettings>(this.#client, this.#httpRequest, {
-      uri: _embeddingsSettingsUri(this.#client, name),
+    return _requestObservable<EmbeddingsSettings>(this.#client, this.#httpRequest, {
+      url: _embeddingsSettingsUri(this.#client, name),
       tag: null,
     })
   }
@@ -92,9 +98,9 @@ export class ObservableDatasetsClient {
   editEmbeddingsSettings(name: string, settings: EmbeddingsSettingsBody): Observable<void> {
     validate.resourceGuard('dataset', this.#client.config())
     validate.dataset(name)
-    return _request<void>(this.#client, this.#httpRequest, {
+    return _requestObservable<void>(this.#client, this.#httpRequest, {
       method: 'PUT',
-      uri: _embeddingsSettingsUri(this.#client, name),
+      url: _embeddingsSettingsUri(this.#client, name),
       body: settings,
       tag: null,
     })
@@ -118,9 +124,7 @@ export class DatasetsClient {
    */
   create(name: string, options?: DatasetCreateOptions): Promise<DatasetResponse> {
     validate.resourceGuard('dataset', this.#client.config())
-    return lastValueFrom(
-      _modify<DatasetResponse>(this.#client, this.#httpRequest, 'PUT', name, options),
-    )
+    return _modify<DatasetResponse>(this.#client, this.#httpRequest, 'PUT', name, options)
   }
 
   /**
@@ -131,9 +135,7 @@ export class DatasetsClient {
    */
   edit(name: string, options?: DatasetEditOptions): Promise<DatasetResponse> {
     validate.resourceGuard('dataset', this.#client.config())
-    return lastValueFrom(
-      _modify<DatasetResponse>(this.#client, this.#httpRequest, 'PATCH', name, options),
-    )
+    return _modify<DatasetResponse>(this.#client, this.#httpRequest, 'PATCH', name, options)
   }
 
   /**
@@ -143,7 +145,7 @@ export class DatasetsClient {
    */
   delete(name: string): Promise<{deleted: true}> {
     validate.resourceGuard('dataset', this.#client.config())
-    return lastValueFrom(_modify<{deleted: true}>(this.#client, this.#httpRequest, 'DELETE', name))
+    return _modify<{deleted: true}>(this.#client, this.#httpRequest, 'DELETE', name)
   }
 
   /**
@@ -153,14 +155,15 @@ export class DatasetsClient {
     validate.resourceGuard('dataset', this.#client.config())
     const config = this.#client.config()
     const projectId = config.projectId
-    let uri = '/datasets'
+    let url = '/datasets'
     if (config.useProjectHostname === false) {
-      uri = `/projects/${projectId}/datasets`
+      url = `/projects/${projectId}/datasets`
     }
 
-    return lastValueFrom(
-      _request<DatasetsResponse>(this.#client, this.#httpRequest, {uri, tag: null}),
-    )
+    return _request<DatasetsResponse>(this.#client, this.#httpRequest, {
+      url,
+      tag: null,
+    })
   }
 
   /**
@@ -171,12 +174,10 @@ export class DatasetsClient {
   getEmbeddingsSettings(name: string): Promise<EmbeddingsSettings> {
     validate.resourceGuard('dataset', this.#client.config())
     validate.dataset(name)
-    return lastValueFrom(
-      _request<EmbeddingsSettings>(this.#client, this.#httpRequest, {
-        uri: _embeddingsSettingsUri(this.#client, name),
-        tag: null,
-      }),
-    )
+    return _request<EmbeddingsSettings>(this.#client, this.#httpRequest, {
+      url: _embeddingsSettingsUri(this.#client, name),
+      tag: null,
+    })
   }
 
   /**
@@ -188,14 +189,12 @@ export class DatasetsClient {
   editEmbeddingsSettings(name: string, settings: EmbeddingsSettingsBody): Promise<void> {
     validate.resourceGuard('dataset', this.#client.config())
     validate.dataset(name)
-    return lastValueFrom(
-      _request<void>(this.#client, this.#httpRequest, {
-        method: 'PUT',
-        uri: _embeddingsSettingsUri(this.#client, name),
-        body: settings,
-        tag: null,
-      }),
-    )
+    return _request<void>(this.#client, this.#httpRequest, {
+      method: 'PUT',
+      url: _embeddingsSettingsUri(this.#client, name),
+      body: settings,
+      tag: null,
+    })
   }
 }
 
@@ -210,7 +209,7 @@ function _embeddingsSettingsUri(
   return `/datasets/${name}/settings/embeddings`
 }
 
-function _modify<R = unknown>(
+function _modifyObservable<R = unknown>(
   client: SanityClient | ObservableSanityClient,
   httpRequest: HttpRequest,
   method: 'DELETE' | 'PATCH' | 'PUT',
@@ -220,9 +219,27 @@ function _modify<R = unknown>(
   validate.resourceGuard('dataset', client.config())
   validate.dataset(name)
 
+  return _requestObservable<R>(client, httpRequest, {
+    method,
+    url: `/datasets/${name}`,
+    body: options,
+    tag: null,
+  })
+}
+
+function _modify<R = unknown>(
+  client: SanityClient | ObservableSanityClient,
+  httpRequest: HttpRequest,
+  method: 'DELETE' | 'PATCH' | 'PUT',
+  name: string,
+  options?: DatasetCreateOptions | DatasetEditOptions,
+): Promise<R> {
+  validate.resourceGuard('dataset', client.config())
+  validate.dataset(name)
+
   return _request<R>(client, httpRequest, {
     method,
-    uri: `/datasets/${name}`,
+    url: `/datasets/${name}`,
     body: options,
     tag: null,
   })

package/src/defineCreateClient.ts

@@ -1,7 +1,7 @@
-import type {Middlewares} from 'get-it'
+import {defineRequester, type EnvironmentOptions} from './http/request'
+import type {ClientConfig, HttpRequest} from './types'
 
-import {defineHttpRequest} from './http/request'
-import type {Any, ClientConfig, HttpRequest} from './types'
+export {isTimeoutError, type TimeoutErrorLike} from 'get-it'
 
 export {validateApiPerspective} from './config'
 export {
@@ -29,9 +29,6 @@ export {
 export * from './SanityClient'
 export * from './types'
 
-/** @alpha */
-export {adapter as unstable__adapter, environment as unstable__environment} from 'get-it'
-
 /**
  * Create the `requester` and `createClient` exports, that have environment specific middleware for node and browsers
  * @internal
@@ -40,27 +37,46 @@ export default function defineCreateClientExports<
   SanityClientType,
   ClientConfigType extends ClientConfig,
 >(
-  envMiddleware: Middlewares,
+  envOptions: EnvironmentOptions,
   ClassConstructor: new (httpRequest: HttpRequest, config: ClientConfigType) => SanityClientType,
 ) {
-  // Set the http client to use for requests, and its environment specific middleware
-  const defaultRequester = defineHttpRequest(envMiddleware)
+  // Set the http client to use for requests, and its environment specific options
+  const defaultRequester = defineRequester(envOptions).observable
 
   const createClient = (config: ClientConfigType) => {
-    const clientRequester = defineHttpRequest(envMiddleware, {
-      ignoreWarnings: config.ignoreWarnings,
-    })
-    return new ClassConstructor(
-      (options, requester) =>
-        (requester || clientRequester)({
-          maxRedirects: 0,
-          maxRetries: config.maxRetries,
-          retryDelay: config.retryDelay,
-          lineage: config.lineage,
-          ...options,
-        } as Any),
-      config,
+    const {observable: clientRequester, promise: clientRequesterPromise} = defineRequester(
+      envOptions,
+      {
+        ignoreWarnings: config.ignoreWarnings,
+        maxRetries: config.maxRetries,
+        retryDelay: config.retryDelay,
+      },
     )
+    // The single transport for the whole client. Resolves a request to its
+    // parsed response body as a Promise; the observable client surface wraps
+    // 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 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
+    // EventSource fetches can reach the environment's fetch without importing
+    // `get-it/node` from a browser-shared module (would leak `undici` into
+    // the browser bundle). A caller-supplied `resolveFetch` wins over the
+    // environment's — that is the supported way to swap the transport (the
+    // test suite injects its mock fetch through it).
+    const resolvedConfig = {
+      ...config,
+      requester: clientRequester,
+      resolveFetch: config.resolveFetch ?? envOptions.resolveFetch,
+    }
+    return new ClassConstructor(httpRequest, resolvedConfig)
   }
 
   return {requester: defaultRequester, createClient}

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/browserMiddleware.ts

@@ -1 +1,7 @@
-export default []
+import type {EnvironmentOptions} from './request'
+
+const environment: EnvironmentOptions = {
+  middleware: [],
+}
+
+export default environment