@sanity/sdk 0.0.0-chore-react-18-compat.1 → 0.0.0-chore-react-18-compat.3

package/src/auth/logout.ts

@@ -1,4 +1,4 @@
-import {createAction} from '../resources/createAction'
+import {bindActionGlobally} from '../store/createActionBinder'
 import {DEFAULT_API_VERSION, REQUEST_TAG_PREFIX} from './authConstants'
 import {AuthStateType} from './authStateType'
 import {authStore} from './authStore'
@@ -6,40 +6,38 @@ import {authStore} from './authStore'
 /**
  * @public
  */
-export const logout = createAction(authStore, ({state}) => {
+export const logout = bindActionGlobally(authStore, async ({state}) => {
   const {clientFactory, apiHost, providedToken, storageArea, storageKey} = state.get().options
 
-  return async function () {
-    // If a token is statically provided, logout does nothing
-    if (providedToken) return
+  // If a token is statically provided, logout does nothing
+  if (providedToken) return
 
-    const {authState} = state.get()
+  const {authState} = state.get()
 
-    // If we already have an inflight request, no-op
-    if (authState.type === AuthStateType.LOGGED_OUT && authState.isDestroyingSession) return
-    const token = authState.type === AuthStateType.LOGGED_IN && authState.token
+  // If we already have an inflight request, no-op
+  if (authState.type === AuthStateType.LOGGED_OUT && authState.isDestroyingSession) return
+  const token = authState.type === AuthStateType.LOGGED_IN && authState.token
 
-    try {
-      if (token) {
-        state.set('loggingOut', {
-          authState: {type: AuthStateType.LOGGED_OUT, isDestroyingSession: true},
-        })
-
-        const client = clientFactory({
-          token,
-          requestTagPrefix: REQUEST_TAG_PREFIX,
-          apiVersion: DEFAULT_API_VERSION,
-          ...(apiHost && {apiHost}),
-          useProjectHostname: false,
-        })
+  try {
+    if (token) {
+      state.set('loggingOut', {
+        authState: {type: AuthStateType.LOGGED_OUT, isDestroyingSession: true},
+      })
 
-        await client.request<void>({uri: '/auth/logout', method: 'POST'})
-      }
-    } finally {
-      state.set('logoutSuccess', {
-        authState: {type: AuthStateType.LOGGED_OUT, isDestroyingSession: false},
+      const client = clientFactory({
+        token,
+        requestTagPrefix: REQUEST_TAG_PREFIX,
+        apiVersion: DEFAULT_API_VERSION,
+        ...(apiHost && {apiHost}),
+        useProjectHostname: false,
       })
-      storageArea?.removeItem(storageKey)
+
+      await client.request<void>({uri: '/auth/logout', method: 'POST'})
     }
+  } finally {
+    state.set('logoutSuccess', {
+      authState: {type: AuthStateType.LOGGED_OUT, isDestroyingSession: false},
+    })
+    storageArea?.removeItem(storageKey)
   }
 })

package/src/auth/refreshStampedToken.test.ts

@@ -1,74 +1,191 @@
 import {of, Subscription, throwError} from 'rxjs'
 import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
 
-import {createSanityInstance} from '../instance/sanityInstance'
-import {createResourceState} from '../resources/createResource'
+import {createSanityInstance} from '../store/createSanityInstance'
+import {createStoreState} from '../store/createStoreState'
 import {AuthStateType} from './authStateType'
 import {type AuthState, authStore} from './authStore'
 import {refreshStampedToken} from './refreshStampedToken'
 
+type LockGrantedCallback = (lock: Lock | null) => Promise<boolean>
+
+interface Lock {
+  name: string
+  mode: 'exclusive' | 'shared'
+}
+
+interface LockOptions {
+  mode: 'exclusive' | 'shared'
+}
+
 describe('refreshStampedToken', () => {
+  let mockStorage: Storage
+  let originalNavigator: typeof navigator
+  let subscriptions: Subscription[]
+
   beforeEach(() => {
-    // Clear mocks between tests
+    subscriptions = []
     vi.clearAllMocks()
-    // Use fake timers so we can simulate interval triggers instantly
-    vi.useFakeTimers()
+    originalNavigator = global.navigator
+    mockStorage = {
+      getItem: vi.fn(),
+      setItem: vi.fn(),
+      removeItem: vi.fn(),
+      clear: vi.fn(),
+      key: vi.fn(),
+      length: 0,
+    }
+    const mockLocks = {
+      request: vi.fn(
+        async (
+          _name: string,
+          _options: LockOptions | LockGrantedCallback,
+          callback?: LockGrantedCallback,
+        ) => {
+          const actualCallback = typeof _options === 'function' ? _options : callback
+          if (!actualCallback) return false
+          const mockLock: Lock = {name: 'mock-lock', mode: 'exclusive'}
+          try {
+            await new Promise((resolve) => setTimeout(resolve, 0))
+            await actualCallback(mockLock)
+            return true
+          } catch {
+            return false
+          }
+        },
+      ),
+      query: vi.fn(async () => ({held: [], pending: []})),
+    }
+    Object.defineProperty(global, 'navigator', {
+      value: {locks: mockLocks},
+      writable: true,
+    })
   })
 
-  afterEach(() => {
-    // Restore real timers
-    vi.useRealTimers()
+  afterEach(async () => {
+    subscriptions.forEach((sub) => sub.unsubscribe())
+    Object.defineProperty(global, 'navigator', {
+      value: originalNavigator,
+      writable: true,
+    })
+    await new Promise((resolve) => setImmediate(resolve))
   })
 
-  it('refreshes the token on interval (success scenario)', () => {
-    // Mock client so that .request(...) yields a new token
-    const mockClient = {
-      observable: {
-        request: vi.fn(() => of({token: 'sk-refreshed-token-st123'})),
-      },
-    }
-    const mockClientFactory = vi.fn().mockReturnValue(mockClient)
+  describe('dashboard context', () => {
+    it('refreshes the token immediately without using locks', async () => {
+      const mockClient = {
+        observable: {
+          request: vi.fn(() => of({token: 'sk-refreshed-token-st123'})),
+        },
+      }
+      const mockClientFactory = vi.fn().mockReturnValue(mockClient)
+      const instance = createSanityInstance({
+        projectId: 'p',
+        dataset: 'd',
+        auth: {clientFactory: mockClientFactory, storageArea: mockStorage},
+      })
+      const initialState = authStore.getInitialState(instance)
+      initialState.authState = {
+        type: AuthStateType.LOGGED_IN,
+        token: 'sk-initial-token-st123',
+        currentUser: null,
+      }
+      initialState.dashboardContext = {mode: 'test'}
+      const state = createStoreState(initialState)
+      const subscription = refreshStampedToken({state, instance})
+      subscriptions.push(subscription)
 
-    // Create an instance (similar to how you do in subscribeToStateAndFetchCurrentUser.test.ts)
-    const instance = createSanityInstance({
-      projectId: 'p',
-      dataset: 'd',
-      auth: {clientFactory: mockClientFactory},
+      // Wait briefly for state to settle
+      await new Promise((resolve) => setTimeout(resolve, 10))
+
+      // Check final state and essential negative assertions
+      const finalAuthStateDash = state.get().authState
+      expect(finalAuthStateDash.type).toBe(AuthStateType.LOGGED_IN)
+      if (finalAuthStateDash.type === AuthStateType.LOGGED_IN) {
+        expect(finalAuthStateDash.token).toBe('sk-refreshed-token-st123')
+      }
+      expect(navigator.locks.request).not.toHaveBeenCalled()
     })
+  })
 
-    // Create the initial state: logged in with some initial token
-    const initialState = authStore.getInitialState(instance)
-    // Force it to be logged in from the start
-    initialState.authState = {
-      type: AuthStateType.LOGGED_IN,
-      token: 'sk-initial-token-st123',
-      currentUser: null,
-    }
+  describe('non-dashboard context', () => {
+    it('uses Web Locks API to coordinate token refresh', async () => {
+      const mockClient = {
+        observable: {
+          request: vi.fn(() => of({token: 'sk-refreshed-token-st123'})),
+        },
+      }
+      const mockClientFactory = vi.fn().mockReturnValue(mockClient)
+      const instance = createSanityInstance({
+        projectId: 'p',
+        dataset: 'd',
+        auth: {clientFactory: mockClientFactory, storageArea: mockStorage},
+      })
+      const initialState = authStore.getInitialState(instance)
+      initialState.authState = {
+        type: AuthStateType.LOGGED_IN,
+        token: 'sk-initial-token-st123',
+        currentUser: null,
+      }
+      const state = createStoreState(initialState)
+      const subscription = refreshStampedToken({state, instance})
+      subscriptions.push(subscription)
 
-    // Create the resource state
-    const state = createResourceState(initialState)
+      // Wait briefly for state to settle
+      await new Promise((resolve) => setTimeout(resolve, 10))
 
-    // Call refreshStampedToken ONCE
-    // Because TParams is [], createInternalAction will call the inner function for us
-    const subscription: Subscription = refreshStampedToken({state, instance})
+      // Check final state and that lock was attempted
+      expect(navigator.locks.request).toHaveBeenCalled()
+      const finalAuthStateNonDash = state.get().authState
+      expect(finalAuthStateNonDash.type).toBe(AuthStateType.LOGGED_IN)
+      if (finalAuthStateNonDash.type === AuthStateType.LOGGED_IN) {
+        expect(finalAuthStateNonDash.token).toBe('sk-refreshed-token-st123')
+      }
+    })
 
-    // Advance time by 10 minutes so the interval fires
-    vi.advanceTimersByTime(10 * 60 * 1000)
+    it('skips refresh if lock cannot be acquired', async () => {
+      const mockLocks = {
+        request: vi.fn(async () => {
+          await new Promise((resolve) => setTimeout(resolve, 0))
+          return false
+        }),
+        query: vi.fn(async () => ({held: [], pending: []})),
+      }
+      Object.defineProperty(global, 'navigator', {value: {locks: mockLocks}, writable: true})
+      const mockClient = {
+        observable: {request: vi.fn(() => of({token: 'sk-refreshed-token-st123'}))},
+      }
+      const mockClientFactory = vi.fn().mockReturnValue(mockClient)
+      const instance = createSanityInstance({
+        projectId: 'p',
+        dataset: 'd',
+        auth: {clientFactory: mockClientFactory, storageArea: mockStorage},
+      })
+      const initialState = authStore.getInitialState(instance)
+      initialState.authState = {
+        type: AuthStateType.LOGGED_IN,
+        token: 'sk-initial-token-st123',
+        currentUser: null,
+      }
+      const state = createStoreState(initialState)
+      const subscription = refreshStampedToken({state, instance})
+      subscriptions.push(subscription)
 
-    // The client request should have been called once
-    expect(mockClient.observable.request).toHaveBeenCalledTimes(1)
-    // The token in state should now be 'refreshed-token'
-    expect(state.get().authState).toEqual({
-      type: AuthStateType.LOGGED_IN,
-      token: 'sk-refreshed-token-st123',
-      currentUser: null,
-    })
+      // Wait briefly
+      await new Promise((resolve) => setTimeout(resolve, 10))
 
-    // Cleanup
-    subscription.unsubscribe()
+      // Check lock was attempted, client request was NOT, and state is unchanged
+      expect(navigator.locks.request).toHaveBeenCalledTimes(1)
+      expect(mockClient.observable.request).not.toHaveBeenCalled()
+      expect(state.get().authState).toEqual({
+        type: AuthStateType.LOGGED_IN,
+        token: 'sk-initial-token-st123',
+        currentUser: null,
+      })
+    })
   })
 
-  it('sets an error state when token refresh fails', () => {
+  it('sets an error state when token refresh fails', async () => {
     const error = new Error('Refresh failed')
     const mockClient = {
       observable: {
@@ -79,99 +196,88 @@ describe('refreshStampedToken', () => {
     const instance = createSanityInstance({
       projectId: 'p',
       dataset: 'd',
-      auth: {clientFactory: mockClientFactory},
+      auth: {clientFactory: mockClientFactory, storageArea: mockStorage},
     })
-
-    // Start logged-in
     const initialState = authStore.getInitialState(instance)
     initialState.authState = {
       type: AuthStateType.LOGGED_IN,
       token: 'sk-initial-token-st123',
       currentUser: null,
     }
-    const state = createResourceState(initialState)
-
-    const subscription: Subscription = refreshStampedToken({state, instance})
+    initialState.dashboardContext = {mode: 'test'}
+    const state = createStoreState(initialState)
+    const subscription = refreshStampedToken({state, instance})
+    subscriptions.push(subscription)
 
-    // Move time forward to trigger the interval
-    vi.advanceTimersByTime(10 * 60 * 1000)
-
-    // Should have set an error state
-    expect(state.get().authState).toEqual({
-      type: AuthStateType.ERROR,
-      error,
-    })
+    // Wait briefly for state to settle
+    await new Promise((resolve) => setTimeout(resolve, 10))
 
-    subscription.unsubscribe()
+    // Check final state IS error
+    const finalAuthStateError = state.get().authState
+    expect(finalAuthStateError.type).toBe(AuthStateType.ERROR)
+    if (finalAuthStateError.type === AuthStateType.ERROR) {
+      expect(finalAuthStateError.error).toBe(error)
+    } else {
+      expect.fail('Expected authState type to be ERROR')
+    }
   })
 
-  it('does nothing if user is not logged in', () => {
+  it('does nothing if user is not logged in', async () => {
     const mockClientFactory = vi.fn()
     const instance = createSanityInstance({
       projectId: 'p',
       dataset: 'd',
       auth: {clientFactory: mockClientFactory},
     })
-
-    // Start logged out
     const initialState = authStore.getInitialState(instance)
     initialState.authState = {
       type: AuthStateType.LOGGED_OUT,
       isDestroyingSession: false,
     } as AuthState
-    const state = createResourceState(initialState)
-
-    const subscription: Subscription = refreshStampedToken({state, instance})
+    const state = createStoreState(initialState)
+    const subscription = refreshStampedToken({state, instance})
+    subscriptions.push(subscription)
 
-    // Move time forward
-    vi.advanceTimersByTime(10 * 60 * 1000)
+    // Wait briefly
+    await new Promise((resolve) => setTimeout(resolve, 10))
 
-    // No calls, no changes
+    // Check nothing happened
     expect(mockClientFactory).not.toHaveBeenCalled()
+    expect(navigator.locks.request).not.toHaveBeenCalled()
     expect(state.get().authState).toEqual({
       type: AuthStateType.LOGGED_OUT,
       isDestroyingSession: false,
     })
-
-    subscription.unsubscribe()
   })
 
-  it('does nothing if token is not stamped', () => {
-    const mockClient = {
-      observable: {
-        request: vi.fn(() => of({token: 'sk-nonstamped-token2'})),
-      },
-    }
+  it('does nothing if token is not stamped', async () => {
+    const mockClient = {observable: {request: vi.fn(() => of({token: 'sk-nonstamped-token2'}))}}
     const mockClientFactory = vi.fn().mockReturnValue(mockClient)
     const instance = createSanityInstance({
       projectId: 'p',
       dataset: 'd',
       auth: {clientFactory: mockClientFactory},
     })
-
-    // Start logged in with a non-stamped token
     const initialState = authStore.getInitialState(instance)
     initialState.authState = {
       type: AuthStateType.LOGGED_IN,
-      token: 'sk-nonstamped-token2', // Note: doesn't include '-st'
+      token: 'sk-nonstamped-token2',
       currentUser: null,
     }
-    const state = createResourceState(initialState)
-
-    const subscription: Subscription = refreshStampedToken({state, instance})
+    const state = createStoreState(initialState)
+    const subscription = refreshStampedToken({state, instance})
+    subscriptions.push(subscription)
 
-    // Move time forward
-    vi.advanceTimersByTime(10 * 60 * 1000)
+    // Wait briefly
+    await new Promise((resolve) => setTimeout(resolve, 10))
 
-    // No refresh should have happened
+    // Check nothing happened
     expect(mockClient.observable.request).not.toHaveBeenCalled()
-    // State should remain unchanged
+    expect(navigator.locks.request).not.toHaveBeenCalled()
     expect(state.get().authState).toEqual({
       type: AuthStateType.LOGGED_IN,
       token: 'sk-nonstamped-token2',
       currentUser: null,
     })
-
-    subscription.unsubscribe()
   })
 })