@sanity/client 5.0.0 → 5.1.0

package/README.md

@@ -846,6 +846,49 @@ The following options are available for mutations, and can be applied either as
 - `dryRun` (`true|false`) - default `false`. If true, the mutation will be a dry run - the response will be identical to the one returned had this property been omitted or false (including error responses) but no documents will be affected.
 - `autoGenerateArrayKeys` (`true|false`) - default `false`. If true, the mutation API will automatically add `_key` attributes to objects in arrays that is missing them. This makes array operations more robust by having a unique key within the array available for selections, which helps prevent race conditions in real-time, collaborative editing.
 
+### Aborting a request
+
+Requests can be aborted (or cancelled) in two ways:
+
+#### 1. Abort a request by passing an [AbortSignal] with the request options
+
+Sanity Client supports the [AbortController] API and supports receiving an abort signal that can be used to cancel the request. Here's an example that will abort the request if it takes more than 200ms to complete:
+
+```js
+const abortController = new AbortController()
+
+// note the lack of await here
+const request = getClient().fetch('*[_type == "movie"]', {}, {signal: abortController.signal})
+
+// this will abort the request after 200ms
+setTimeout(() => abortController.abort(), 200)
+
+try {
+  const response = await request
+  //…
+} catch (error) {
+  if (error.name === 'AbortError') {
+    console.log('Request was aborted')
+  } else {
+    // rethrow in case of other errors
+    throw error
+  }
+}
+```
+
+#### 2. Cancel a request by unsubscribing from the Observable
+
+When using the Observable API (e.g. `client.observable.fetch()`), you can cancel the request by simply `unsubscribe` from the returned observable:
+
+```js
+const subscription = client.observable.fetch('*[_type == "movie"]').subscribe((result) => {
+  /* do something with the result */
+})
+
+// this will cancel the request
+subscription.unsubscribe()
+```
+
 ### Get client configuration
 
 ```js
@@ -1234,3 +1277,5 @@ await client.request<void>({uri: '/auth/logout', method: 'POST'})
 [api-versioning]: http://sanity.io/docs/api-versioning
 [zod]: https://zod.dev/
 [groqd]: https://github.com/FormidableLabs/groqd#readme
+[AbortSignal]: https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal
+[AbortController]: https://developer.mozilla.org/en-US/docs/Web/API/AbortController

package/dist/index.browser.cjs

@@ -749,7 +749,8 @@ function _dataRequest(client, httpRequest, endpoint, body) {
     headers,
     token,
     tag,
-    canUseCdn: isQuery
+    canUseCdn: isQuery,
+    signal: options.signal
   };
   return _requestObservable(client, httpRequest, reqOptions).pipe(operators.filter(isResponse), operators.map(getBody), operators.map(res => {
     if (!isMutation) {
@@ -796,9 +797,10 @@ function _requestObservable(client, httpRequest, options) {
   const reqOptions = getRequestOptions(config, Object.assign({}, options, {
     url: _getUrl(client, uri, useCdn)
   }));
-  return new rxjs.Observable(subscriber =>
+  const request = new rxjs.Observable(subscriber =>
   // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- the typings thinks it's optional because it's not required to specify it when calling createClient, but it's always defined in practice since SanityClient provides a default
   httpRequest(reqOptions, config.requester).subscribe(subscriber));
+  return options.signal ? request.pipe(_withAbortSignal(options.signal)) : request;
 }
 function _request(client, httpRequest, options) {
   const observable = _requestObservable(client, httpRequest, options).pipe(operators.filter(event => event.type === "response"), operators.map(event => event.body));
@@ -820,6 +822,33 @@ function _getUrl(client, uri) {
   const base = canUseCdn ? cdnUrl : url;
   return "".concat(base, "/").concat(uri.replace(/^\//, ""));
 }
+function _withAbortSignal(signal) {
+  return input => {
+    return new rxjs.Observable(observer => {
+      const abort = () => observer.error(_createAbortError(signal));
+      if (signal && signal.aborted) {
+        abort();
+        return;
+      }
+      const subscription = input.subscribe(observer);
+      signal.addEventListener("abort", abort);
+      return () => {
+        signal.removeEventListener("abort", abort);
+        subscription.unsubscribe();
+      };
+    });
+  };
+}
+const isDomExceptionSupported = Boolean(globalThis.DOMException);
+function _createAbortError(signal) {
+  var _a, _b;
+  if (isDomExceptionSupported) {
+    return new DOMException((_a = signal == null ? void 0 : signal.reason) != null ? _a : "The operation was aborted.", "AbortError");
+  }
+  const error = new Error((_b = signal == null ? void 0 : signal.reason) != null ? _b : "The operation was aborted.");
+  error.name = "AbortError";
+  return error;
+}
 var __accessCheck$4 = (obj, member, msg) => {
   if (!member.has(obj)) throw TypeError("Cannot " + msg);
 };
@@ -1662,6 +1691,9 @@ const _SanityClient = class {
 let SanityClient = _SanityClient;
 _clientConfig2 = new WeakMap();
 _httpRequest2 = new WeakMap();
+function migrationNotice() {
+  throw new TypeError("The default export of @sanity/client has been deprecated. Use the named export `createClient` instead");
+}
 const httpRequest = defineHttpRequest(envMiddleware);
 const requester = httpRequest.defaultRequester;
 const createClient = config => new SanityClient(httpRequest, config);
@@ -1676,5 +1708,6 @@ exports.SanityClient = SanityClient;
 exports.ServerError = ServerError;
 exports.Transaction = Transaction;
 exports.createClient = createClient;
+exports.default = migrationNotice;
 exports.requester = requester;
 //# sourceMappingURL=index.browser.cjs.map