@sanity/sdk 0.0.0-alpha.1

package/src/client/store/actions/getClientEvents.test.ts

@@ -0,0 +1,95 @@
+import {createClient, type SanityClient} from '@sanity/client'
+import {describe, expect, it, vi} from 'vitest'
+
+import {config} from '../../../../test/fixtures'
+import {createSanityInstance} from '../../../instance/sanityInstance'
+import {createClientStore} from '../clientStore'
+
+describe('getClientEvents', () => {
+  const API_VERSION = '2024-12-05'
+  let defaultClient: SanityClient
+  let store: ReturnType<typeof createClientStore>
+  let instance: ReturnType<typeof createSanityInstance>
+
+  beforeEach(() => {
+    instance = createSanityInstance(config)
+    defaultClient = createClient({...config, apiVersion: API_VERSION, useCdn: false})
+    store = createClientStore(instance, defaultClient)
+  })
+
+  it('immediately emits initial client', () => {
+    const events = store.getClientEvents({apiVersion: '2024-01-01'})
+    const mockNext = vi.fn()
+
+    events.subscribe({next: mockNext})
+
+    expect(mockNext).toHaveBeenCalledTimes(1)
+    const emittedClient = mockNext.mock.calls[0][0]
+    expect(emittedClient.config().apiVersion).toBe('2024-01-01')
+  })
+
+  it('emits new client when store updates token', () => {
+    const events = store.getClientEvents({apiVersion: '2024-01-01'})
+    const mockNext = vi.fn()
+
+    events.subscribe({next: mockNext})
+    store.receiveToken('new-token')
+
+    expect(mockNext).toHaveBeenCalledTimes(2) // Initial + update
+    const latestClient = mockNext.mock.calls[1][0]
+    expect(latestClient.config().token).toBe('new-token')
+    expect(latestClient.config().apiVersion).toBe('2024-01-01')
+  })
+
+  it('unsubscribes properly', () => {
+    const events = store.getClientEvents({apiVersion: '2024-01-01'})
+    const mockNext = vi.fn()
+
+    const subscription = events.subscribe({next: mockNext})
+    subscription.unsubscribe()
+
+    store.receiveToken('new-token')
+
+    // Should only have the initial emission
+    expect(mockNext).toHaveBeenCalledTimes(1)
+  })
+
+  it('throws error when apiVersion is missing', () => {
+    expect(() => store.getClientEvents({})).toThrow('Missing required `apiVersion` option')
+  })
+
+  it('maintains apiVersion through updates', () => {
+    const events = store.getClientEvents({apiVersion: '2024-01-01'})
+    const mockNext = vi.fn()
+
+    events.subscribe({next: mockNext})
+    store.receiveToken('token1')
+    store.receiveToken('token2')
+
+    expect(mockNext).toHaveBeenCalledTimes(3) // Initial + 2 updates
+    mockNext.mock.calls.forEach(([client]) => {
+      expect(client.config().apiVersion).toBe('2024-01-01')
+    })
+  })
+
+  it('handles multiple subscribers independently', () => {
+    const events1 = store.getClientEvents({apiVersion: '2024-01-01'})
+    const events2 = store.getClientEvents({apiVersion: '2024-02-01'})
+    const mockNext1 = vi.fn()
+    const mockNext2 = vi.fn()
+
+    events1.subscribe({next: mockNext1})
+    events2.subscribe({next: mockNext2})
+    store.receiveToken('new-token')
+
+    expect(mockNext1).toHaveBeenCalledTimes(2) // Initial + update
+    expect(mockNext2).toHaveBeenCalledTimes(2) // Initial + update
+
+    const latestClient1 = mockNext1.mock.calls[1][0]
+    const latestClient2 = mockNext2.mock.calls[1][0]
+    expect(latestClient1.config().apiVersion).toBe('2024-01-01')
+    expect(latestClient2.config().apiVersion).toBe('2024-02-01')
+    expect(latestClient1.config().token).toBe('new-token')
+    expect(latestClient2.config().token).toBe('new-token')
+  })
+})

package/src/client/store/actions/getClientEvents.ts

@@ -0,0 +1,33 @@
+import type {SanityClient} from '@sanity/client'
+import {distinctUntilChanged, map, Observable, startWith, type Subscribable} from 'rxjs'
+
+import type {StoreActionContext} from '../../../store/createStore'
+import type {ClientOptions, ClientState} from '../clientStore'
+import {getOrCreateClient} from './getOrCreateClient'
+
+/**
+ * Provides a stream of clients, based on the current state of the store.
+ * (For example, when a user logs in, this will emit an authorized client.)
+ * @internal
+ */
+export const getClientEvents = (
+  context: StoreActionContext<ClientState>,
+  options: ClientOptions = {},
+): Subscribable<SanityClient> => {
+  const {store} = context
+
+  const initialClient = getOrCreateClient(context, options)
+  const clientStore$ = new Observable<void>((subscriber) =>
+    store.subscribe(() => subscriber.next()),
+  )
+
+  const client$ = clientStore$.pipe(
+    map(() => getOrCreateClient(context, options)),
+    startWith(initialClient),
+    distinctUntilChanged((prev, curr) => prev.config().token === curr.config().token),
+  )
+
+  return {
+    subscribe: client$.subscribe.bind(client$),
+  }
+}

