@sanity/sdk 3.0.0-rc.0 → 3.0.0-rc.2

package/src/client/clientStore.test.ts

@@ -1,6 +1,6 @@
 import {createClient, type SanityClient} from '@sanity/client'
 import {Subject} from 'rxjs'
-import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
+import {beforeEach, describe, expect, it, vi} from 'vitest'
 
 import {getAuthMethodState, getTokenState} from '../auth/authStore'
 import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
@@ -33,7 +33,10 @@ beforeEach(() => {
   vi.mocked(createClient).mockImplementation(
     (clientConfig) => ({config: () => clientConfig}) as SanityClient,
   )
-  instance = createSanityInstance()
+  instance = createSanityInstance({
+    projectId: 'test-project',
+    dataset: 'test-dataset',
+  })
 })
 
 afterEach(() => {
@@ -42,6 +45,43 @@ afterEach(() => {
 
 describe('clientStore', () => {
   describe('getClient', () => {
+    it('should create a client with default configuration', () => {
+      const client = getClient(instance, {apiVersion: '2024-11-12'})
+
+      const defaultConfiguration = {
+        useCdn: false,
+        ignoreBrowserTokenWarning: true,
+        allowReconfigure: false,
+        requestTagPrefix: 'sanity.sdk',
+        projectId: 'test-project',
+        dataset: 'test-dataset',
+        token: 'initial-token',
+      }
+
+      expect(vi.mocked(createClient)).toHaveBeenCalledWith({
+        ...defaultConfiguration,
+        apiVersion: '2024-11-12',
+      })
+      expect(client.config()).toEqual({
+        ...defaultConfiguration,
+        apiVersion: '2024-11-12',
+      })
+    })
+
+    it('should pass staging apiHost when __SANITY_STAGING__ is true and no explicit apiHost', () => {
+      vi.stubGlobal('__SANITY_STAGING__', true)
+
+      getClient(instance, {apiVersion: '2024-11-12'})
+
+      expect(vi.mocked(createClient)).toHaveBeenCalledWith(
+        expect.objectContaining({
+          apiHost: 'https://api.sanity.work',
+        }),
+      )
+
+      vi.unstubAllGlobals()
+    })
+
     it('should throw when using disallowed configuration keys', () => {
       expect(() =>
         getClient(instance, {
@@ -150,8 +190,8 @@ describe('clientStore', () => {
     })
   })
 
-  describe('source handling', () => {
-    it('should create client when source is provided', () => {
+  describe('resource handling', () => {
+    it('should create resource when media library resource is provided and be projectless', () => {
       const client = getClient(instance, {
         apiVersion: '2024-11-12',
         resource: {mediaLibraryId: 'media-lib-123'},
@@ -159,8 +199,8 @@ describe('clientStore', () => {
 
       expect(vi.mocked(createClient)).toHaveBeenCalledWith(
         expect.objectContaining({
-          'apiVersion': '2024-11-12',
-          '~experimental_resource': {type: 'media-library', id: 'media-lib-123'},
+          resource: {type: 'media-library', id: 'media-lib-123'},
+          apiVersion: '2024-11-12',
         }),
       )
       // Client should be projectless - no projectId/dataset in config
@@ -168,12 +208,12 @@ describe('clientStore', () => {
       expect(client.config()).not.toHaveProperty('dataset')
       expect(client.config()).toEqual(
         expect.objectContaining({
-          '~experimental_resource': {type: 'media-library', id: 'media-lib-123'},
+          resource: {type: 'media-library', id: 'media-lib-123'},
         }),
       )
     })
 
-    it('should create resource when canvas source is provided and be projectless', () => {
+    it('should create resource when canvas resource is provided and be projectless', () => {
       const client = getClient(instance, {
         apiVersion: '2024-11-12',
         resource: {canvasId: 'canvas-123'},
@@ -181,8 +221,8 @@ describe('clientStore', () => {
 
       expect(vi.mocked(createClient)).toHaveBeenCalledWith(
         expect.objectContaining({
-          '~experimental_resource': {type: 'canvas', id: 'canvas-123'},
-          'apiVersion': '2024-11-12',
+          resource: {type: 'canvas', id: 'canvas-123'},
+          apiVersion: '2024-11-12',
         }),
       )
       // Client should be projectless - no projectId/dataset in config
@@ -190,47 +230,32 @@ describe('clientStore', () => {
       expect(client.config()).not.toHaveProperty('dataset')
       expect(client.config()).toEqual(
         expect.objectContaining({
-          '~experimental_resource': {type: 'canvas', id: 'canvas-123'},
+          resource: {type: 'canvas', id: 'canvas-123'},
         }),
       )
     })
 
-    // skipped until we migrate to using source for project and dataset
-    it.skip('should create projectless client when source is provided, ignoring instance config', () => {
+    it('should transform dataset resource to project-based config for now', () => {
       const client = getClient(instance, {
         apiVersion: '2024-11-12',
         resource: {projectId: 'source-project', dataset: 'source-dataset'},
       })
 
-      // Client should be projectless - source takes precedence, instance config is ignored
-      expect(client.config()).not.toHaveProperty('projectId')
-      expect(client.config()).not.toHaveProperty('dataset')
-      expect(client.config()).toEqual(
+      expect(vi.mocked(createClient)).toHaveBeenCalledWith(
         expect.objectContaining({
-          '~experimental_resource': {type: 'dataset', id: 'source-project.source-dataset'},
+          projectId: 'source-project',
+          dataset: 'source-dataset',
         }),
       )
-    })
-
-    it('should warn when both source and explicit projectId/dataset are provided', () => {
-      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-      const client = getClient(instance, {
-        apiVersion: '2024-11-12',
-        resource: {mediaLibraryId: 'media-lib-123'},
-        projectId: 'explicit-project',
-        dataset: 'explicit-dataset',
-      })
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        'Both resource and explicit projectId/dataset are provided. The resource will be used and projectId/dataset will be ignored.',
+      expect(client.config()).toEqual(
+        expect.objectContaining({
+          projectId: 'source-project',
+          dataset: 'source-dataset',
+        }),
       )
-      // Client should still be projectless despite explicit projectId/dataset
-      expect(client.config()).not.toHaveProperty('projectId')
-      expect(client.config()).not.toHaveProperty('dataset')
-      consoleSpy.mockRestore()
     })
 
-    it('should create different clients for different sources', () => {
+    it('should create different clients for different resources', () => {
       const client1 = getClient(instance, {
         apiVersion: '2024-11-12',
         resource: {projectId: 'source-project', dataset: 'source-dataset'},
@@ -250,7 +275,7 @@ describe('clientStore', () => {
       expect(vi.mocked(createClient)).toHaveBeenCalledTimes(3)
     })
 
-    it('should reuse clients with identical source configurations', () => {
+    it('should reuse clients with identical resource configurations', () => {
       const client1 = getClient(instance, {
         apiVersion: '2024-11-12',
         resource: {projectId: 'source-project', dataset: 'source-dataset'},

package/src/client/clientStore.ts

@@ -1,10 +1,4 @@
-import {
-  type ClientConfig,
-  type ClientPerspective,
-  createClient,
-  type SanityClient,
-} from '@sanity/client'
-import {pick} from 'lodash-es'
+import {type ClientConfig, createClient, type SanityClient} from '@sanity/client'
 
 import {getAuthMethodState, getTokenState} from '../auth/authStore'
 import {
@@ -16,6 +10,8 @@ import {
 import {bindActionGlobally} from '../store/createActionBinder'
 import {createStateSourceAction} from '../store/createStateSourceAction'
 import {defineStore, type StoreContext} from '../store/defineStore'
+import {getStagingApiHost} from '../utils/getStagingApiHost'
+import {pickProperties} from '../utils/object'
 
 const DEFAULT_API_VERSION = '2024-11-12'
 const DEFAULT_REQUEST_TAG_PREFIX = 'sanity.sdk'
@@ -35,31 +31,30 @@ type AllowedClientConfigKey =
   | 'useProjectHostname'
 
 const allowedKeys = Object.keys({
-  'apiHost': null,
-  'useCdn': null,
-  'token': null,
-  'perspective': null,
-  'proxy': null,
-  'withCredentials': null,
-  'timeout': null,
-  'maxRetries': null,
-  'dataset': null,
-  'projectId': null,
-  'scope': null,
-  'apiVersion': null,
-  'requestTagPrefix': null,
-  'useProjectHostname': null,
-  '~experimental_resource': null,
-  'resource': null,
+  apiHost: null,
+  useCdn: null,
+  token: null,
+  perspective: null,
+  proxy: null,
+  withCredentials: null,
+  timeout: null,
+  maxRetries: null,
+  dataset: null,
+  projectId: null,
+  scope: null,
+  apiVersion: null,
+  requestTagPrefix: null,
+  useProjectHostname: null,
+  resource: null,
 } satisfies Record<keyof ClientOptions, null>) as (keyof ClientOptions)[]
 
-const DEFAULT_CLIENT_CONFIG = {
+const DEFAULT_CLIENT_CONFIG: ClientConfig = {
   apiVersion: DEFAULT_API_VERSION,
   useCdn: false,
   ignoreBrowserTokenWarning: true,
   allowReconfigure: false,
   requestTagPrefix: DEFAULT_REQUEST_TAG_PREFIX,
-} satisfies ClientConfig
+}
 
 /**
  * States tracked by the client store
@@ -71,11 +66,6 @@ export interface ClientStoreState {
   authMethod?: 'localstorage' | 'cookie'
 }
 
-interface ClientResource {
-  type: 'dataset' | 'media-library' | 'canvas'
-  id: string
-}
-
 /**
  * Options used when retrieving a client instance from the client store.
  *
@@ -92,34 +82,23 @@ interface ClientResource {
  *
  * @public
  */
-export interface ClientOptions extends Omit<
-  Pick<ClientConfig, AllowedClientConfigKey>,
-  'resource'
-> {
-  /**
-   * Narrows the inherited `perspective` to exclude stackable perspectives,
-   * which are not supported by the SDK.
-   */
-  'perspective'?: Exclude<ClientPerspective, readonly unknown[]>
+export interface ClientOptions extends Pick<ClientConfig, AllowedClientConfigKey> {
   /**
    * An optional flag to choose between the default client (typically project-level)
    * and the global client ('global'). When set to `'global'`, the global client
    * is used.
    */
-  'scope'?: 'default' | 'global'
+  scope?: 'default' | 'global'
   /**
    * A required string indicating the API version for the client.
    */
-  'apiVersion': string
-  /**
-   * @internal
-   */
-  '~experimental_resource'?: ClientConfig['~experimental_resource']
+  apiVersion: string
 
   /**
    * @internal
+   * The SDK resource to use for the client -- this will get transformed into a ClientConfig resource.
    */
-  'resource'?: DocumentResource
+  resource?: DocumentResource
 }
 
 const clientStore = defineStore<ClientStoreState>({
@@ -156,7 +135,13 @@ const listenToAuthMethod = ({instance, state}: StoreContext<ClientStoreState>) =
   })
 }
 
-const getClientConfigKey = (options: ClientOptions) => JSON.stringify(pick(options, ...allowedKeys))
+type ClientInstanceCacheKeyInput = ClientConfig &
+  Partial<Pick<ClientOptions, 'scope'>> & {
+    apiVersion: string
+  }
+
+const getClientConfigKey = (options: ClientInstanceCacheKeyInput) =>
+  JSON.stringify(pickProperties(options, allowedKeys))
 
 /**
  * Retrieves a Sanity client instance configured with the provided options.
@@ -193,10 +178,10 @@ export const getClient = bindActionGlobally(
 
     const tokenFromState = state.get().token
     const {clients, authMethod} = state.get()
+    let projectId = options.projectId ?? instance.config.projectId
+    let dataset = options.dataset ?? instance.config.dataset
 
-    let resource: ClientResource | undefined
-    let projectId: string | undefined = options.projectId
-    let dataset: string | undefined = options.dataset
+    let resource: ClientConfig['resource'] | undefined
 
     if (options.resource) {
       if (isMediaLibraryResource(options.resource)) {
@@ -204,43 +189,31 @@ export const getClient = bindActionGlobally(
       } else if (isCanvasResource(options.resource)) {
         resource = {type: 'canvas', id: options.resource.canvasId}
       } else if (isDatasetResource(options.resource)) {
+        // use project-based routes for datasets to avoid existing CORS and Studio auth cookie issues
         projectId = options.resource.projectId
         dataset = options.resource.dataset
       }
-      // temporarily excluding dataset resource as a resource for now. Many of the global API endpoints require vX api version.
-      // When ready, remove the above check and uncomment the below check.
-      // } else if (isDatasetResource(options.resource)) {
-      //   resource = {type: 'dataset', id: `${options.resource.projectId}.${options.resource.dataset}`}
     }
 
-    const apiHost = options.apiHost ?? instance.config.auth?.apiHost
+    const apiHost = options.apiHost ?? instance.config.auth?.apiHost ?? getStagingApiHost()
 
-    const effectiveOptions = {
+    const effectiveOptions: ClientConfig & {apiVersion: string} = {
       ...DEFAULT_CLIENT_CONFIG,
       ...((options.scope === 'global' || !projectId || resource) && {useProjectHostname: false}),
       token: authMethod === 'cookie' ? undefined : (tokenFromState ?? undefined),
       ...options,
       ...(projectId && {projectId}),
       ...(dataset && {dataset}),
+      ...(resource ? {resource} : {resource: undefined}),
       ...(apiHost && {apiHost}),
-      ...(resource && {'~experimental_resource': resource}),
-    } as ClientOptions
+    }
 
-    // When a MediaLibrary or Canvas resource is provided, don't use projectId/dataset - the client should be "projectless"
+    // When a resource is provided, don't use projectId/dataset - the client should be "projectless"
     // The client code itself will ignore the non-resource config, so we do this to prevent confusing the user.
     // (ref: https://github.com/sanity-io/client/blob/5c23f81f5ab93a53f5b22b39845c867988508d84/src/data/dataMethods.ts#L691)
-    // Note: DatasetResource is handled differently - it extracts projectId/dataset from the resource and uses those
-    if (options.resource) {
-      if (options.projectId || options.dataset) {
-        // eslint-disable-next-line no-console
-        console.warn(
-          'Both resource and explicit projectId/dataset are provided. The resource will be used and projectId/dataset will be ignored.',
-        )
-      }
-      if (resource) {
-        delete effectiveOptions.projectId
-        delete effectiveOptions.dataset
-      }
+    if (resource) {
+      delete effectiveOptions.projectId
+      delete effectiveOptions.dataset
     }
 
     if (effectiveOptions.token === null || typeof effectiveOptions.token === 'undefined') {
@@ -252,14 +225,11 @@ export const getClient = bindActionGlobally(
       delete effectiveOptions.withCredentials
     }
 
-    // Don't pass our DocumentResource to createClient - we've already derived projectId/dataset or ~experimental_resource
-    const {resource: _omitResource, ...clientConfig} = effectiveOptions
-
     const key = getClientConfigKey(effectiveOptions)
 
     if (clients[key]) return clients[key]
 
-    const client = createClient(clientConfig as ClientConfig)
+    const client = createClient(effectiveOptions)
     state.set('addClient', (prev) => ({clients: {...prev.clients, [key]: client}}))
 
     return client

package/src/client/liveEvents.test.ts

@@ -0,0 +1,151 @@
+import {
+  ConnectionFailedError,
+  CorsOriginError,
+  DisconnectError,
+  type LiveEvent,
+  type LiveEventMessage,
+  type SanityClient,
+} from '@sanity/client'
+import {of, Subject} from 'rxjs'
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
+
+import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
+import {type StateSource} from '../store/createStateSourceAction'
+import {getClientState} from './clientStore'
+import {LIVE_EVENTS_RETRY_DELAY, observeLiveEvents} from './liveEvents'
+
+vi.mock('./clientStore', () => ({getClientState: vi.fn()}))
+
+describe('observeLiveEvents', () => {
+  let instance: SanityInstance
+  let liveEventSubjects: Subject<LiveEvent>[]
+  let events: ReturnType<typeof vi.fn>
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    instance = createSanityInstance({projectId: 'test', dataset: 'test'})
+
+    liveEventSubjects = []
+    events = vi.fn().mockImplementation(() => {
+      const subject = new Subject<LiveEvent>()
+      liveEventSubjects.push(subject)
+      return subject
+    })
+
+    vi.mocked(getClientState).mockReturnValue({
+      observable: of({
+        config: vi.fn().mockReturnValue({token: 'token'}),
+        live: {events},
+      } as unknown as SanityClient),
+    } as StateSource<SanityClient>)
+  })
+
+  afterEach(() => {
+    instance.dispose()
+  })
+
+  it('emits only message events', () => {
+    const messages: LiveEventMessage[] = []
+    const subscription = observeLiveEvents(instance, {onCorsError: vi.fn()}).subscribe((message) =>
+      messages.push(message),
+    )
+
+    liveEventSubjects[0].next({type: 'welcome'} as LiveEvent)
+    liveEventSubjects[0].next({type: 'message', id: 'e1', tags: ['s1:a']} as LiveEvent)
+
+    expect(messages).toEqual([{type: 'message', id: 'e1', tags: ['s1:a']}])
+    subscription.unsubscribe()
+  })
+
+  it('reports CORS errors through onCorsError and completes without erroring', () => {
+    const onCorsError = vi.fn()
+    const error = vi.fn()
+    const complete = vi.fn()
+    observeLiveEvents(instance, {onCorsError}).subscribe({error, complete})
+
+    const corsError = new CorsOriginError({projectId: 'test'})
+    liveEventSubjects[0].error(corsError)
+
+    expect(onCorsError).toHaveBeenCalledWith(corsError)
+    expect(error).not.toHaveBeenCalled()
+    expect(complete).toHaveBeenCalled()
+  })
+
+  it('completes without retrying on DisconnectError', async () => {
+    vi.useFakeTimers()
+    try {
+      const error = vi.fn()
+      const complete = vi.fn()
+      observeLiveEvents(instance, {onCorsError: vi.fn()}).subscribe({error, complete})
+
+      liveEventSubjects[0].error(new DisconnectError('Server disconnected client'))
+      await vi.advanceTimersByTimeAsync(LIVE_EVENTS_RETRY_DELAY * 5)
+
+      expect(error).not.toHaveBeenCalled()
+      expect(complete).toHaveBeenCalled()
+      expect(events).toHaveBeenCalledTimes(1)
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  it('completes without retrying on a 4xx connection rejection', async () => {
+    vi.useFakeTimers()
+    try {
+      const error = vi.fn()
+      const complete = vi.fn()
+      observeLiveEvents(instance, {onCorsError: vi.fn()}).subscribe({error, complete})
+
+      // The server rejected the connection with a 401 (e.g. expired token) —
+      // it will keep rejecting, so retrying would reconnect once per second
+      // forever
+      liveEventSubjects[0].error(
+        new ConnectionFailedError('EventSource connection failed', {status: 401}),
+      )
+      await vi.advanceTimersByTimeAsync(LIVE_EVENTS_RETRY_DELAY * 5)
+
+      expect(error).not.toHaveBeenCalled()
+      expect(complete).toHaveBeenCalled()
+      expect(events).toHaveBeenCalledTimes(1)
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  it('retries a connection failure without a status (transient network failure)', async () => {
+    vi.useFakeTimers()
+    try {
+      const error = vi.fn()
+      const subscription = observeLiveEvents(instance, {onCorsError: vi.fn()}).subscribe({error})
+
+      // No status means the failure could be transient (native EventSource
+      // exposes no status) — reconnecting is correct here
+      liveEventSubjects[0].error(new ConnectionFailedError('EventSource connection failed'))
+      await vi.advanceTimersByTimeAsync(LIVE_EVENTS_RETRY_DELAY)
+
+      expect(events).toHaveBeenCalledTimes(2)
+      expect(error).not.toHaveBeenCalled()
+      subscription.unsubscribe()
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  it('retries the connection after server-initiated errors', async () => {
+    vi.useFakeTimers()
+    try {
+      const error = vi.fn()
+      const subscription = observeLiveEvents(instance, {onCorsError: vi.fn()}).subscribe({error})
+      expect(events).toHaveBeenCalledTimes(1)
+
+      liveEventSubjects[0].error(new Error('ChannelError'))
+      await vi.advanceTimersByTimeAsync(LIVE_EVENTS_RETRY_DELAY)
+
+      expect(events).toHaveBeenCalledTimes(2)
+      expect(error).not.toHaveBeenCalled()
+      subscription.unsubscribe()
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+})

package/src/client/liveEvents.ts

@@ -0,0 +1,107 @@
+import {
+  ConnectionFailedError,
+  CorsOriginError,
+  DisconnectError,
+  type LiveEventMessage,
+} from '@sanity/client'
+import {catchError, defer, EMPTY, filter, type Observable, retry, switchMap} from 'rxjs'
+
+import {type DocumentResource} from '../config/sanityConfig'
+import {type SanityInstance} from '../store/createSanityInstance'
+import {getClientState} from './clientStore'
+
+/**
+ * All live-events subscriptions must use identical connection options
+ * (API version, request tag, `includeDrafts`): `@sanity/client` caches the
+ * underlying EventSource per URL + options, so divergent options would
+ * silently split what should be a single shared connection.
+ */
+const LIVE_EVENTS_API_VERSION = 'v2025-05-06'
+
+/**
+ * Delay before re-establishing the live events connection after a
+ * server-initiated error (e.g. ChannelError, MessageError). Live errors are
+ * retried rather than surfaced because an errored live connection would
+ * otherwise poison the consuming store. Plain connection drops never reach
+ * this — they are reconnected inside `@sanity/client`.
+ *
+ * @internal
+ */
+export const LIVE_EVENTS_RETRY_DELAY = 1000
+
+/**
+ * Options for {@link observeLiveEvents}.
+ * @internal
+ */
+export interface ObserveLiveEventsOptions {
+  /** Resource to scope the underlying client and live connection to. */
+  resource?: DocumentResource
+  /**
+   * Called when the connection fails due to a CORS misconfiguration. The
+   * error is swallowed (the stream never errors; it idles until a new client
+   * is emitted) so consumers can surface it as store state instead of a
+   * stream error.
+   */
+  onCorsError: (error: unknown) => void
+}
+
+/**
+ * Emits Live Content API messages for a dataset so consumers can invalidate
+ * fetched data via sync tags.
+ *
+ * All consumers observe the same underlying EventSource connection:
+ * `@sanity/client` caches the live-events stream per URL and connection
+ * options, and every subscription made through this function uses the same
+ * API version and request tag.
+ *
+ * @internal
+ */
+export function observeLiveEvents(
+  instance: SanityInstance,
+  {resource, onCorsError}: ObserveLiveEventsOptions,
+): Observable<LiveEventMessage> {
+  return getClientState(instance, {
+    apiVersion: LIVE_EVENTS_API_VERSION,
+    resource,
+  }).observable.pipe(
+    switchMap((client) =>
+      defer(() =>
+        client.live.events({includeDrafts: !!client.config().token, tag: 'live-events'}),
+      ).pipe(
+        catchError((error) => {
+          if (error instanceof CorsOriginError) {
+            // Swallow CORS errors without bubbling up so that they can be
+            // handled by the consumer (e.g. shown via the Cors Error component)
+            onCorsError(error)
+            return EMPTY
+          }
+          if (error instanceof DisconnectError) {
+            // The server explicitly told this client to stop reconnecting —
+            // end live updates without erroring (consumers keep serving data,
+            // they just stop receiving live invalidation)
+            return EMPTY
+          }
+          if (
+            error instanceof ConnectionFailedError &&
+            typeof error.status === 'number' &&
+            error.status >= 400 &&
+            error.status < 500
+          ) {
+            // The server rejected the connection with a 4xx (e.g. a 401 from
+            // an expired token) — it will keep rejecting, so retrying would
+            // reconnect once per second forever. End live updates like a
+            // DisconnectError. A ConnectionFailedError without a status stays
+            // retryable: it may be a transient network failure.
+            return EMPTY
+          }
+          throw error
+        }),
+        // Server-initiated live errors (e.g. ChannelError, MessageError) are
+        // retried, not surfaced. Dropped connections are already reconnected
+        // inside @sanity/client.
+        retry({delay: LIVE_EVENTS_RETRY_DELAY}),
+      ),
+    ),
+    filter((e): e is LiveEventMessage => e.type === 'message'),
+  )
+}

package/src/comlink/controller/actions/destroyController.test.ts

@@ -7,7 +7,10 @@ import {type ComlinkControllerState} from '../comlinkControllerStore'
 import {destroyController} from './destroyController'
 
 describe('destroyController', () => {
-  const instance = createSanityInstance()
+  const instance = createSanityInstance({
+    projectId: 'test-project-id',
+    dataset: 'test-dataset',
+  })
   let state: ReturnType<typeof createStoreState<ComlinkControllerState>>
   let mockController: {destroy: ReturnType<typeof vi.fn>}
 

package/src/comlink/controller/actions/getOrCreateChannel.test.ts

@@ -13,7 +13,10 @@ const channelConfig = {
 }
 
 describe('getOrCreateChannel', () => {
-  const instance = createSanityInstance()
+  const instance = createSanityInstance({
+    projectId: 'test-project-id',
+    dataset: 'test-dataset',
+  })
   let state: ReturnType<typeof createStoreState<ComlinkControllerState>>
   let mockController: Partial<Controller>
   let mockChannel: Partial<ChannelInstance<FrameMessage, WindowMessage>>