@sanity/client 7.5.0 → 7.7.0

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
@@ -1660,3 +1684,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/umd/sanityClient.js

@@ -2049,6 +2049,12 @@
     };
   }
   const MAX_ITEMS_IN_ERROR_MESSAGE = 5;
+  function isHttpError(error) {
+    if (!isRecord(error))
+      return false;
+    const response = error.response;
+    return !(typeof error.statusCode != "number" || typeof error.message != "string" || !isRecord(response) || typeof response.body > "u" || typeof response.url != "string" || typeof response.method != "string" || typeof response.headers != "object" || typeof response.statusCode != "number");
+  }
   class ClientError extends Error {
     response;
     statusCode = 400;
@@ -2149,22 +2155,22 @@ ${codeFrame(query, { start, end }, description)}${withTag}`;
       return res;
     }
   };
-  function printWarnings() {
-    const seen = {};
+  function printWarnings(config = {}) {
+    const seen = {}, shouldIgnoreWarning = (message) => config.ignoreWarnings === void 0 ? false : (Array.isArray(config.ignoreWarnings) ? config.ignoreWarnings : [config.ignoreWarnings]).some((pattern) => typeof pattern == "string" ? message.includes(pattern) : pattern instanceof RegExp ? pattern.test(message) : false);
     return {
       onResponse: (res) => {
         const warn = res.headers["x-sanity-warning"], warnings = Array.isArray(warn) ? warn : [warn];
         for (const msg of warnings)
-          !msg || seen[msg] || (seen[msg] = true, console.warn(msg));
+          !msg || seen[msg] || shouldIgnoreWarning(msg) || (seen[msg] = true, console.warn(msg));
         return res;
       }
     };
   }
-  function defineHttpRequest(envMiddleware2) {
+  function defineHttpRequest(envMiddleware2, config = {}) {
     return p$1([
       P({ shouldRetry }),
       ...envMiddleware2,
-      printWarnings(),
+      printWarnings(config),
       x(),
       E$1(),
       S$1(),
@@ -2254,7 +2260,7 @@ ${codeFrame(query, { start, end }, description)}${withTag}`;
   }, resourceGuard = (service, config) => {
     if (config["~experimental_resource"])
       throw new Error(`\`${service}\` does not support resource-based operations`);
-  };
+  }, EXPERIMENTAL_API_WARNING = "This is an experimental API version";
   function once(fn) {
     let didCall = false, returnValue;
     return (...args) => (didCall || (returnValue = fn(...args), didCall = true), returnValue);
@@ -4635,7 +4641,9 @@ ${selectionOpts}`);
   }
   function defineCreateClientExports(envMiddleware2, ClassConstructor) {
     return { requester: defineHttpRequest(envMiddleware2), createClient: (config) => {
-      const clientRequester = defineHttpRequest(envMiddleware2);
+      const clientRequester = defineHttpRequest(envMiddleware2, {
+        ignoreWarnings: config.ignoreWarnings
+      });
       return new ClassConstructor(
         (options, requester2) => (requester2 || clientRequester)({
           maxRedirects: 0,
@@ -6095,6 +6103,7 @@ ${selectionOpts}`);
   exports.ConnectionFailedError = ConnectionFailedError;
   exports.CorsOriginError = CorsOriginError;
   exports.DisconnectError = DisconnectError;
+  exports.EXPERIMENTAL_API_WARNING = EXPERIMENTAL_API_WARNING;
   exports.MessageError = MessageError;
   exports.MessageParseError = MessageParseError;
   exports.ObservablePatch = ObservablePatch;
@@ -6108,6 +6117,7 @@ ${selectionOpts}`);
   exports.createClient = createClient;
   exports.default = deprecatedCreateClient;
   exports.formatQueryParseError = formatQueryParseError;
+  exports.isHttpError = isHttpError;
   exports.isQueryParseError = isQueryParseError;
   exports.requester = requester;
   exports.unstable__adapter = c$2;