package/src/client/store/actions/getOrCreateClient.test.ts

@@ -0,0 +1,56 @@
+import {createClient, type SanityClient} from '@sanity/client'
+
+import {config} from '../../../../test/fixtures'
+import {createSanityInstance} from '../../../instance/sanityInstance'
+import {createClientStore} from '../clientStore'
+
+describe('getOrCreateClient', () => {
+  const API_VERSION = '2024-12-05'
+  let defaultClient: SanityClient
+  let store: ReturnType<typeof createClientStore>
+  let instance: ReturnType<typeof createSanityInstance>
+
+  beforeEach(() => {
+    instance = createSanityInstance(config)
+    defaultClient = createClient({...config, apiVersion: API_VERSION, useCdn: false})
+    store = createClientStore(instance, defaultClient)
+  })
+
+  it('throws error when apiVersion is missing', () => {
+    expect(() => store.getOrCreateClient({})).toThrow('Missing required `apiVersion` option')
+  })
+
+  it('creates new client with correct apiVersion', () => {
+    const apiVersion = '2024-01-01'
+    const result = store.getOrCreateClient({apiVersion})
+    expect(result.config().apiVersion).toBe(apiVersion)
+  })
+
+  it('reuses existing client for same apiVersion', () => {
+    const apiVersion = '2024-01-01'
+    const result1 = store.getOrCreateClient({apiVersion})
+    const result2 = store.getOrCreateClient({apiVersion})
+
+    expect(result1).toBe(result2)
+  })
+
+  it('preserves client identity after token update', () => {
+    const apiVersion = '2024-01-01'
+    const client1 = store.getOrCreateClient({apiVersion})
+
+    // Update token
+    store.receiveToken('new-token')
+
+    const client2 = store.getOrCreateClient({apiVersion})
+
+    // Verify the new token was applied
+    expect(client2.config().token).toBe('new-token')
+    expect(client2.config().apiVersion).toBe(apiVersion)
+
+    // Verify we got a new client instance (since token changed)
+    expect(client2).not.toBe(client1)
+
+    // Verify first client keeps its original config
+    expect(client1.config().token).toBeUndefined()
+  })
+})

package/src/client/store/actions/getOrCreateClient.ts

@@ -0,0 +1,40 @@
+import {type SanityClient} from '@sanity/client'
+
+import type {StoreActionContext} from '../../../store/createStore'
+import type {ClientOptions, ClientState} from '../clientStore'
+
+/**
+ * Retrieves a memoized client based on the API version,
+ * or creates a new one if it doesn't exist.
+ * @internal
+ */
+export const getOrCreateClient = (
+  {store}: StoreActionContext<ClientState>,
+  options: ClientOptions = {},
+): SanityClient => {
+  const state = store.getState()
+  const {apiVersion} = options
+
+  if (!apiVersion) {
+    throw new Error('Missing required `apiVersion` option')
+  }
+
+  const cached = state.clients.get(apiVersion)
+  if (cached) {
+    return cached
+  }
+
+  // Create new client with specified API version
+  const client = state.defaultClient.withConfig(options)
+
+  // Update state with new client
+  store.setState((prevState) => {
+    const newMap = new Map(prevState.clients)
+    newMap.set(apiVersion, client)
+    return {
+      clients: newMap,
+    }
+  })
+
+  return client
+}

package/src/client/store/actions/receiveToken.test.ts

@@ -0,0 +1,18 @@
+import {config} from '../../../../test/fixtures'
+import {createSanityInstance} from '../../../instance/sanityInstance'
+import {getClientStore} from '../clientStore'
+
+describe('receiveToken', () => {
+  const sanityInstance = createSanityInstance(config)
+  it('updates client tokens when auth state changes', () => {
+    const store = getClientStore(sanityInstance)
+
+    const client = store.getOrCreateClient({apiVersion: 'v2023-01-01'})
+    expect(client.config().token).toBeUndefined()
+
+    store.receiveToken('new-token')
+
+    const updatedClient = store.getOrCreateClient({apiVersion: 'v2023-01-01'})
+    expect(updatedClient.config().token).toBe('new-token')
+  })
+})

package/src/client/store/actions/receiveToken.ts

