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

package/src/auth/getOrganizationVerificationState.test.ts

@@ -1,4 +1,4 @@
-import {type Observable} from 'rxjs'
+import {map, type Observable} from 'rxjs'
 import {TestScheduler} from 'rxjs/testing'
 import {beforeEach, describe, expect, it, vi} from 'vitest'
 
@@ -6,7 +6,7 @@ import {
   compareProjectOrganization,
   type OrgVerificationResult,
 } from '../project/organizationVerification'
-import {getProjectState} from '../project/project'
+import {project} from '../project/project'
 import {type SanityInstance} from '../store/createSanityInstance'
 import {type StateSource} from '../store/createStateSourceAction'
 import {getDashboardOrganizationId} from './dashboardUtils'
@@ -17,7 +17,7 @@ vi.mock('./dashboardUtils', () => ({
   getDashboardOrganizationId: vi.fn(),
 }))
 vi.mock('../project/project', () => ({
-  getProjectState: vi.fn(),
+  project: {getState: vi.fn()},
 }))
 // Mock the comparison function to check its inputs
 vi.mock('../project/organizationVerification', async (importOriginal) => {
@@ -32,10 +32,10 @@ vi.mock('../project/organizationVerification', async (importOriginal) => {
 describe('observeOrganizationVerificationState', () => {
   let testScheduler: TestScheduler
 
-  // Mock instance with studio.projectId
+  // Mock instance (only config.projectId is used)
   const mockInstance = {
-    config: {studio: {projectId: 'proj-1'}},
-  } as unknown as SanityInstance
+    config: {projectId: 'proj-1', dataset: 'd'},
+  } as SanityInstance
 
   beforeEach(() => {
     testScheduler = new TestScheduler((actual, expected) => {
@@ -54,11 +54,11 @@ describe('observeOrganizationVerificationState', () => {
     } as any) // Cast to any to bypass strict type checking in mock
   }
 
-  // Helper to mock getProjectState
+  // Helper to mock the project fetcher's state; wraps plain values in the snapshot envelope
   const mockProjectOrgId = (observable: Observable<{organizationId: string | null} | null>) => {
-    vi.mocked(getProjectState).mockReturnValue({
+    vi.mocked(project.getState).mockReturnValue({
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      observable: observable as any, // Cast needed due to complex type
+      observable: observable.pipe(map((value) => ({data: value ?? undefined}))) as any,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
     } as StateSource<any>)
   }
@@ -80,17 +80,18 @@ describe('observeOrganizationVerificationState', () => {
       const expectedValues = {a: {error: null}}
 
       const result$ = observeOrganizationVerificationState(mockInstance, [
-        mockInstance.config.studio!.projectId!,
+        mockInstance.config.projectId!,
       ])
       expectObservable(result$).toBe(expectedMarble, expectedValues)
     })
     expect(compareProjectOrganization).not.toHaveBeenCalled()
   })
 
-  it('should emit {error: null} if instance has no default source projectId', () => {
+  it('should emit {error: null} if instance.config.projectId is missing', () => {
     const instanceWithoutProjectId = {
-      config: {auth: {}},
-    } as unknown as SanityInstance
+      config: {projectId: undefined, dataset: 'd'},
+      // Add other required properties if SanityInstance type needs them
+    } as SanityInstance
 
     testScheduler.run(({hot, expectObservable}) => {
       // Dashboard org ID doesn't matter much here, but provide one
@@ -109,7 +110,7 @@ describe('observeOrganizationVerificationState', () => {
       expectObservable(result$).toBe(expectedMarble, expectedValues)
     })
     // No project fetch or comparison should occur
-    expect(getProjectState).not.toHaveBeenCalled()
+    expect(project.getState).not.toHaveBeenCalled()
     expect(compareProjectOrganization).not.toHaveBeenCalled()
   })
 
@@ -138,7 +139,7 @@ describe('observeOrganizationVerificationState', () => {
       const expectedValues = {r: {error: null}} // Expect null error
 
       const result$ = observeOrganizationVerificationState(mockInstance, [
-        mockInstance.config.studio!.projectId!,
+        mockInstance.config.projectId!,
       ])
       expectObservable(result$).toBe(expectedMarble, expectedValues)
     })
@@ -162,7 +163,7 @@ describe('observeOrganizationVerificationState', () => {
       const expectedValues = {r: comparisonResult}
 
       const result$ = observeOrganizationVerificationState(mockInstance, [
-        mockInstance.config.studio!.projectId!,
+        mockInstance.config.projectId!,
       ])
       expectObservable(result$).toBe(expectedMarble, expectedValues)
     })
@@ -186,7 +187,7 @@ describe('observeOrganizationVerificationState', () => {
       const expectedValues = {r: comparisonResult}
 
       const result$ = observeOrganizationVerificationState(mockInstance, [
-        mockInstance.config.studio!.projectId!,
+        mockInstance.config.projectId!,
       ])
       expectObservable(result$).toBe(expectedMarble, expectedValues)
     })

package/src/auth/getOrganizationVerificationState.ts

@@ -4,14 +4,14 @@ import {
   compareProjectOrganization,
   type OrgVerificationResult,
 } from '../project/organizationVerification'
-import {getProjectState} from '../project/project'
+import {project} from '../project/project'
 import {type SanityInstance} from '../store/createSanityInstance'
 import {getDashboardOrganizationId} from './dashboardUtils'
 
 /**
  * Creates an observable that emits the organization verification state for a given instance.
  * It combines the dashboard organization ID (from auth context) with the
- * project's actual organization ID (fetched via getProjectState) and compares them.
+ * project's actual organization ID (fetched via the project fetcher) and compares them.
  * @public
  */
 export function observeOrganizationVerificationState(
@@ -24,8 +24,8 @@ export function observeOrganizationVerificationState(
 
   // Create observables for each project's org ID
   const projectOrgIdObservables = projectIds.map((id) =>
-    getProjectState(instance, {projectId: id}).observable.pipe(
-      map((project) => ({projectId: id, orgId: project?.organizationId ?? null})),
+    project.getState(instance, {projectId: id}).observable.pipe(
+      map((snapshot) => ({projectId: id, orgId: snapshot.data?.organizationId ?? null})),
       // Ensure we only proceed if the orgId is loaded, distinct prevents unnecessary checks
       distinctUntilChanged((prev, curr) => prev.orgId === curr.orgId),
     ),

package/src/auth/handleAuthCallback.test.ts

@@ -1,5 +1,5 @@
 import {NEVER} from 'rxjs'
-import {beforeEach, describe, it} from 'vitest'
+import {beforeEach, describe, expect, it, vi} from 'vitest'
 
 import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
 import {AuthStateType} from './authStateType'
@@ -22,6 +22,25 @@ vi.mock('./utils', async (importOriginal) => {
 vi.mock('./subscribeToStateAndFetchCurrentUser')
 vi.mock('./subscribeToStorageEventsAndSetToken')
 
+// Mock logger to prevent actual logging during tests
+vi.mock('../utils/logger', async (importOriginal) => {
+  const original = await importOriginal<typeof import('../utils/logger')>()
+  return {
+    ...original,
+    createLogger: vi.fn(() => ({
+      info: vi.fn(),
+      debug: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      trace: vi.fn(),
+    })),
+  }
+})
+
+// Import createLogger after mocking
+// eslint-disable-next-line import-x/first
+import {createLogger} from '../utils/logger'
+
 let instance: SanityInstance | undefined
 
 describe('handleCallback', () => {
@@ -44,6 +63,8 @@ describe('handleCallback', () => {
     vi.mocked(getAuthCode).mockReturnValue(authCode)
 
     instance = createSanityInstance({
+      projectId: 'p',
+      dataset: 'd',
       auth: {
         clientFactory,
         storageArea: {setItem} as unknown as Storage,
@@ -87,6 +108,8 @@ describe('handleCallback', () => {
     vi.mocked(getAuthCode).mockReturnValue(authCode)
 
     instance = createSanityInstance({
+      projectId: 'p',
+      dataset: 'd',
       auth: {
         clientFactory,
         storageArea: {setItem} as unknown as Storage,
@@ -115,6 +138,8 @@ describe('handleCallback', () => {
     const setItem = vi.fn()
 
     instance = createSanityInstance({
+      projectId: 'p',
+      dataset: 'd',
       auth: {
         clientFactory,
         storageArea: {setItem: setItem as Storage['setItem']} as Storage,
@@ -155,6 +180,8 @@ describe('handleCallback', () => {
     const setItem = vi.fn()
 
     instance = createSanityInstance({
+      projectId: 'p',
+      dataset: 'd',
       auth: {
         clientFactory,
         storageArea: {setItem} as unknown as Storage,
@@ -182,6 +209,8 @@ describe('handleCallback', () => {
     vi.mocked(getAuthCode).mockReturnValue(authCode)
 
     instance = createSanityInstance({
+      projectId: 'p',
+      dataset: 'd',
       auth: {
         clientFactory,
         storageArea: {setItem} as unknown as Storage,
@@ -219,6 +248,8 @@ describe('handleCallback', () => {
     vi.mocked(getTokenFromLocation).mockReturnValue('hash-token')
 
     instance = createSanityInstance({
+      projectId: 'p',
+      dataset: 'd',
       auth: {
         clientFactory,
         storageArea: {setItem} as unknown as Storage,
@@ -242,5 +273,8 @@ describe('handleCallback', () => {
     })
     expect(clientFactory).not.toHaveBeenCalled()
     expect(setItem).not.toHaveBeenCalled()
+
+    // Verify logger was called
+    expect(createLogger).toHaveBeenCalled()
   })
 })

package/src/auth/handleAuthCallback.ts

@@ -1,5 +1,6 @@
 import {bindActionGlobally} from '../store/createActionBinder'
 import {DEFAULT_API_VERSION, REQUEST_TAG_PREFIX} from './authConstants'
+import {getAuthLogger} from './authLogger'
 import {AuthStateType} from './authStateType'
 import {authStore, type AuthStoreState, type DashboardContext} from './authStore'
 import {
@@ -15,16 +16,24 @@ import {
  */
 export const handleAuthCallback = bindActionGlobally(
   authStore,
-  async ({state}, locationHref: string = getDefaultLocation()) => {
+  async ({state, instance}, locationHref: string = getDefaultLocation()) => {
+    const logger = getAuthLogger(instance)
+
     const {providedToken, callbackUrl, clientFactory, apiHost, storageArea, storageKey} =
       state.get().options
 
     // If a token is provided, no need to handle callback
-    if (providedToken) return false
+    if (providedToken) {
+      logger.debug('Skipping auth callback - token already provided')
+      return false
+    }
 
     // Don't handle the callback if already in flight.
     const {authState} = state.get()
-    if (authState.type === AuthStateType.LOGGING_IN && authState.isExchangingToken) return false
+    if (authState.type === AuthStateType.LOGGING_IN && authState.isExchangingToken) {
+      logger.debug('Skipping auth callback - token exchange already in progress')
+      return false
+    }
 
     // Prepare the cleaned-up URL early. It will be returned on both success and error if an authCode/token was processed.
     const cleanedUrl = getCleanedUrl(locationHref)
@@ -32,6 +41,7 @@ export const handleAuthCallback = bindActionGlobally(
     // Check if there is a token in the is in the Dashboard iframe url hash
     const tokenFromUrl = getTokenFromLocation(locationHref)
     if (tokenFromUrl) {
+      logger.info('Auth token found in URL, logging in')
       state.set('setTokenFromUrl', {
         authState: createLoggedInAuthState(tokenFromUrl, null),
       })
@@ -40,7 +50,10 @@ export const handleAuthCallback = bindActionGlobally(
 
     // If there is no matching `authCode` then we can't handle the callback
     const authCode = getAuthCode(callbackUrl, locationHref)
-    if (!authCode) return false
+    if (!authCode) {
+      logger.debug('No auth code found in callback URL')
+      return false
+    }
 
     // Get the SanityOS dashboard context from the url
     const parsedUrl = new URL(locationHref)
@@ -52,15 +65,18 @@ export const handleAuthCallback = bindActionGlobally(
         if (parsedContext && typeof parsedContext === 'object') {
           delete parsedContext.sid
           dashboardContext = parsedContext
+          logger.debug('Dashboard context parsed from callback URL', {
+            hasDashboardContext: true,
+          })
         }
       }
     } catch (err) {
       // If JSON parsing fails, use empty context
-      // eslint-disable-next-line no-console
-      console.error('Failed to parse dashboard context:', err)
+      logger.warn('Failed to parse dashboard context from callback URL', {error: err})
     }
 
     // Otherwise, start the exchange
+    logger.info('Exchanging auth code for token')
     state.set('exchangeSessionForToken', {
       authState: {type: AuthStateType.LOGGING_IN, isExchangingToken: true},
       dashboardContext,
@@ -75,6 +91,7 @@ export const handleAuthCallback = bindActionGlobally(
         ...(apiHost && {apiHost}),
       })
 
+      logger.debug('Fetching token from auth endpoint')
       const {token} = await client.request<{token: string; label: string}>({
         method: 'GET',
         uri: '/auth/fetch',
@@ -82,11 +99,13 @@ export const handleAuthCallback = bindActionGlobally(
         tag: 'fetch-token',
       })
 
+      logger.info('Auth token obtained successfully, user logged in')
       storageArea?.setItem(storageKey, JSON.stringify({token}))
       state.set('setToken', {authState: createLoggedInAuthState(token, null)})
 
       return cleanedUrl
     } catch (error) {
+      logger.error('Failed to exchange auth code for token', {error})
       state.set('exchangeSessionForTokenError', {authState: {type: AuthStateType.ERROR, error}})
       return cleanedUrl
     }

package/src/auth/logout.test.ts

@@ -1,5 +1,5 @@
 import {NEVER} from 'rxjs'
-import {describe, it} from 'vitest'
+import {describe, expect, it, vi} from 'vitest'
 
 import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
 import {AuthStateType} from './authStateType'
@@ -17,9 +17,25 @@ vi.mock('./utils', async (importOriginal) => {
 vi.mock('./subscribeToStateAndFetchCurrentUser')
 vi.mock('./subscribeToStorageEventsAndSetToken')
 
+// Mock logger to prevent actual logging during tests
+vi.mock('../utils/logger', async (importOriginal) => {
+  const original = await importOriginal<typeof import('../utils/logger')>()
+  return {
+    ...original,
+    createLogger: vi.fn(() => ({
+      info: vi.fn(),
+      debug: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      trace: vi.fn(),
+    })),
+  }
+})
+
 let instance: SanityInstance | undefined
 
 beforeEach(() => {
+  vi.clearAllMocks()
   vi.mocked(subscribeToStateAndFetchCurrentUser).mockImplementation(() => NEVER.subscribe())
   vi.mocked(subscribeToStorageEventsAndSetToken).mockImplementation(() => NEVER.subscribe())
 })
@@ -36,6 +52,8 @@ describe('logout', () => {
     const removeItem = vi.fn() as Storage['removeItem']
 
     instance = createSanityInstance({
+      projectId: 'p',
+      dataset: 'd',
       auth: {
         clientFactory,
         storageArea: {removeItem} as Storage,
@@ -57,7 +75,7 @@ describe('logout', () => {
       useProjectHostname: false,
       useCdn: false,
     })
-    expect(mockRequest).toHaveBeenCalledWith({method: 'POST', uri: '/auth/logout'})
+    expect(mockRequest).toHaveBeenCalledWith({method: 'POST', uri: '/auth/logout', tag: 'logout'})
     expect(removeItem).toHaveBeenCalledWith('__sanity_auth_token')
   })
 
@@ -65,6 +83,8 @@ describe('logout', () => {
     const clientFactory = vi.fn()
     const removeItem = vi.fn() as Storage['removeItem']
     instance = createSanityInstance({
+      projectId: 'p',
+      dataset: 'd',
       auth: {
         token: 'provided-token',
         clientFactory,
@@ -89,6 +109,8 @@ describe('logout', () => {
     vi.mocked(getTokenFromStorage).mockReturnValue('token')
 
     instance = createSanityInstance({
+      projectId: 'p',
+      dataset: 'd',
       auth: {
         clientFactory,
         storageArea: {removeItem} as Storage,
@@ -115,4 +137,55 @@ describe('logout', () => {
     await originalLogout
     expect(removeItem).toHaveBeenCalledTimes(2)
   })
+
+  it('handles logout when already logged out', async () => {
+    vi.mocked(getTokenFromStorage).mockReturnValue(null)
+    const mockRequest = vi.fn()
+    const clientFactory = vi.fn().mockReturnValue({request: mockRequest})
+    const removeItem = vi.fn() as Storage['removeItem']
+
+    instance = createSanityInstance({
+      projectId: 'p',
+      dataset: 'd',
+      auth: {
+        clientFactory,
+        storageArea: {removeItem} as Storage,
+      },
+    })
+
+    const authState = getAuthState(instance)
+    expect(authState.getCurrent()).toMatchObject({type: AuthStateType.LOGGED_OUT})
+
+    await logout(instance)
+
+    // Should not make API call when already logged out
+    expect(clientFactory).not.toHaveBeenCalled()
+    expect(mockRequest).not.toHaveBeenCalled()
+
+    // Should still clean up storage
+    expect(removeItem).toHaveBeenCalledWith('__sanity_auth_token')
+  })
+
+  it('cleans up storage even if logout request fails', async () => {
+    vi.mocked(getTokenFromStorage).mockReturnValue('token')
+    const error = new Error('Logout request failed')
+    const mockRequest = vi.fn().mockRejectedValue(error)
+    const clientFactory = vi.fn().mockReturnValue({request: mockRequest})
+    const removeItem = vi.fn() as Storage['removeItem']
+
+    instance = createSanityInstance({
+      projectId: 'p',
+      dataset: 'd',
+      auth: {
+        clientFactory,
+        storageArea: {removeItem} as Storage,
+      },
+    })
+
+    // logout rejects when the request fails, matching the pre-logging behavior
+    await expect(logout(instance)).rejects.toThrow('Logout request failed')
+
+    // Should still clean up storage even on error
+    expect(removeItem).toHaveBeenCalledWith('__sanity_auth_token')
+  })
 })

package/src/auth/logout.ts

@@ -1,25 +1,35 @@
 import {bindActionGlobally} from '../store/createActionBinder'
 import {DEFAULT_API_VERSION, REQUEST_TAG_PREFIX} from './authConstants'
+import {getAuthLogger} from './authLogger'
 import {AuthStateType} from './authStateType'
 import {authStore} from './authStore'
 
 /**
  * @public
  */
-export const logout = bindActionGlobally(authStore, async ({state}) => {
+export const logout = bindActionGlobally(authStore, async ({state, instance}) => {
+  const logger = getAuthLogger(instance)
+
   const {clientFactory, apiHost, providedToken, storageArea, storageKey} = state.get().options
 
   // If a token is statically provided, logout does nothing
-  if (providedToken) return
+  if (providedToken) {
+    logger.debug('Skipping logout - token is statically provided')
+    return
+  }
 
   const {authState} = state.get()
 
   // If we already have an inflight request, no-op
-  if (authState.type === AuthStateType.LOGGED_OUT && authState.isDestroyingSession) return
+  if (authState.type === AuthStateType.LOGGED_OUT && authState.isDestroyingSession) {
+    logger.debug('Skipping logout - already in progress')
+    return
+  }
   const token = authState.type === AuthStateType.LOGGED_IN && authState.token
 
   try {
     if (token) {
+      logger.info('Logging out user')
       state.set('loggingOut', {
         authState: {type: AuthStateType.LOGGED_OUT, isDestroyingSession: true},
       })
@@ -33,9 +43,18 @@ export const logout = bindActionGlobally(authStore, async ({state}) => {
         useCdn: false,
       })
 
-      await client.request<void>({uri: '/auth/logout', method: 'POST'})
+      logger.debug('Calling logout endpoint')
+      await client.request<void>({uri: '/auth/logout', method: 'POST', tag: 'logout'})
+    } else {
+      logger.debug('No token to logout - already logged out')
     }
+  } catch (error) {
+    // Re-throw to preserve the existing contract: logout rejects when the
+    // request fails. Local state is still cleared in the finally block.
+    logger.error('Logout request failed', {error})
+    throw error
   } finally {
+    logger.info('User logged out, clearing stored tokens')
     state.set('logoutSuccess', {
       authState: {type: AuthStateType.LOGGED_OUT, isDestroyingSession: false},
     })