@sanity/client 7.19.0 → 7.21.0

package/dist/stega.d.ts

@@ -804,6 +804,32 @@ export declare interface ClientConfig {
    * Lineage token for recursion control
    */
   lineage?: string
+  /**
+   * A custom request handler that intercepts all HTTP requests made by the client.
+   *
+   * Useful for logging, adding custom headers, refreshing auth tokens, rate limiting, etc.
+   *
+   * When using `withConfig()`, the new handler **replaces** the previous one (it does not
+   * wrap it). To compose handlers, you can chain them manually:
+   *
+   * ```ts
+   * const parent = createClient({...config, _requestHandler: handlerA})
+   * const child = parent.withConfig({
+   *   _requestHandler: (req, defaultRequester) =>
+   *     handlerB(req, (opts) => handlerA(opts, defaultRequester)),
+   * })
+   * ```
+   *
+   * Setting `_requestHandler` to `undefined` via `withConfig()` removes the handler.
+   *
+   * Note: This only applies to HTTP requests. Real-time listener connections
+   * (`client.listen()`) use EventSource and are not intercepted by this handler.
+   *
+   * @internal
+   * @deprecated Don't use outside of Sanity internals
+   * @see {@link RequestHandler}
+   */
+  _requestHandler?: RequestHandler
 }
 
 declare type ClientConfigResource =
@@ -2299,6 +2325,13 @@ export declare type ListenParams = {
   [key: string]: Any
 }
 
+declare type ListOptions = {
+  includeMembers?: boolean
+  includeFeatures?: boolean
+  organizationId?: string
+  onlyExplicitMembership?: boolean
+}
+
 /**
  * @public
  */
@@ -2311,6 +2344,7 @@ export declare class LiveClient {
   events({
     includeDrafts,
     tag: _tag,
+    waitFor,
   }?: {
     includeDrafts?: boolean
     /**
@@ -2319,6 +2353,11 @@ export declare class LiveClient {
      * @defaultValue `undefined`
      */
     tag?: string
+    /**
+     * Delays events until after a Sanity Function has processed them and called the callback endpoint.
+     * When omitted, events are delivered immediately.
+     */
+    waitFor?: 'function'
   }): Observable<LiveEvent>
 }
 