@@ -0,0 +1,31 @@
+import type {StoreActionContext} from '../../../store/createStore'
+import type {ClientState} from '../clientStore'
+
+/**
+ * Updates the client store state when a token is received.
+ * @internal
+ */
+export const receiveToken = (
+  {store}: StoreActionContext<ClientState>,
+  token: string | undefined,
+): void => {
+  // Update the default client
+  const newDefaultClient = store.getState().defaultClient.withConfig({
+    token,
+  })
+
+  // Update existing clients while preserving the map structure
+  store.setState((prevState) => {
+    const updatedClients = new Map(
+      Array.from(prevState.clients.entries()).map(([version, client]) => [
+        version,
+        client.withConfig({token}),
+      ]),
+    )
+
+    return {
+      defaultClient: newDefaultClient,
+      clients: updatedClients,
+    }
+  })
+}

package/src/client/store/clientStore.test.ts

@@ -0,0 +1,152 @@
+import {describe, expect, it, vi} from 'vitest'
+
+import {config} from '../../../test/fixtures'
+import {getInternalAuthStore} from '../../auth/getInternalAuthStore'
+import {createSanityInstance} from '../../instance/sanityInstance'
+import {getClientStore} from './clientStore'
+
+// Mock at module level but don't provide implementation yet
+vi.mock('../../auth/getAuthStore')
+
+describe.skip('clientStore', () => {
+  beforeEach(() => {
+    vi.resetModules()
+    vi.clearAllMocks()
+    // Reset to default mock implementation
+    vi.mocked(getInternalAuthStore).mockImplementation(() => ({
+      setState: vi.fn(),
+      getState: () => ({
+        authState: {type: 'logged-out', isDestroyingSession: false},
+        providers: undefined,
+        setAuthState: vi.fn(),
+        setProviders: vi.fn(),
+        handleCallback: vi.fn(),
+        getLoginUrls: vi.fn(),
+        logout: vi.fn(),
+        dispose: vi.fn(),
+      }),
+      getInitialState: () => ({
+        authState: {type: 'logged-out', isDestroyingSession: false},
+        providers: undefined,
+        setAuthState: vi.fn(),
+        setProviders: vi.fn(),
+        handleCallback: vi.fn(),
+        getLoginUrls: vi.fn(),
+        logout: vi.fn(),
+        dispose: vi.fn(),
+      }),
+      subscribe: () => () => {}, // Default no-op implementation
+    }))
+  })
+
+  it('creates a store with the expected interface', () => {
+    const sanityInstance = createSanityInstance(config)
+    const store = getClientStore(sanityInstance)
+    expect(store).toHaveProperty('getClientEvents')
+    expect(store).toHaveProperty('getOrCreateClient')
+    expect(store).toHaveProperty('receiveToken')
+  })
+
+  it('provides clients with correct configuration', () => {
+    const sanityInstance = createSanityInstance(config)
+    const store = getClientStore(sanityInstance)
+    const client = store.getOrCreateClient({apiVersion: 'v2024-11-12'})
+    const clientConfig = client.config()
+    expect(clientConfig).toMatchObject({
+      ...config,
+      useCdn: false,
+    })
+  })
+
+  it('creates clients with config auth token', () => {
+    const instanceWithToken = createSanityInstance({
+      ...config,
+      auth: {
+        token: 'initial-auth-token',
+      },
+    })
+
+    const store = getClientStore(instanceWithToken)
+    const client = store.getOrCreateClient({apiVersion: 'v2024-11-12'})
+
+    expect(client.config().token).toBe('initial-auth-token')
+  })
+
+  it('handles logged-in auth state changes', async () => {
+    const sanityInstance = createSanityInstance(config)
+
+    // Override mock implementation just for this test
+    vi.mocked(getInternalAuthStore).mockImplementation(() => ({
+      setState: vi.fn(),
+      getState: () => ({
+        authState: {type: 'logged-in', token: 'test-token', currentUser: null},
+        providers: undefined,
+        setAuthState: vi.fn(),
+        setProviders: vi.fn(),
+        handleCallback: vi.fn(),
+        getLoginUrls: vi.fn(),
+        logout: vi.fn(),
+        dispose: vi.fn(),
+      }),
+      getInitialState: () => ({
+        authState: {type: 'logged-in', token: 'test-token', currentUser: null},
+        providers: undefined,
+        setAuthState: vi.fn(),
+        setProviders: vi.fn(),
+        handleCallback: vi.fn(),
+        getLoginUrls: vi.fn(),
+        logout: vi.fn(),
+        dispose: vi.fn(),
+      }),
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      subscribe: (observer: any) => {
+        observer.next({type: 'logged-in', token: 'test-token', currentUser: null})
+        return () => {}
+      },
+    }))
+
+    const store = getClientStore(sanityInstance)
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    const client = store.getOrCreateClient({apiVersion: 'v2023-01-01'})
+    expect(client.config().token).toBe('test-token')
+  })
+
+  it('properly cleans up auth subscription when cleanup is called', () => {
+    const unsubscribeSpy = vi.fn()
+
+    // Mock the auth store with a spy on the unsubscribe function
+    vi.mocked(getInternalAuthStore).mockImplementation(() => ({
+      setState: vi.fn(),
+      getState: () => ({
+        authState: {type: 'logged-in', token: 'test-token', currentUser: null},
+        providers: undefined,
+        setAuthState: vi.fn(),
+        setProviders: vi.fn(),
+        handleCallback: vi.fn(),
+        getLoginUrls: vi.fn(),
+        logout: vi.fn(),
+        dispose: vi.fn(),
+      }),
+      getInitialState: () => ({
+        authState: {type: 'logged-in', token: 'test-token', currentUser: null},
+        providers: undefined,
+        setAuthState: vi.fn(),
+        setProviders: vi.fn(),
+        handleCallback: vi.fn(),
+        getLoginUrls: vi.fn(),
+        logout: vi.fn(),
+        dispose: vi.fn(),
+      }),
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      subscribe: (observer: any) => {
+        observer.next({type: 'logged-in', token: 'test-token', currentUser: null})
+        return unsubscribeSpy
+      },
+    }))
+
+    // Verify that the unsubscribe function was called
+    expect(unsubscribeSpy).toHaveBeenCalledTimes(1)
+  })
+})

