@sanity/sdk 0.0.0-alpha.21 → 0.0.0-alpha.23

package/src/client/clientStore.test.ts

@@ -1,87 +1,151 @@
-import {first, firstValueFrom, map, ReplaySubject} from 'rxjs'
-import {describe, expect, it} from 'vitest'
+import {createClient, type SanityClient} from '@sanity/client'
+import {Subject} from 'rxjs'
+import {beforeEach, describe, expect, it, vi} from 'vitest'
 
 import {getTokenState} from '../auth/authStore'
-import {createSanityInstance} from '../instance/sanityInstance'
-import {type StateSource} from '../resources/createStateSourceAction'
-import {type ClientOptions, getClient, getClientState} from './clientStore'
+import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
+import {getClient, getClientState} from './clientStore'
 
-let token$: ReplaySubject<string>
+// Mock dependencies
+vi.mock('@sanity/client')
 
-vi.mock('../auth/authStore', () => {
-  const subject = new ReplaySubject(1)
-  subject.next('initial-token')
+vi.mock('../auth/authStore')
 
-  return {
-    getTokenState: vi.fn().mockReturnValue({observable: subject}),
-  }
-})
+let instance: SanityInstance
 
 beforeEach(() => {
-  token$ = (getTokenState as () => StateSource<string>)().observable as ReplaySubject<string>
+  vi.resetAllMocks()
+  vi.mocked(getTokenState).mockReturnValue({
+    getCurrent: vi.fn().mockReturnValue('initial-token'),
+    subscribe: vi.fn(),
+    observable: new Subject(),
+  })
+  vi.mocked(createClient).mockImplementation(
+    (clientConfig) => ({config: () => clientConfig}) as SanityClient,
+  )
+  instance = createSanityInstance({projectId: 'test-project', dataset: 'test-dataset'})
 })
 
-describe('getClient', () => {
-  it('memoizes the resulting client based on current default client', () => {
-    const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
-    const client1 = getClient(instance, {apiVersion: 'vX'})
-    const client2 = getClient(instance, {apiVersion: 'vX'})
-    expect(client1).toBe(client2)
-  })
+afterEach(() => {
+  instance.dispose()
+})
 
-  it('configures `apiHost`', () => {
-    const stagingApiHost = 'https://api.sanity.work'
-    const instance = createSanityInstance({
-      projectId: 'p',
-      dataset: 'd',
-      auth: {apiHost: stagingApiHost},
+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',
+      })
     })
-    const projectClient = getClient(instance, {apiVersion: 'vX', scope: 'project'})
-    const globalClient = getClient(instance, {apiVersion: 'vX', scope: 'global'})
 
-    expect(projectClient.config().apiHost).toBe(stagingApiHost)
-    expect(globalClient.config().apiHost).toBe(stagingApiHost)
-  })
-
-  it('returns a different result if the token is updated', () => {
-    const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
-    const client1 = getClient(instance, {apiVersion: 'vX'})
-    const client2 = getClient(instance, {apiVersion: 'vX'})
-    expect(client1).toBe(client2)
-    expect(client1.config().token).toBe('initial-token')
-    expect(client1.config().token).toBe(client2.config().token)
-
-    token$.next('updated-token')
-    const client3 = getClient(instance, {apiVersion: 'vX'})
-    const client4 = getClient(instance, {apiVersion: 'vX'})
-    expect(client3).toBe(client4)
-    expect(client3.config().token).toBe('updated-token')
-    expect(client3.config().token).toBe(client4.config().token)
-  })
-})
+    it('should throw when using disallowed configuration keys', () => {
+      expect(() =>
+        getClient(instance, {
+          apiVersion: '2024-11-12',
+          // @ts-expect-error Testing invalid key
+          illegalKey: 'foo',
+        }),
+      ).toThrowError(/unsupported properties: illegalKey/)
+    })
 
