@sanity/client 7.6.0 → 7.8.0

package/dist/stega.d.ts

@@ -692,6 +692,30 @@ export declare interface ClientConfig {
    */
   headers?: Record<string, string>
   ignoreBrowserTokenWarning?: boolean
+  /**
+   * Ignore specific warning messages from the client.
+   *
+   * @remarks
+   * - String values perform substring matching (not exact matching) against warning messages
+   * - RegExp values are tested against the full warning message
+   * - Array values allow multiple patterns to be specified
+   *
+   * @example
+   * ```typescript
+   * // Ignore warnings containing "experimental"
+   * ignoreWarnings: 'experimental'
+   *
+   * // Ignore multiple warning types
+   * ignoreWarnings: ['experimental', 'deprecated']
+   *
+   * // Use regex for exact matching
+   * ignoreWarnings: /^This is an experimental API version$/
+   *
+   * // Mix strings and regex patterns
+   * ignoreWarnings: ['rate limit', /^deprecated/i]
+   * ```
+   */
+  ignoreWarnings?: string | RegExp | Array<string | RegExp>
   withCredentials?: boolean
   allowReconfigure?: boolean
   timeout?: number
@@ -1080,16 +1104,29 @@ export declare interface CreateReleaseAction {
 }
 
 /**
- * Creates a new version of an existing document, attached to the release as given
- * by `document._id`
+ * Creates a new version of an existing document.
+ *
+ * If the `document` is provided, the version is created from the document
+ * attached to the release as given by `document._id`
+ *
+ * If the `baseId` and `versionId` are provided, the version is created from the base document
+ * and the version is attached to the release as given by `publishedId` and `versionId`
  *
  * @public
  */
-export declare interface CreateVersionAction {
+export declare type CreateVersionAction = {
   actionType: 'sanity.action.document.version.create'
   publishedId: string
-  document: IdentifiedSanityDocumentStub
-}
+} & (
+  | {
+      document: IdentifiedSanityDocumentStub
+    }
+  | {
+      baseId: string
+      versionId: string
+      ifBaseRevisionId?: string
+    }
+)
 
 /** @public */
 export declare interface CurrentSanityUser {
@@ -1385,6 +1422,26 @@ export declare type EventSourceEvent<Name extends string> = ServerSentEvent<Name
  */
 export declare type EventSourceInstance = InstanceType<typeof globalThis.EventSource>
 
+/**
+ * A string constant containing the experimental API version warning message.
+ * Use this with the `ignoreWarnings` option to suppress warnings when using experimental API versions.
+ *
+ * @example
+ * ```typescript
+ * import { createClient, EXPERIMENTAL_API_WARNING } from '@sanity/client'
+ *
+ * const client = createClient({
+ *   projectId: 'your-project-id',
+ *   dataset: 'production',
+ *   apiVersion: 'vX', // experimental version
+ *   ignoreWarnings: EXPERIMENTAL_API_WARNING
+ * })
+ * ```
+ *
+ * @public
+ */
+export declare const EXPERIMENTAL_API_WARNING = 'This is an experimental API version'
+
 /**
  *
  *
@@ -1849,6 +1906,25 @@ export declare interface GroqAgentActionParam {
   params?: Record<string, string>
 }
 
+/**
+ * Shared properties for HTTP errors (eg both ClientError and ServerError)
+ * Use `isHttpError` for type narrowing and accessing response properties.
+ *
+ * @public
+ */
+export declare interface HttpError {
+  statusCode: number
+  message: string
+  response: {
+    body: unknown
+    url: string
+    method: string
+    headers: Record<string, string>
+    statusCode: number
+    statusMessage: string | null
+  }
+}
+
 /** @public */
 export declare type HttpRequest = {
   (options: RequestOptions, requester: Requester): ReturnType<Requester>
@@ -1968,6 +2044,15 @@ export declare type InsertPatch =
       items: Any[]
     }
 
+/**
+ * Checks if the provided error is an HTTP error.
+ *
+ * @param error - The error to check.
+ * @returns `true` if the error is an HTTP error, `false` otherwise.
+ * @public
+ */
+export declare function isHttpError(error: unknown): error is HttpError
+
 /** @internal */
 export declare function isQueryParseError(error: object): error is QueryParseError
 
@@ -3224,6 +3309,15 @@ export declare class ObservableSanityClient {
     },
     options?: BaseActionOptions,
   ): Observable<SingleActionResult | MultipleActionResult>
+  createVersion(
+    args: {
+      baseId: string
+      releaseId: string
+      publishedId: string
+      ifBaseRevisionId?: string
+    },
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult | MultipleActionResult>
   /**
    * Deletes a document with the given document ID.
    * Returns an observable that resolves to the deleted document.
@@ -4951,7 +5045,8 @@ export declare class SanityClient {
    * Creates a new version of a published document.
    *
    * @remarks
-   * * Requires a document with a `_type` property.
+   * * The preferred approach is to use `baseId` to refer to the existing published document, but it is also possible to provide a complete `document` instead.
+   * * If `document` is provided, it must have a `_type` property.
    * * Creating a version with no `releaseId` will create a new draft version of the published document.
    * * If the `document._id` is defined, it should be a draft or release version ID that matches the version ID generated from `publishedId` and `releaseId`.
    * * If the `document._id` is not defined, it will be generated from `publishedId` and `releaseId`.
@@ -4960,17 +5055,18 @@ export declare class SanityClient {
    * @category Versions
    *
    * @param params - Version action parameters:
+   *   - `baseId` - The ID of the published document from which to create a new version from.
+   *   - `ifBaseRevisionId` - If `baseId` is provided, this ensures the `baseId`'s revision Id is as expected before creating the new version from it.
    *   - `document` - The document to create as a new version (must include `_type`).
    *   - `publishedId` - The ID of the published document being versioned.
    *   - `releaseId` - The ID of the release to create the version for.
    * @param options - Additional action options.
    * @returns A promise that resolves to the `transactionId`.
    *
-   * @example Creating a new version of a published document with a generated version ID
+   * @example Creating a new version of a published document
    * ```ts
    * const transactionId = await client.createVersion({
-   *   // The document does not need to include an `_id` property since it will be generated from `publishedId` and `releaseId`
-   *   document: {_type: 'myDocument', title: 'My Document'},
+   *   baseId: 'myDocument',
    *   publishedId: 'myDocument',
    *   releaseId: 'myRelease',
    * })
@@ -4983,25 +5079,11 @@ export declare class SanityClient {
    * // }
    * ```
    *
-   * @example Creating a new version of a published document with a specified version ID
-   * ```ts
-   * const transactionId = await client.createVersion({
-   *   document: {_type: 'myDocument', _id: 'versions.myRelease.myDocument', title: 'My Document'},
-   *   // `publishedId` and `releaseId` are not required since `document._id` has been specified
-   * })
-   *
-   * // The following document will be created:
-   * // {
-   * //   _id: 'versions.myRelease.myDocument',
-   * //   _type: 'myDocument',
-   * //   title: 'My Document',
-   * // }
-   * ```
    *
    * @example Creating a new draft version of a published document
    * ```ts
    * const transactionId = await client.createVersion({
-   *   document: {_type: 'myDocument', title: 'My Document'},
+   *   baseId: 'myDocument',
    *   publishedId: 'myDocument',
    * })
    *
@@ -5029,6 +5111,15 @@ export declare class SanityClient {
     },
     options?: BaseActionOptions,
   ): Promise<SingleActionResult | MultipleActionResult>
+  createVersion(
+    args: {
+      publishedId: string
+      baseId: string
+      releaseId: string
+      ifBaseRevisionId?: string
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult | MultipleActionResult>
   /**
    * Deletes a document with the given document ID.
    * Returns a promise that resolves to the deleted document.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/client",
-  "version": "7.6.0",
+  "version": "7.8.0",
   "description": "Client for retrieving, creating and patching data from Sanity.io",
   "keywords": [
     "sanity",

package/src/SanityClient.ts

@@ -543,18 +543,43 @@ export class ObservableSanityClient {
     },
     options?: BaseActionOptions,
   ): Observable<SingleActionResult | MultipleActionResult>
+  createVersion(
+    args: {
+      baseId: string
+      releaseId: string
+      publishedId: string
+      ifBaseRevisionId?: string
+    },
+    options?: BaseActionOptions,
+  ): Observable<SingleActionResult | MultipleActionResult>
   createVersion<R extends Record<string, Any>>(
     {
       document,
       publishedId,
       releaseId,
+      baseId,
+      ifBaseRevisionId,
     }: {
-      document: SanityDocumentStub<R> | IdentifiedSanityDocumentStub<R>
+      document?: SanityDocumentStub<R> | IdentifiedSanityDocumentStub<R>
       publishedId?: string
       releaseId?: string
+      baseId?: string
+      ifBaseRevisionId?: string
     },
     options?: BaseActionOptions,
   ): Observable<SingleActionResult | MultipleActionResult> {
+    if (!document) {
+      return dataMethods._createVersionFromBase(
+        this,
+        this.#httpRequest,
+        publishedId,
+        baseId,
+        releaseId,
+        ifBaseRevisionId,
+        options,
+      )
+    }
+
     const documentVersionId = deriveDocumentVersionId('createVersion', {
       document,
       publishedId,
@@ -1446,7 +1471,8 @@ export class SanityClient {
    * Creates a new version of a published document.
    *
    * @remarks
-   * * Requires a document with a `_type` property.
+   * * The preferred approach is to use `baseId` to refer to the existing published document, but it is also possible to provide a complete `document` instead.
+   * * If `document` is provided, it must have a `_type` property.
    * * Creating a version with no `releaseId` will create a new draft version of the published document.
    * * If the `document._id` is defined, it should be a draft or release version ID that matches the version ID generated from `publishedId` and `releaseId`.
    * * If the `document._id` is not defined, it will be generated from `publishedId` and `releaseId`.
@@ -1455,17 +1481,18 @@ export class SanityClient {
    * @category Versions
    *
    * @param params - Version action parameters:
+   *   - `baseId` - The ID of the published document from which to create a new version from.
+   *   - `ifBaseRevisionId` - If `baseId` is provided, this ensures the `baseId`'s revision Id is as expected before creating the new version from it.
    *   - `document` - The document to create as a new version (must include `_type`).
    *   - `publishedId` - The ID of the published document being versioned.
    *   - `releaseId` - The ID of the release to create the version for.
    * @param options - Additional action options.
    * @returns A promise that resolves to the `transactionId`.
    *
-   * @example Creating a new version of a published document with a generated version ID
+   * @example Creating a new version of a published document
    * ```ts
    * const transactionId = await client.createVersion({
-   *   // The document does not need to include an `_id` property since it will be generated from `publishedId` and `releaseId`
-   *   document: {_type: 'myDocument', title: 'My Document'},
+   *   baseId: 'myDocument',
    *   publishedId: 'myDocument',
    *   releaseId: 'myRelease',
    * })
@@ -1478,25 +1505,11 @@ export class SanityClient {
    * // }
    * ```
    *
-   * @example Creating a new version of a published document with a specified version ID
-   * ```ts
-   * const transactionId = await client.createVersion({
-   *   document: {_type: 'myDocument', _id: 'versions.myRelease.myDocument', title: 'My Document'},
-   *   // `publishedId` and `releaseId` are not required since `document._id` has been specified
-   * })
-   *
-   * // The following document will be created:
-   * // {
-   * //   _id: 'versions.myRelease.myDocument',
-   * //   _type: 'myDocument',
-   * //   title: 'My Document',
-   * // }
-   * ```
    *
    * @example Creating a new draft version of a published document
    * ```ts
    * const transactionId = await client.createVersion({
-   *   document: {_type: 'myDocument', title: 'My Document'},
+   *   baseId: 'myDocument',
    *   publishedId: 'myDocument',
    * })
    *
@@ -1524,18 +1537,45 @@ export class SanityClient {
     },
     options?: BaseActionOptions,
   ): Promise<SingleActionResult | MultipleActionResult>
+  createVersion(
+    args: {
+      publishedId: string
+      baseId: string
+      releaseId: string
+      ifBaseRevisionId?: string
+    },
+    options?: BaseActionOptions,
+  ): Promise<SingleActionResult | MultipleActionResult>
   createVersion<R extends Record<string, Any>>(
     {
       document,
       publishedId,
       releaseId,
+      baseId,
+      ifBaseRevisionId,
     }: {
-      document: SanityDocumentStub<R> | IdentifiedSanityDocumentStub<R>
+      document?: SanityDocumentStub<R> | IdentifiedSanityDocumentStub<R>
       publishedId?: string
       releaseId?: string
+      baseId?: string
+      ifBaseRevisionId?: string
     },
     options?: BaseActionOptions,
   ): Promise<SingleActionResult | MultipleActionResult> {
+    if (!document) {
+      return firstValueFrom(
+        dataMethods._createVersionFromBase(
+          this,
+          this.#httpRequest,
+          publishedId,
+          baseId,
+          releaseId,
+          ifBaseRevisionId,
+          options,
+        ),
+      )
+    }
+
     const documentVersionId = deriveDocumentVersionId('createVersion', {
       document,
       publishedId,

package/src/data/dataMethods.ts

@@ -1,4 +1,4 @@
-import {getVersionFromId, getVersionId, isDraftId} from '@sanity/client/csm'
+import {getDraftId, getVersionFromId, getVersionId, isDraftId} from '@sanity/client/csm'
 import {from, type MonoTypeOperatorFunction, Observable} from 'rxjs'
 import {combineLatestWith, filter, map} from 'rxjs/operators'
 
@@ -39,7 +39,11 @@ import type {
 import {getSelection} from '../util/getSelection'
 import * as validate from '../validators'
 import * as validators from '../validators'
-import {printCdnPreviewDraftsWarning, printPreviewDraftsDeprecationWarning} from '../warnings'
+import {
+  printCdnPreviewDraftsWarning,
+  printCreateVersionWithBaseIdWarning,
+  printPreviewDraftsDeprecationWarning,
+} from '../warnings'
 import {encodeQueryString} from './encodeQueryString'
 import {ObservablePatch, Patch} from './patch'
 import {ObservableTransaction, Transaction} from './transaction'
@@ -266,6 +270,7 @@ export function _createVersion<R extends Record<string, Any>>(
 ): Observable<SingleActionResult> {
   validators.requireDocumentId('createVersion', doc)
   validators.requireDocumentType('createVersion', doc)
+  printCreateVersionWithBaseIdWarning()
 
   const createVersionAction: CreateVersionAction = {
     actionType: 'sanity.action.document.version.create',
@@ -276,6 +281,38 @@ export function _createVersion<R extends Record<string, Any>>(
   return _action(client, httpRequest, createVersionAction, options)
 }
 
+/** @internal */
+export function _createVersionFromBase(
+  client: ObservableSanityClient | SanityClient,
+  httpRequest: HttpRequest,
+  publishedId?: string,
+  baseId?: string,
+  releaseId?: string,
+  ifBaseRevisionId?: string,
+  options?: BaseActionOptions,
+): Observable<SingleActionResult> {
+  if (!baseId) {
+    throw new Error('`createVersion()` requires `baseId` when no `document` is provided')
+  }
+
+  if (!publishedId) {
+    throw new Error('`createVersion()` requires `publishedId` when `baseId` is provided')
+  }
+
+  validators.validateDocumentId('createVersion', baseId)
+  validators.validateDocumentId('createVersion', publishedId)
+
+  const createVersionAction: CreateVersionAction = {
+    actionType: 'sanity.action.document.version.create',
+    publishedId,
+    baseId,
+    versionId: releaseId ? getVersionId(publishedId, releaseId) : getDraftId(publishedId),
+    ifBaseRevisionId,
+  }
+
+  return _action(client, httpRequest, createVersionAction, options)
+}
+
 /** @internal */
 export function _delete<R extends Record<string, Any>>(
   client: Client,

package/src/defineCreateClient.ts

@@ -21,6 +21,8 @@ export {
   ClientError,
   CorsOriginError,
   formatQueryParseError,
+  type HttpError,
+  isHttpError,
   isQueryParseError,
   ServerError,
 } from './http/errors'
@@ -45,7 +47,9 @@ export default function defineCreateClientExports<
   const defaultRequester = defineHttpRequest(envMiddleware)
 
   const createClient = (config: ClientConfigType) => {
-    const clientRequester = defineHttpRequest(envMiddleware)
+    const clientRequester = defineHttpRequest(envMiddleware, {
+      ignoreWarnings: config.ignoreWarnings,
+    })
     return new ClassConstructor(
       (options, requester) =>
         (requester || clientRequester)({

package/src/http/errors.ts

@@ -6,6 +6,59 @@ import {isRecord} from '../util/isRecord'
 
 const MAX_ITEMS_IN_ERROR_MESSAGE = 5
 
+/**
+ * Shared properties for HTTP errors (eg both ClientError and ServerError)
+ * Use `isHttpError` for type narrowing and accessing response properties.
+ *
+ * @public
+ */
+export interface HttpError {
+  statusCode: number
+  message: string
+  response: {
+    body: unknown
+    url: string
+    method: string
+    headers: Record<string, string>
+    statusCode: number
+    statusMessage: string | null
+  }
+}
+
+/**
+ * Checks if the provided error is an HTTP error.
+ *
+ * @param error - The error to check.
+ * @returns `true` if the error is an HTTP error, `false` otherwise.
+ * @public
+ */
+export function isHttpError(error: unknown): error is HttpError {
+  if (!isRecord(error)) {
+    return false
+  }
+
+  const response = error.response
+  if (
+    typeof error.statusCode !== 'number' ||
+    typeof error.message !== 'string' ||
+    !isRecord(response)
+  ) {
+    return false
+  }
+
+  if (
+    typeof response.body === 'undefined' ||
+    typeof response.url !== 'string' ||
+    typeof response.method !== 'string' ||
+    typeof response.headers !== 'object' ||
+    typeof response.statusCode !== 'number'
+  ) {
+    return false
+  }
+
+  return true
+}
+
 /** @public */
 export class ClientError extends Error {
   response: ErrorProps['response']

package/src/http/request.ts

@@ -17,14 +17,39 @@ const httpError = {
   },
 }
 
-function printWarnings() {
+function printWarnings(config: {ignoreWarnings?: string | RegExp | Array<string | RegExp>} = {}) {
   const seen: Record<string, boolean> = {}
+
+  // Helper function to check if a warning should be ignored
+  const shouldIgnoreWarning = (message: string): boolean => {
+    if (config.ignoreWarnings === undefined) return false
+
+    const patterns = Array.isArray(config.ignoreWarnings)
+      ? config.ignoreWarnings
+      : [config.ignoreWarnings]
+
+    return patterns.some((pattern) => {
+      if (typeof pattern === 'string') {
+        return message.includes(pattern)
+      } else if (pattern instanceof RegExp) {
+        return pattern.test(message)
+      }
+      return false
+    })
+  }
+
   return {
     onResponse: (res: Any) => {
       const warn = res.headers['x-sanity-warning']
       const warnings = Array.isArray(warn) ? warn : [warn]
       for (const msg of warnings) {
         if (!msg || seen[msg]) continue
+
+        // Skip warnings that match ignore patterns
+        if (shouldIgnoreWarning(msg)) {
+          continue
+        }
+
         seen[msg] = true
         console.warn(msg) // eslint-disable-line no-console
       }
@@ -34,11 +59,14 @@ function printWarnings() {
 }
 
 /** @internal */
-export function defineHttpRequest(envMiddleware: Middlewares): Requester {
+export function defineHttpRequest(
+  envMiddleware: Middlewares,
+  config: {ignoreWarnings?: string | RegExp | Array<string | RegExp>} = {},
+): Requester {
   return getIt([
     retry({shouldRetry}),
     ...envMiddleware,
-    printWarnings(),
+    printWarnings(config),
     jsonRequest(),
     jsonResponse(),
     progress(),

package/src/types.ts

@@ -111,6 +111,30 @@ export interface ClientConfig {
   headers?: Record<string, string>
 
   ignoreBrowserTokenWarning?: boolean
+  /**
+   * Ignore specific warning messages from the client.
+   *
+   * @remarks
+   * - String values perform substring matching (not exact matching) against warning messages
+   * - RegExp values are tested against the full warning message
+   * - Array values allow multiple patterns to be specified
+   *
+   * @example
+   * ```typescript
+   * // Ignore warnings containing "experimental"
+   * ignoreWarnings: 'experimental'
+   *
+   * // Ignore multiple warning types
+   * ignoreWarnings: ['experimental', 'deprecated']
+   *
+   * // Use regex for exact matching
+   * ignoreWarnings: /^This is an experimental API version$/
+   *
+   * // Mix strings and regex patterns
+   * ignoreWarnings: ['rate limit', /^deprecated/i]
+   * ```
+   */
+  ignoreWarnings?: string | RegExp | Array<string | RegExp>
   withCredentials?: boolean
   allowReconfigure?: boolean
   timeout?: number
@@ -701,16 +725,29 @@ export interface DeleteReleaseAction {
 }
 
 /**
- * Creates a new version of an existing document, attached to the release as given
- * by `document._id`
+ * Creates a new version of an existing document.
+ *
+ * If the `document` is provided, the version is created from the document
+ * attached to the release as given by `document._id`
+ *
+ * If the `baseId` and `versionId` are provided, the version is created from the base document
+ * and the version is attached to the release as given by `publishedId` and `versionId`
  *
  * @public
  */
-export interface CreateVersionAction {
+export type CreateVersionAction = {
   actionType: 'sanity.action.document.version.create'
   publishedId: string
-  document: IdentifiedSanityDocumentStub
-}
+} & (
+  | {
+      document: IdentifiedSanityDocumentStub
+    }
+  | {
+      baseId: string
+      versionId: string
+      ifBaseRevisionId?: string
+    }
+)
 
 /**
  * Delete a version of a document.
@@ -1660,3 +1697,23 @@ export type {
   StudioBaseUrl,
   StudioUrl,
 } from './stega/types'
+
+/**
+ * A string constant containing the experimental API version warning message.
+ * Use this with the `ignoreWarnings` option to suppress warnings when using experimental API versions.
+ *
+ * @example
+ * ```typescript
+ * import { createClient, EXPERIMENTAL_API_WARNING } from '@sanity/client'
+ *
+ * const client = createClient({
+ *   projectId: 'your-project-id',
+ *   dataset: 'production',
+ *   apiVersion: 'vX', // experimental version
+ *   ignoreWarnings: EXPERIMENTAL_API_WARNING
+ * })
+ * ```
+ *
+ * @public
+ */
+export const EXPERIMENTAL_API_WARNING = 'This is an experimental API version'

package/src/warnings.ts

@@ -46,3 +46,7 @@ export const printNoApiVersionSpecifiedWarning = createWarningPrinter([
 export const printNoDefaultExport = createWarningPrinter([
   'The default export of @sanity/client has been deprecated. Use the named export `createClient` instead.',
 ])
+
+export const printCreateVersionWithBaseIdWarning = createWarningPrinter([
+  'You have called `createVersion()` with a defined `document`. The recommended approach is to provide a `baseId` and `releaseId` instead.',
+])