package/src/client/store/clientStore.ts

@@ -0,0 +1,98 @@
+import {createClient, type SanityClient} from '@sanity/client'
+import type {Subscribable} from 'rxjs'
+
+import {getInternalAuthStore} from '../../auth/getInternalAuthStore'
+import {getOrCreateResource} from '../../instance/sanityInstance'
+import type {SanityInstance} from '../../instance/types'
+import {createStore} from '../../store/createStore'
+import {getClientEvents} from './actions/getClientEvents'
+import {getOrCreateClient} from './actions/getOrCreateClient'
+import {receiveToken} from './actions/receiveToken'
+
+export const DEFAULT_API_VERSION = 'v2024-11-12'
+
+/**
+ * Options used when retrieving a client via getOrCreateClient.
+ * @public
+ */
+export interface ClientOptions {
+  apiVersion?: string
+}
+
+/**
+ * Internal state of the client store.
+ * @internal
+ */
+export interface ClientState {
+  // default client shouldn't be exposed, but is used in creation of new clients
+  defaultClient: SanityClient
+  clients: Map<string, SanityClient>
+}
+
+/**
+ * Collection of actions to retrieve or create clients.
+ * @internal
+ */
+export interface ClientStore {
+  getOrCreateClient: (options: ClientOptions) => SanityClient
+  receiveToken: (token: string | undefined) => void
+  getClientEvents: (options: ClientOptions) => Subscribable<SanityClient>
+}
+
+const createInitialState = (defaultClient: SanityClient): ClientState => {
+  const clients = new Map<string, SanityClient>()
+  clients.set(defaultClient.config().apiVersion, defaultClient)
+  return {defaultClient, clients}
+}
+
+const clientStoreActions = {
+  getOrCreateClient,
+  receiveToken,
+  getClientEvents,
+}
+
+/**
+ * Construction method for creating a client store, including subscribing to auth store.
+ * @internal
+ */
+export const createClientStore = (
+  instance: SanityInstance,
+  defaultClient: SanityClient,
+): ClientStore => {
+  const internalAuthStore = getInternalAuthStore(instance)
+
+  const store = createStore(createInitialState(defaultClient), clientStoreActions, {
+    name: 'clientStore',
+    instance,
+  })
+
+  internalAuthStore.subscribe((state, prevState) => {
+    if (state.authState.type === 'logged-in' && prevState.authState.type !== 'logged-in') {
+      store.receiveToken(state.authState.token)
+    }
+    if (prevState.authState.type === 'logged-in' && state.authState.type !== 'logged-in') {
+      store.receiveToken(undefined)
+    }
+  })
+
+  return store
+}
+
+/**
+ * This is an internal function that retrieves or creates a client store.
+ * @internal
+ */
+export const getClientStore = (instance: SanityInstance): ClientStore => {
+  return getOrCreateResource(instance, 'clientStore', () => {
+    const {config, identity} = instance
+
+    const client = createClient({
+      projectId: identity.projectId,
+      dataset: identity.dataset,
+      token: config?.auth?.token,
+      useCdn: false,
+      apiVersion: DEFAULT_API_VERSION,
+    })
+    return createClientStore(instance, client)
+  })
+}