-describe('getClientState', () => {
-  it('returns a state source that updates when `getClient` updates', async () => {
-    const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
-    const options: ClientOptions = {apiVersion: 'vX', scope: 'global'}
-    const clientState = getClientState(instance, options)
+    it('should reuse clients with identical configurations', () => {
+      const options = {apiVersion: '2024-11-12', useCdn: true}
+      const client1 = getClient(instance, options)
+      const client2 = getClient(instance, options)
 
-    expect(clientState.getCurrent()).toBe(getClient(instance, options))
+      expect(client1).toBe(client2)
+      expect(vi.mocked(createClient)).toHaveBeenCalledTimes(1)
+    })
 
-    const subscriber = vi.fn()
-    const unsubscribe = clientState.subscribe(subscriber)
+    it('should create new clients when configuration changes', () => {
+      const client1 = getClient(instance, {apiVersion: '2024-11-12'})
+      const client2 = getClient(instance, {apiVersion: '2023-08-01'})
 
-    const tokenUpdated = firstValueFrom(
-      clientState.observable.pipe(
-        map((client) => client.config().token),
-        first((token) => token === 'updated-token'),
-      ),
-    )
+      expect(client1).not.toBe(client2)
+      expect(vi.mocked(createClient)).toHaveBeenCalledTimes(2)
+    })
+  })
 
-    token$.next('updated-token')
-    await tokenUpdated
+  describe('token handling', () => {
+    it('should reset clients when token changes', () => {
+      // Initial client with first token
+      const tokenState = getTokenState(instance)
+      vi.mocked(tokenState.getCurrent).mockReturnValue('first-token')
+      const client1 = getClient(instance, {apiVersion: '2024-11-12'})
+
+      // Simulate token change
+      vi.mocked(tokenState.getCurrent).mockReturnValue('new-token')
+      const token$ = tokenState.observable as Subject<string>
+      token$.next('new-token')
+
+      // New client should be created with new token
+      const client2 = getClient(instance, {apiVersion: '2024-11-12'})
+
+      expect(client1).not.toBe(client2)
+      expect(vi.mocked(createClient)).toHaveBeenCalledWith(
+        expect.objectContaining({
+          token: 'new-token',
+        }),
+      )
+    })
+  })
 
-    expect(subscriber).toHaveBeenCalledTimes(1)
-    unsubscribe()
+  describe('getClientState', () => {
+    it('should provide a state source that emits client changes', async () => {
+      // Get initial client state with a specific configuration
+      const state = getClientState(instance, {apiVersion: '2024-11-12'})
+
+      // Get initial client
+      const initialClient = state.getCurrent()
+      expect(initialClient).toBeDefined()
+
+      // Setup a spy to track emissions from the observable
+      const nextSpy = vi.fn()
+      const subscription = state.observable.subscribe(nextSpy)
+
+      // Should have emitted once initially
+      expect(nextSpy).toHaveBeenCalledTimes(1)
+      expect(nextSpy).toHaveBeenCalledWith(initialClient)
+
+      // Simulate token change
+      const tokenState = getTokenState(instance)
+      vi.mocked(tokenState.getCurrent).mockReturnValue('updated-token')
+      const token$ = tokenState.observable as Subject<string>
+      token$.next('updated-token')
+
+      // Should emit a new client instance
+      expect(nextSpy).toHaveBeenCalledTimes(2)
+
+      // The new client should be different from the initial one
+      const updatedClient = nextSpy.mock.calls[1][0]
+      expect(updatedClient).not.toBe(initialClient)
+
+      // The updated client should have the new token
+      expect(updatedClient.config()).toEqual(
+        expect.objectContaining({
+          token: 'updated-token',
+        }),
+      )
+
+      // Clean up subscription
+      subscription.unsubscribe()
+    })
   })
 })

package/src/client/clientStore.ts

@@ -1,23 +1,61 @@
 import {type ClientConfig, createClient, type SanityClient} from '@sanity/client'
-import {createSelector} from 'reselect'
+import {pick} from 'lodash-es'
 
 import {getTokenState} from '../auth/authStore'
-import {type ResourceId} from '../document/patchOperations'
-import {type SanityInstance} from '../instance/types'
-import {type ActionContext, createAction, createInternalAction} from '../resources/createAction'
-import {createResource, type Resource} from '../resources/createResource'
-import {createStateSourceAction} from '../resources/createStateSourceAction'
+import {type DatasetHandle} from '../config/sanityConfig'
+import {bindActionGlobally} from '../store/createActionBinder'
+import {createStateSourceAction} from '../store/createStateSourceAction'
+import {defineStore, type StoreContext} from '../store/defineStore'
 
 const DEFAULT_API_VERSION = '2024-11-12'
 const DEFAULT_REQUEST_TAG_PREFIX = 'sanity.sdk'
 