@@ -2862,19 +2901,13 @@ export declare class ObservableProjectsClient {
    *
    * @param options - Options for the list request
    *   - `includeMembers` - Whether to include members in the response (default: true)
+   *   - `includeFeatures` - Whether to include features in the response (default: true)
    *   - `organizationId` - ID of the organization to fetch projects for
-   *   - `onlyExplicitMembership` - Only include projects where the user has explicit membership (default: false)
-   */
-  list(options?: {
-    includeMembers?: true
-    organizationId?: string
-    onlyExplicitMembership?: boolean
-  }): Observable<SanityProject[]>
-  list(options?: {
-    includeMembers?: false
-    organizationId?: string
-    onlyExplicitMembership?: boolean
-  }): Observable<Omit<SanityProject, 'members'>[]>
+   *   - `onlyExplicitMembership` - Whether to include only projects with explicit membership (default: false)
+   */
+  list<T extends ListOptions>(
+    options?: T,
+  ): Observable<Omit<SanityProject, OmittedProjectFields<T>>[]>
   /**
    * Fetch a project by project ID
    *
@@ -4035,6 +4068,18 @@ export declare class ObservableUsersClient {
   ): Observable<T extends 'me' ? CurrentSanityUser : SanityUser>
 }
 
+declare type OmittedProjectFields<T extends ListOptions | undefined> =
+  | (T extends {
+      includeMembers: false
+    }
+      ? 'members'
+      : never)
+  | (T extends {
+      includeFeatures: false
+    }
+      ? 'features'
+      : never)
+
 /**
  * The listener connection has been established
  * note: it's usually a better option to use the 'welcome' event
@@ -4251,19 +4296,11 @@ export declare class ProjectsClient {
    *
    * @param options - Options for the list request
    *   - `includeMembers` - Whether to include members in the response (default: true)
+   *   - `includeFeatures` - Whether to include features in the response (default: true)
    *   - `organizationId` - ID of the organization to fetch projects for
-   *   - `onlyExplicitMembership` - Only include projects where the user has explicit membership (default: false)
-   */
-  list(options?: {
-    includeMembers?: true
-    organizationId?: string
-    onlyExplicitMembership?: boolean
-  }): Promise<SanityProject[]>
-  list(options?: {
-    includeMembers?: false
-    organizationId?: string
-    onlyExplicitMembership?: boolean
-  }): Promise<Omit<SanityProject, 'members'>[]>
+   *   - `onlyExplicitMembership` - Whether to include only projects with explicit membership (default: false)
+   */
+  list<T extends ListOptions>(options?: T): Promise<Omit<SanityProject, OmittedProjectFields<T>>[]>
   /**
    * Fetch a project by project ID
    *
@@ -4946,6 +4983,44 @@ export declare interface ReplaceVersionAction {
  */
 export declare const requester: Requester
 
+/**
+ * A function that intercepts HTTP requests made by the client.
+ *
+ * Receives the resolved request options, a `defaultRequester` function that
+ * executes the request through the normal pipeline, and a `client` instance
+ * without a `_requestHandler` (to avoid recursive interception).
+ *
+ * The consumer can:
+ * - Modify request options before calling `defaultRequester`
+ * - Transform the response stream (e.g. via `pipe`)
+ * - Skip `defaultRequester` entirely and return a custom Observable
+ * - Use `client` to make additional requests (e.g. refresh an auth token on 401)
+ *
+ * When set via `withConfig()`, the new handler **replaces** (not wraps) the previous one.
+ *
+ * Note: This only applies to HTTP requests. Real-time listener connections
+ * (`client.listen()`) use EventSource and are not intercepted by this handler.
+ *
+ * @param request - The resolved request options including `url`
+ * @param defaultRequester - Executes the request through the normal pipeline
+ * @param client - A client instance with the same configuration but without a `_requestHandler`,
+ *   useful for making side requests (e.g. token refresh) without triggering the handler recursively
+ *
+ * @internal
+ * @deprecated Don't use outside of Sanity internals
+ */
+export declare type RequestHandler = (
+  request: RequestOptions & {
+    url: string
+  },
+  defaultRequester: (
+    options: RequestOptions & {
+      url: string
+    },
+  ) => Observable<HttpRequestEvent>,
+  client: SanityClient,
+) => Observable<HttpRequestEvent>
+
 /** @internal */
 export declare interface RequestObservableOptions extends Omit<RequestOptions, 'url'> {
   url?: string
@@ -5922,6 +5997,7 @@ export declare interface SanityProject {
   pendingInvites?: number
   maxRetentionDays?: number
   members: SanityProjectMember[]
+  features: string[]
   metadata: {
     cliInitializedAt?: string
     color?: string

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/client",
-  "version": "7.19.0",
+  "version": "7.21.0",
   "description": "Client for retrieving, creating and patching data from Sanity.io",
   "keywords": [
     "sanity",
@@ -130,7 +130,7 @@
   },
   "dependencies": {
     "@sanity/eventsource": "^5.0.2",
-    "get-it": "^8.7.0",
+    "get-it": "^8.7.2",
     "nanoid": "^3.3.11",
     "rxjs": "^7.0.0"
   },

package/src/SanityClient.ts

@@ -43,6 +43,7 @@ import type {
   RawQuerylessQueryResponse,
   RawQueryResponse,
   RawRequestOptions,
+  RequestOptions,
   SanityDocument,
   SanityDocumentStub,
   SingleActionResult,
@@ -87,6 +88,7 @@ export class ObservableSanityClient {
    * Private properties
    */
   #clientConfig: InitializedClientConfig
+  #originalHttpRequest: HttpRequest
   #httpRequest: HttpRequest
 
   /**
@@ -97,7 +99,22 @@ export class ObservableSanityClient {
   constructor(httpRequest: HttpRequest, config: ClientConfig = defaultConfig) {
     this.config(config)
 
-    this.#httpRequest = httpRequest
+    this.#originalHttpRequest = httpRequest
+    const requestHandler = config._requestHandler
+
+    this.#httpRequest = requestHandler
+      ? (() => {
+          let bareClient: SanityClient | undefined
+          const wrapped: HttpRequest = (options, requester) => {
+            const opts = options as RequestOptions & {url: string}
+            if (!bareClient) {
+              bareClient = new SanityClient(httpRequest, {...config, _requestHandler: undefined})
+            }
+            return requestHandler(opts, (o) => httpRequest(o, requester), bareClient)
+          }
+          return wrapped
+        })()
+      : httpRequest
 
     this.assets = new ObservableAssetsClient(this, this.#httpRequest)
     this.datasets = new ObservableDatasetsClient(this, this.#httpRequest)
@@ -117,7 +134,7 @@ export class ObservableSanityClient {
    * Clone the client - returns a new instance
    */
   clone(): ObservableSanityClient {
-    return new ObservableSanityClient(this.#httpRequest, this.config())
+    return new ObservableSanityClient(this.#originalHttpRequest, this.config())
   }
 
   /**
@@ -150,7 +167,7 @@ export class ObservableSanityClient {
    */
   withConfig(newConfig?: Partial<ClientConfig>): ObservableSanityClient {
     const thisConfig = this.config()
-    return new ObservableSanityClient(this.#httpRequest, {
+    return new ObservableSanityClient(this.#originalHttpRequest, {
       ...thisConfig,
       ...newConfig,
       stega: {
@@ -1128,6 +1145,7 @@ export class SanityClient {
    * Private properties
    */
   #clientConfig: InitializedClientConfig
+  #originalHttpRequest: HttpRequest
   #httpRequest: HttpRequest
 
   /**
@@ -1138,7 +1156,21 @@ export class SanityClient {
   constructor(httpRequest: HttpRequest, config: ClientConfig = defaultConfig) {
     this.config(config)
 
-    this.#httpRequest = httpRequest
+    this.#originalHttpRequest = httpRequest
+    const requestHandler = config._requestHandler
+    this.#httpRequest = requestHandler
+      ? (() => {
+          let bareClient: SanityClient | undefined
+          const wrapped: HttpRequest = (options, requester) => {
+            const opts = options as RequestOptions & {url: string}
+            if (!bareClient) {
+              bareClient = new SanityClient(httpRequest, {...config, _requestHandler: undefined})
+            }
+            return requestHandler(opts, (o) => httpRequest(o, requester), bareClient)
+          }
+          return wrapped
+        })()
+      : httpRequest
 
     this.assets = new AssetsClient(this, this.#httpRequest)
     this.datasets = new DatasetsClient(this, this.#httpRequest)
@@ -1160,7 +1192,7 @@ export class SanityClient {
    * Clone the client - returns a new instance
    */
   clone(): SanityClient {
-    return new SanityClient(this.#httpRequest, this.config())
+    return new SanityClient(this.#originalHttpRequest, this.config())
   }
 
   /**
@@ -1197,7 +1229,7 @@ export class SanityClient {
    */
   withConfig(newConfig?: Partial<ClientConfig>): SanityClient {
     const thisConfig = this.config()
-    return new SanityClient(this.#httpRequest, {
+    return new SanityClient(this.#originalHttpRequest, {
       ...thisConfig,
       ...newConfig,
       stega: {

package/src/data/live.ts

@@ -35,6 +35,7 @@ export class LiveClient {
   events({
     includeDrafts = false,
     tag: _tag,
+    waitFor,
   }: {
     includeDrafts?: boolean
     /**
@@ -43,6 +44,11 @@ export class LiveClient {
      * @defaultValue `undefined`
      */
     tag?: string
+    /**
+     * Delays events until after a Sanity Function has processed them and called the callback endpoint.
+     * When omitted, events are delivered immediately.
+     */
+    waitFor?: 'function'
   } = {}): Observable<LiveEvent> {
     const {
       projectId,
@@ -74,6 +80,9 @@ export class LiveClient {
     if (includeDrafts) {
       url.searchParams.set('includeDrafts', 'true')
     }
+    if (waitFor) {
+      url.searchParams.set('waitFor', waitFor)
+    }
     const esOptions: EventSourceInit & {headers?: Record<string, string>} = {}
     if (includeDrafts && withCredentials) {
       esOptions.withCredentials = true

package/src/projects/ProjectsClient.ts

@@ -4,6 +4,17 @@ import {_request} from '../data/dataMethods'
 import type {ObservableSanityClient, SanityClient} from '../SanityClient'
 import type {HttpRequest, SanityProject} from '../types'
 
+type ListOptions = {
+  includeMembers?: boolean
+  includeFeatures?: boolean
+  organizationId?: string
+  onlyExplicitMembership?: boolean
+}
+
+type OmittedProjectFields<T extends ListOptions | undefined> =
+  | (T extends {includeMembers: false} ? 'members' : never)
+  | (T extends {includeFeatures: false} ? 'features' : never)
+
 /** @internal */
 export class ObservableProjectsClient {
   #client: ObservableSanityClient
@@ -18,37 +29,31 @@ export class ObservableProjectsClient {
    *
    * @param options - Options for the list request
    *   - `includeMembers` - Whether to include members in the response (default: true)
+   *   - `includeFeatures` - Whether to include features in the response (default: true)
    *   - `organizationId` - ID of the organization to fetch projects for
-   *   - `onlyExplicitMembership` - Only include projects where the user has explicit membership (default: false)
+   *   - `onlyExplicitMembership` - Whether to include only projects with explicit membership (default: false)
    */
-  list(options?: {
-    includeMembers?: true
-    organizationId?: string
-    onlyExplicitMembership?: boolean
-  }): Observable<SanityProject[]>
-  list(options?: {
-    includeMembers?: false
-    organizationId?: string
-    onlyExplicitMembership?: boolean
-  }): Observable<Omit<SanityProject, 'members'>[]>
-  list(options?: {
-    includeMembers?: boolean
-    organizationId?: string
-    onlyExplicitMembership?: boolean
-  }): Observable<SanityProject[] | Omit<SanityProject, 'members'>[]> {
+  list<T extends ListOptions>(
+    options?: T,
+  ): Observable<Omit<SanityProject, OmittedProjectFields<T>>[]> {
     const query: Record<string, string> = {}
     const uri = '/projects'
     if (options?.includeMembers === false) {
       query.includeMembers = 'false'
     }
+    if (options?.includeFeatures === false) {
+      query.includeFeatures = 'false'
+    }
     if (options?.organizationId) {
       query.organizationId = options.organizationId
     }
-    if (options?.onlyExplicitMembership === true) {
+    if (options?.onlyExplicitMembership) {
       query.onlyExplicitMembership = 'true'
     }
 
-    return _request<SanityProject[]>(this.#client, this.#httpRequest, {uri, query})
+    return _request<SanityProject[]>(this.#client, this.#httpRequest, {uri, query}) as Observable<
+      Omit<SanityProject, OmittedProjectFields<T>>[]
+    >
   }
 
   /**
@@ -75,36 +80,32 @@ export class ProjectsClient {
    *
    * @param options - Options for the list request
    *   - `includeMembers` - Whether to include members in the response (default: true)
+   *   - `includeFeatures` - Whether to include features in the response (default: true)
    *   - `organizationId` - ID of the organization to fetch projects for
-   *   - `onlyExplicitMembership` - Only include projects where the user has explicit membership (default: false)
+   *   - `onlyExplicitMembership` - Whether to include only projects with explicit membership (default: false)
    */
-  list(options?: {
-    includeMembers?: true
-    organizationId?: string
-    onlyExplicitMembership?: boolean
-  }): Promise<SanityProject[]>
-  list(options?: {
-    includeMembers?: false
-    organizationId?: string
-    onlyExplicitMembership?: boolean
-  }): Promise<Omit<SanityProject, 'members'>[]>
-  list(options?: {
-    includeMembers?: boolean
-    organizationId?: string
-    onlyExplicitMembership?: boolean
-  }): Promise<SanityProject[] | Omit<SanityProject, 'members'>[]> {
+  list<T extends ListOptions>(
+    options?: T,
+  ): Promise<Omit<SanityProject, OmittedProjectFields<T>>[]> {
     const query: Record<string, string> = {}
     const uri = '/projects'
     if (options?.includeMembers === false) {
       query.includeMembers = 'false'
     }
+    if (options?.includeFeatures === false) {
+      query.includeFeatures = 'false'
+    }
     if (options?.organizationId) {
       query.organizationId = options.organizationId
     }
-    if (options?.onlyExplicitMembership === true) {
+    if (options?.onlyExplicitMembership) {
       query.onlyExplicitMembership = 'true'
     }
-    return lastValueFrom(_request<SanityProject[]>(this.#client, this.#httpRequest, {uri, query}))
+    return lastValueFrom(
+      _request<SanityProject[]>(this.#client, this.#httpRequest, {uri, query}) as Observable<
+        Omit<SanityProject, OmittedProjectFields<T>>[]
+      >,
+    )
   }
 
   /**

package/src/types.ts

@@ -2,7 +2,9 @@
 /* eslint-disable @typescript-eslint/no-empty-object-type */
 
 import type {Requester} from 'get-it'
+import type {Observable} from 'rxjs'
 
+import type {SanityClient} from './SanityClient'
 import type {InitializedStegaConfig, StegaConfig} from './stega/types'
 
 /**
@@ -203,6 +205,33 @@ export interface ClientConfig {
    * Lineage token for recursion control
    */
   lineage?: string
+
+  /**
+   * A custom request handler that intercepts all HTTP requests made by the client.
+   *
+   * Useful for logging, adding custom headers, refreshing auth tokens, rate limiting, etc.
+   *
+   * When using `withConfig()`, the new handler **replaces** the previous one (it does not
+   * wrap it). To compose handlers, you can chain them manually:
+   *
+   * ```ts
+   * const parent = createClient({...config, _requestHandler: handlerA})
+   * const child = parent.withConfig({
+   *   _requestHandler: (req, defaultRequester) =>
+   *     handlerB(req, (opts) => handlerA(opts, defaultRequester)),
+   * })
+   * ```
+   *
+   * Setting `_requestHandler` to `undefined` via `withConfig()` removes the handler.
+   *
+   * Note: This only applies to HTTP requests. Real-time listener connections
+   * (`client.listen()`) use EventSource and are not intercepted by this handler.
+   *
+   * @internal
+   * @deprecated Don't use outside of Sanity internals
+   * @see {@link RequestHandler}
+   */
+  _requestHandler?: RequestHandler
 }
 
 /** @public */
@@ -412,6 +441,38 @@ export type HttpRequest = {
   (options: RequestOptions, requester: Requester): ReturnType<Requester>
 }
 
+/**
+ * A function that intercepts HTTP requests made by the client.
+ *
+ * Receives the resolved request options, a `defaultRequester` function that
+ * executes the request through the normal pipeline, and a `client` instance
+ * without a `_requestHandler` (to avoid recursive interception).
+ *
+ * The consumer can:
+ * - Modify request options before calling `defaultRequester`
+ * - Transform the response stream (e.g. via `pipe`)
+ * - Skip `defaultRequester` entirely and return a custom Observable
+ * - Use `client` to make additional requests (e.g. refresh an auth token on 401)
+ *
+ * When set via `withConfig()`, the new handler **replaces** (not wraps) the previous one.
+ *
+ * Note: This only applies to HTTP requests. Real-time listener connections
+ * (`client.listen()`) use EventSource and are not intercepted by this handler.
+ *
+ * @param request - The resolved request options including `url`
+ * @param defaultRequester - Executes the request through the normal pipeline
+ * @param client - A client instance with the same configuration but without a `_requestHandler`,
+ *   useful for making side requests (e.g. token refresh) without triggering the handler recursively
+ *
+ * @internal
+ * @deprecated Don't use outside of Sanity internals
+ */
+export type RequestHandler = (
+  request: RequestOptions & {url: string},
+  defaultRequester: (options: RequestOptions & {url: string}) => Observable<HttpRequestEvent>,
+  client: SanityClient,
+) => Observable<HttpRequestEvent>
+
 /** @internal */
 export interface RequestObservableOptions extends Omit<RequestOptions, 'url'> {
   url?: string
@@ -529,6 +590,7 @@ export interface SanityProject {
   pendingInvites?: number
   maxRetentionDays?: number
   members: SanityProjectMember[]
+  features: string[]
   metadata: {
     cliInitializedAt?: string
     color?: string