@sanity/client 6.24.3 → 6.24.4

package/src/data/reconnectOnConnectionFailure.ts

@@ -0,0 +1,30 @@
+import {
+  catchError,
+  concat,
+  mergeMap,
+  Observable,
+  of,
+  type OperatorFunction,
+  throwError,
+  timer,
+} from 'rxjs'
+
+import {ConnectionFailedError} from './eventsource'
+
+/**
+ * Note: connection failure is not the same as network disconnect which may happen more frequent.
+ * The EventSource instance will automatically reconnect in case of a network disconnect, however,
+ * in some rare cases a ConnectionFailed Error will be thrown and this operator explicitly retries these
+ */
+export function reconnectOnConnectionFailure<T>(): OperatorFunction<T, T | {type: 'reconnect'}> {
+  return function (source: Observable<T>) {
+    return source.pipe(
+      catchError((err, caught) => {
+        if (err instanceof ConnectionFailedError) {
+          return concat(of({type: 'reconnect' as const}), timer(1000).pipe(mergeMap(() => caught)))
+        }
+        return throwError(() => err)
+      }),
+    )
+  }
+}

package/src/data/transaction.ts

@@ -7,6 +7,7 @@ import type {
   IdentifiedSanityDocumentStub,
   MultipleMutationResult,
   Mutation,
+  MutationSelection,
   PatchOperations,
   SanityDocument,
   SanityDocumentStub,
@@ -213,6 +214,13 @@ export class Transaction extends BaseTransaction {
    * @param patchOps - Operations to perform, or a builder function
    */
   patch(documentId: string, patchOps?: PatchBuilder | PatchOperations): this
+  /**
+   * Performs a patch on the given selection. Can either be a builder function or an object of patch operations.
+   *
+   * @param selection - An object with `query` and optional `params`, defining which document(s) to patch
+   * @param patchOps - Operations to perform, or a builder function
+   */
+  patch(patch: MutationSelection, patchOps?: PatchBuilder | PatchOperations): this
   /**
    * Adds the given patch instance to the transaction.
    * The operation is added to the current transaction, ready to be commited by `commit()`
@@ -220,9 +228,15 @@ export class Transaction extends BaseTransaction {
    * @param patch - Patch to execute
    */
   patch(patch: Patch): this
-  patch(patchOrDocumentId: Patch | string, patchOps?: PatchBuilder | PatchOperations): this {
+  patch(
+    patchOrDocumentId: Patch | MutationSelection | string,
+    patchOps?: PatchBuilder | PatchOperations,
+  ): this {
     const isBuilder = typeof patchOps === 'function'
     const isPatch = typeof patchOrDocumentId !== 'string' && patchOrDocumentId instanceof Patch
+    const isMutationSelection =
+      typeof patchOrDocumentId === 'object' &&
+      ('query' in patchOrDocumentId || 'id' in patchOrDocumentId)
 
     // transaction.patch(client.patch('documentId').inc({visits: 1}))
     if (isPatch) {
@@ -239,6 +253,17 @@ export class Transaction extends BaseTransaction {
       return this._add({patch: patch.serialize()})
     }
 
+    /**
+     * transaction.patch(
+     *   {query: "*[_type == 'person' && points >= $threshold]", params: { threshold: 100 }},
+     *   {dec: { points: 100 }, inc: { bonuses: 1 }}
+     * )
+     */
+    if (isMutationSelection) {
+      const patch = new Patch(patchOrDocumentId, patchOps || {}, this.#client)
+      return this._add({patch: patch.serialize()})
+    }
+
     return this._add({patch: {id: patchOrDocumentId, ...patchOps}})
   }
 }

package/src/defineCreateClient.ts

@@ -4,6 +4,17 @@ import {defineHttpRequest} from './http/request'
 import type {Any, ClientConfig, HttpRequest} from './types'
 
 export {validateApiPerspective} from './config'
+export {
+  ChannelError,
+  connectEventSource,
+  ConnectionFailedError,
+  DisconnectError,
+  type EventSourceEvent,
+  type EventSourceInstance,
+  MessageError,
+  MessageParseError,
+  type ServerSentEvent,
+} from './data/eventsource'
 export * from './data/patch'
 export * from './data/transaction'
 export {ClientError, CorsOriginError, ServerError} from './http/errors'

package/src/types.ts

@@ -854,6 +854,15 @@ export type ReconnectEvent = {
   type: 'reconnect'
 }
 
+/**
+ * The listener connection has been established
+ * note: it's usually a better option to use the 'welcome' event
+ * @public
+ */
+export type OpenEvent = {
+  type: 'open'
+}
+
 /**
  * The listener has been established, and will start receiving events.
  * Note that this is also emitted upon _reconnection_.
@@ -872,6 +881,7 @@ export type ListenEvent<R extends Record<string, Any>> =
   | DisconnectEvent
   | ReconnectEvent
   | WelcomeEvent
+  | OpenEvent
 
 /** @public */
 export type ListenEventName =