+type AllowedClientConfigKey =
+  | 'useCdn'
+  | 'token'
+  | 'perspective'
+  | 'apiHost'
+  | 'proxy'
+  | 'withCredentials'
+  | 'timeout'
+  | 'maxRetries'
+  | 'dataset'
+  | 'projectId'
+  | 'requestTagPrefix'
+  | '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,
+} satisfies Record<keyof ClientOptions, null>) as (keyof ClientOptions)[]
+
+const DEFAULT_CLIENT_CONFIG: ClientConfig = {
+  apiVersion: DEFAULT_API_VERSION,
+  useCdn: false,
+  ignoreBrowserTokenWarning: true,
+  allowReconfigure: false,
+  requestTagPrefix: DEFAULT_REQUEST_TAG_PREFIX,
+}
+
 /**
  * States tracked by the client store
  * @public
  */
-export interface ClientState {
-  defaultClient: SanityClient
-  defaultGlobalClient: SanityClient
+export interface ClientStoreState {
+  token: string | null
+  clients: {[TKey in string]?: SanityClient}
 }
 
 /**
@@ -30,150 +68,113 @@ export interface ClientState {
  *   ('project') and the global client ('global'). When set to `'global'`, the
  *   global client is used.
  *
- * These options are utilized by `getClient` and `getClientState` to return a memoized
- * client instance, ensuring that clients are reused for identical configurations and that
- * updates (such as auth token changes) propagate correctly.
+ * These options are utilized by `getClient` and `getClientState` to configure and
+ * return appropriate client instances that automatically handle authentication
+ * updates and configuration changes.
  *
  * @public
  */
-export interface ClientOptions extends ClientConfig {
+export interface ClientOptions extends Pick<ClientConfig, AllowedClientConfigKey>, DatasetHandle {
   /**
-   * An optional flag to choose between the project-specific client ('project')
+   * 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?: 'project' | 'global'
+  scope?: 'default' | 'global'
   /**
    * A required string indicating the API version for the client.
    */
   apiVersion: string
-
-  /**
-   * A resource identifier for a document, in the format of `projectId.dataset`
-   */
-  resourceId?: ResourceId
 }
 
-const clientStore: Resource<ClientState> = createResource({
+const clientStore = defineStore<ClientStoreState>({
   name: 'clientStore',
 
-  getInitialState: (instance: SanityInstance) => {
-    const {identity, config} = instance
-    const defaultClient = createClient({
-      projectId: identity.projectId,
-      dataset: identity.dataset,
-      token: config?.auth?.token,
-      useCdn: false,
-      apiVersion: DEFAULT_API_VERSION,
-      requestTagPrefix: DEFAULT_REQUEST_TAG_PREFIX,
-      ...(config?.auth?.apiHost ? {apiHost: config.auth.apiHost} : {}),
-    })
-
-    const defaultGlobalClient = createClient({
-      token: config?.auth?.token,
-      useCdn: false,
-      apiVersion: 'vX', // Many global APIs are only available under this version, we may need to support other versions in the future
-      useProjectHostname: false,
-      requestTagPrefix: DEFAULT_REQUEST_TAG_PREFIX,
-      ...(config?.auth?.apiHost ? {apiHost: config.auth.apiHost} : {}),
-    })
-
-    return {
-      defaultClient,
-      defaultGlobalClient,
-    }
-  },
+  getInitialState: (instance) => ({
+    clients: {},
+    token: getTokenState(instance).getCurrent(),
+  }),
 
-  initialize() {
-    const authEventSubscription = subscribeToAuthEvents(this)
-    return () => {
-      authEventSubscription.unsubscribe()
-    }
+  initialize(context) {
+    const subscription = listenToToken(context)
+    return () => subscription.unsubscribe()
   },
 })
 
-const receiveToken = (prev: ClientState, token: string | undefined): ClientState => {
-  const newDefaultClient = prev.defaultClient.withConfig({
-    token,
-  })
-  const newGlobalClient = prev.defaultGlobalClient.withConfig({
-    token,
-  })
-
-  return {
-    defaultClient: newDefaultClient,
-    defaultGlobalClient: newGlobalClient,
-  }
-}
-
 /**
  * Updates the client store state when a token is received.
  * @internal
  */
-const subscribeToAuthEvents = createInternalAction(
-  ({instance, state}: ActionContext<ClientState>) => {
-    return () => {
-      return getTokenState(instance).observable.subscribe((newToken) => {
-        state.set('receiveToken', (prev) => receiveToken(prev, newToken ?? undefined))
-      })
-    }
-  },
-)
-
-const optionsCache = new WeakMap<SanityClient, Map<string, ClientOptions>>()
-
-const defaultClientSelector = (state: ClientState, options: ClientOptions) =>
-  options?.scope === 'global' ? state.defaultGlobalClient : state.defaultClient
-
-const memoizedOptionsSelector = createSelector(
-  [defaultClientSelector, (_state: ClientState, options: ClientOptions) => options],
-  (client, options) => {
-    let nestedCache = optionsCache.get(client)
-    if (!nestedCache) {
-      nestedCache = new Map<string, ClientOptions>()
-      optionsCache.set(client, nestedCache)
-    }
-
-    const key = JSON.stringify(options)
-    const cached = nestedCache.get(key)
-    if (cached) return cached
-
-    nestedCache.set(key, options)
-    return options
-  },
-)
+const listenToToken = ({instance, state}: StoreContext<ClientStoreState>) => {
+  return getTokenState(instance).observable.subscribe((token) => {
+    state.set('setTokenAndResetClients', {token, clients: {}})
+  })
+}
 
-const clientSelector = createSelector(
-  [defaultClientSelector, memoizedOptionsSelector],
-  (client, options) => client.withConfig(options),
-)
+const getClientConfigKey = (options: ClientOptions) => JSON.stringify(pick(options, ...allowedKeys))
 
 /**
- * Retrieves a memoized Sanity client instance configured with the provided options.
+ * Retrieves a Sanity client instance configured with the provided options.
  *
- * This function uses a memoized selector to return a client instance from the
- * client store, based on the default project or global client. The selector
- * leverages a WeakMap-based cache and reselect to ensure that clients with the
- * same configuration are reused, and that updates, such as authentication token
- * changes, propagate automatically.
+ * This function returns a client instance configured for the project or as a
+ * global client based on the options provided. It ensures efficient reuse of
+ * client instances by returning the same instance for the same options.
+ * For automatic handling of authentication token updates, consider using
+ * `getClientState`.
  *
  * @public
  */
-export const getClient = createAction(
+export const getClient = bindActionGlobally(
   clientStore,
-  ({state}) =>
-    (options: ClientOptions) =>
-      clientSelector(state.get(), options),
+  ({state, instance}, options: ClientOptions) => {
+    // Check for disallowed keys
+    const providedKeys = Object.keys(options) as (keyof ClientOptions)[]
+    const disallowedKeys = providedKeys.filter((key) => !allowedKeys.includes(key))
+
+    if (disallowedKeys.length > 0) {
+      const listFormatter = new Intl.ListFormat('en', {style: 'long', type: 'conjunction'})
+      throw new Error(
+        `The client options provided contains unsupported properties: ${listFormatter.format(disallowedKeys)}. ` +
+          `Allowed keys are: ${listFormatter.format(allowedKeys)}.`,
+      )
+    }
+
+    const {token, clients} = state.get()
+    const projectId = options.projectId ?? instance.config.projectId
+    const dataset = options.dataset ?? instance.config.dataset
+    const apiHost = options.apiHost ?? instance.config.auth?.apiHost
+
+    const effectiveOptions: ClientOptions = {
+      ...DEFAULT_CLIENT_CONFIG,
+      ...((options.scope === 'global' || !projectId) && {useProjectHostname: false}),
+      ...(token && {token}),
+      ...options,
+      ...(projectId && {projectId}),
+      ...(dataset && {dataset}),
+      ...(apiHost && {apiHost}),
+    }
+
+    const key = getClientConfigKey(effectiveOptions)
+
+    if (clients[key]) return clients[key]
+
+    const client = createClient(effectiveOptions)
+    state.set('addClient', (prev) => ({clients: {...prev.clients, [key]: client}}))
+
+    return client
+  },
 )
 
 /**
  * Returns a state source for the Sanity client instance.
  *
  * This function provides a subscribable state source that emits updated client
- * instances whenever the client configuration changes (for example, due to
- * token updates). It leverages the underlying client store and memoized selector
- * to ensure that subscribers receive the most current client configuration.
+ * instances whenever relevant configurations change (such as authentication tokens).
+ * Use this when you need to react to client configuration changes in your application.
  *
  * @public
  */
-export const getClientState = createStateSourceAction(clientStore, clientSelector)
+export const getClientState = bindActionGlobally(
+  clientStore,
+  createStateSourceAction(({instance}, options: ClientOptions) => getClient(instance, options)),
+)

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

@@ -1,32 +1,57 @@
-import {beforeEach, describe, expect, it} from 'vitest'
+import {type Controller} from '@sanity/comlink'
+import {beforeEach, describe, expect, it, vi} from 'vitest'
 
-import {config} from '../../../../test/fixtures'
-import {createSanityInstance} from '../../../instance/sanityInstance'
-import {type SanityInstance} from '../../../instance/types'
-import {createResourceState} from '../../../resources/createResource'
-import {comlinkControllerStore} from '../comlinkControllerStore'
+import {createSanityInstance} from '../../../store/createSanityInstance'
+import {createStoreState} from '../../../store/createStoreState'
+import {type ComlinkControllerState} from '../comlinkControllerStore'
 import {destroyController} from './destroyController'
-import {getOrCreateController} from './getOrCreateController'
 
 describe('destroyController', () => {
-  let instance: SanityInstance
+  const instance = createSanityInstance({
+    projectId: 'test-project-id',
+    dataset: 'test-dataset',
+  })
+  let state: ReturnType<typeof createStoreState<ComlinkControllerState>>
+  let mockController: {destroy: ReturnType<typeof vi.fn>}
 
   beforeEach(() => {
-    instance = createSanityInstance(config)
+    mockController = {
+      destroy: vi.fn(),
+    }
+
+    // Initialize test store state
+    state = createStoreState<ComlinkControllerState>({
+      controller: null,
+      controllerOrigin: null,
+      channels: new Map(),
+    })
+  })
+
+  afterEach(() => {
+    instance.dispose()
   })
 
   it('should destroy controller and clear state', () => {
-    const state = createResourceState(comlinkControllerStore.getInitialState(instance))
-    getOrCreateController(instance, 'https://test.sanity.dev')!
+    // Set up test state with a controller
+    state.set('setup', {
+      controller: mockController as unknown as Controller,
+      controllerOrigin: 'https://test.sanity.dev',
+    })
+
+    // Execute action
     destroyController({state, instance})
 
+    // Verify controller was destroyed and state was cleared
+    expect(mockController.destroy).toHaveBeenCalled()
     expect(state.get().controller).toBeNull()
     expect(state.get().channels.size).toBe(0)
   })
 
   it('should do nothing if no controller exists', () => {
-    const state = createResourceState(comlinkControllerStore.getInitialState(instance))
-
+    // State already has null controller, so just execute action
     expect(() => destroyController({state, instance})).not.toThrow()
+
+    // State should remain unchanged
+    expect(state.get().controller).toBeNull()
   })
 })

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

@@ -1,22 +1,18 @@
-import {createInternalAction} from '../../../resources/createAction'
+import {type StoreContext} from '../../../store/defineStore'
 import {type ComlinkControllerState} from '../comlinkControllerStore'
 
 /**
  * Calls the destroy method on the controller and resets the controller state.
  * @public
  */
-export const destroyController = createInternalAction<ComlinkControllerState, [], void>(
-  ({state}) => {
-    return () => {
-      const {controller} = state.get()
+export const destroyController = ({state}: StoreContext<ComlinkControllerState>): void => {
+  const {controller} = state.get()
 
-      if (controller) {
-        controller.destroy()
-        state.set('destroyController', {
-          controller: null,
-          channels: new Map(),
-        })
-      }
-    }
-  },
-)
+  if (controller) {
+    controller.destroy()
+    state.set('destroyController', {
+      controller: null,
+      channels: new Map(),
+    })
+  }
+}