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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/sdk",
-  "version": "0.0.0-alpha.21",
+  "version": "0.0.0-alpha.23",
   "private": false,
   "description": "Sanity SDK",
   "keywords": [
@@ -55,16 +55,15 @@
   },
   "devDependencies": {
     "@sanity/browserslist-config": "^1.0.5",
-    "@sanity/pkg-utils": "^6.13.4",
+    "@sanity/pkg-utils": "^7.2.2",
     "@sanity/prettier-config": "^1.0.3",
-    "@sanity/types": "^3.79.0",
-    "@vitest/coverage-v8": "3.0.9",
+    "@vitest/coverage-v8": "3.1.1",
     "eslint": "^9.22.0",
     "groq-js": "^1.16.1",
     "prettier": "^3.5.3",
     "typescript": "^5.7.3",
-    "vite": "^6.2.2",
-    "vitest": "^3.0.9",
+    "vite": "^6.2.4",
+    "vitest": "^3.1.1",
     "@repo/config-eslint": "0.0.0",
     "@repo/config-test": "0.0.1",
     "@repo/package.config": "0.0.1",
@@ -80,7 +79,7 @@
     "build": "pkg build --strict --clean --check",
     "clean": "rimraf dist",
     "dev": "pkg watch",
-    "docs": "typedoc --out docs --tsconfig ../../tsconfig.tsdoc.json",
+    "docs": "typedoc --out docs --tsconfig ./tsconfig.dist.json",
     "format": "prettier --write --cache --ignore-unknown .",
     "lint": "eslint .",
     "test": "vitest run",

package/src/_exports/index.ts

@@ -1,4 +1,3 @@
-// Use import type to access the internal type and re-export it
 import {type SanityProject as _SanityProject} from '@sanity/client'
 
 /**
@@ -8,34 +7,40 @@ export type SanityProject = _SanityProject
 
 export {AuthStateType} from '../auth/authStateType'
 export {
-  type AuthConfig,
-  type AuthProvider,
   type AuthState,
   type AuthStoreState,
   type ErrorAuthState,
   getAuthState,
   getCurrentUserState,
   getDashboardOrganizationId,
-  getLoginUrlsState,
+  getLoginUrlState,
   getTokenState,
   type LoggedInAuthState,
   type LoggedOutAuthState,
   type LoggingInAuthState,
 } from '../auth/authStore'
-export {fetchLoginUrls} from '../auth/fetchLoginUrls'
 export {handleAuthCallback} from '../auth/handleAuthCallback'
 export {logout} from '../auth/logout'
-export type {ClientState} from '../client/clientStore'
+export type {ClientStoreState as ClientState} from '../client/clientStore'
 export {type ClientOptions, getClient, getClientState} from '../client/clientStore'
-export {destroyController} from '../comlink/controller/actions/destroyController'
-export {getOrCreateChannel} from '../comlink/controller/actions/getOrCreateChannel'
-export {getOrCreateController} from '../comlink/controller/actions/getOrCreateController'
-export {releaseChannel} from '../comlink/controller/actions/releaseChannel'
-export type {ComlinkControllerState} from '../comlink/controller/comlinkControllerStore'
-export {getOrCreateNode} from '../comlink/node/actions/getOrCreateNode'
-export {releaseNode} from '../comlink/node/actions/releaseNode'
+export {
+  type ComlinkControllerState,
+  destroyController,
+  getOrCreateChannel,
+  getOrCreateController,
+  releaseChannel,
+} from '../comlink/controller/comlinkControllerStore'
 export type {ComlinkNodeState} from '../comlink/node/comlinkNodeStore'
+export {getOrCreateNode, releaseNode} from '../comlink/node/comlinkNodeStore'
 export {type FrameMessage, type WindowMessage} from '../comlink/types'
+export {type AuthConfig, type AuthProvider} from '../config/authConfig'
+export {
+  type DatasetHandle,
+  type DocumentHandle,
+  type DocumentTypeHandle,
+  type ProjectHandle,
+  type SanityConfig,
+} from '../config/sanityConfig'
 export {getDatasetsState, resolveDatasets} from '../datasets/datasets'
 export {
   createDocument,
@@ -77,23 +82,14 @@ export {
   type TransactionAcceptedEvent,
   type TransactionRevertedEvent,
 } from '../document/events'
-export {
-  type DocumentHandle,
-  type DocumentTypeHandle,
-  type JsonMatch,
-  jsonMatch,
-  type JsonMatchPath,
-} from '../document/patchOperations'
-export {type DocumentResourceId, getResourceId, type ResourceId} from '../document/patchOperations'
+export {type JsonMatch, jsonMatch, type JsonMatchPath} from '../document/patchOperations'
 export {type DocumentPermissionsResult, type PermissionDeniedReason} from '../document/permissions'
-export {createSanityInstance} from '../instance/sanityInstance'
-export type {SanityConfig, SanityInstance, SdkIdentity} from '../instance/types'
 export {getPreviewState, type GetPreviewStateOptions} from '../preview/getPreviewState'
 export type {PreviewStoreState, PreviewValue, ValuePending} from '../preview/previewStore'
 export {resolvePreview, type ResolvePreviewOptions} from '../preview/resolvePreview'
 export {getProjectState, resolveProject} from '../project/project'
 export {getProjectionState} from '../projection/getProjectionState'
-export type {ProjectionValuePending, ValidProjection} from '../projection/projectionStore'
+export {type ProjectionValuePending, type ValidProjection} from '../projection/projectionStore'
 export {resolveProjection} from '../projection/resolveProjection'
 export {getProjectsState, resolveProjects} from '../projects/projects'
 export {
@@ -103,12 +99,17 @@ export {
   type QueryOptions,
   resolveQuery,
 } from '../query/queryStore'
-export {type ActionContext, type ResourceAction} from '../resources/createAction'
-export {type ResourceState} from '../resources/createResource'
-export type {StateSource} from '../resources/createStateSourceAction'
-export {type BoundResourceAction} from '../resources/createStore'
-export {type Membership, type ResourceType, type SanityUser, type UserProfile} from '../users/types'
-export {createUsersStore, type UsersStoreState} from '../users/usersStore'
+export {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
+export {type Selector, type StateSource} from '../store/createStateSourceAction'
+export {getUsersKey, parseUsersKey} from '../users/reducers'
+export {
+  type GetUsersOptions,
+  type Membership,
+  type ResolveUsersOptions,
+  type SanityUser,
+  type UserProfile,
+} from '../users/types'
+export {getUsersState, loadMoreUsers, resolveUsers} from '../users/usersStore'
 export {type FetcherStore, type FetcherStoreState} from '../utils/createFetcherStore'
 export {CORE_SDK_VERSION} from '../version'
 export type {CurrentUser, Role, SanityDocument, SanityDocumentLike} from '@sanity/types'

package/src/auth/authStore.test.ts

@@ -1,20 +1,19 @@
 import {type ClientConfig, createClient} from '@sanity/client'
 import {type CurrentUser} from '@sanity/types'
-import {type Subscription} from 'rxjs'
-import {beforeEach, describe, it} from 'vitest'
+import {NEVER, type Subscription} from 'rxjs'
+import {afterEach, beforeEach, describe, it} from 'vitest'
 
-import {createSanityInstance} from '../instance/sanityInstance'
-import {createResourceState, getOrCreateResource} from '../resources/createResource'
+import {createSanityInstance} from '../store/createSanityInstance'
 import {AuthStateType} from './authStateType'
 import {
   authStore,
-  type AuthStoreState,
   getAuthState,
   getCurrentUserState,
   getDashboardOrganizationId,
-  getLoginUrlsState,
+  getLoginUrlState,
   getTokenState,
 } from './authStore'
+import {handleAuthCallback} from './handleAuthCallback'
 import {subscribeToStateAndFetchCurrentUser} from './subscribeToStateAndFetchCurrentUser'
 import {subscribeToStorageEventsAndSetToken} from './subscribeToStorageEventsAndSetToken'
 import {getAuthCode, getTokenFromStorage} from './utils'
@@ -28,7 +27,25 @@ vi.mock('./subscribeToStateAndFetchCurrentUser')
 vi.mock('./subscribeToStorageEventsAndSetToken')
 
 describe('authStore', () => {
+  // Global beforeEach and afterEach for all tests
+  beforeEach(() => {
+    vi.resetAllMocks()
+    vi.mocked(subscribeToStateAndFetchCurrentUser).mockImplementation(() => NEVER.subscribe())
+    vi.mocked(subscribeToStorageEventsAndSetToken).mockImplementation(() => NEVER.subscribe())
+  })
+
   describe('getInitialState', () => {
+    let instance: ReturnType<typeof createSanityInstance>
+
+    beforeEach(() => {
+      vi.mocked(getTokenFromStorage).mockReturnValue(null)
+      vi.mocked(getAuthCode).mockReturnValue(null)
+    })
+
+    afterEach(() => {
+      instance?.dispose()
+    })
+
     it('sets initial options onto state', () => {
       const apiHost = 'test-api-host'
       const callbackUrl = '/login/callback'
@@ -40,7 +57,7 @@ describe('authStore', () => {
       const initialLocationHref = 'https://example.com'
       const storageArea = {} as Storage
 
-      const instance = createSanityInstance({
+      instance = createSanityInstance({
         projectId: 'p',
         dataset: 'd',
         auth: {
@@ -54,8 +71,6 @@ describe('authStore', () => {
         },
       })
 
-      vi.mocked(getTokenFromStorage).mockReturnValue(null)
-
       const {options} = authStore.getInitialState(instance)
 
       expect(options.apiHost).toBe(apiHost)
@@ -69,7 +84,7 @@ describe('authStore', () => {
     })
 
     it('sets to logged in if provided token is present', () => {
-      const instance = createSanityInstance({
+      instance = createSanityInstance({
         projectId: 'p',
         dataset: 'd',
         auth: {
@@ -82,7 +97,7 @@ describe('authStore', () => {
     })
 
     it('sets to logging in if `getAuthCode` returns a code', () => {
-      const instance = createSanityInstance({
+      instance = createSanityInstance({
         projectId: 'p',
         dataset: 'd',
       })
@@ -94,7 +109,7 @@ describe('authStore', () => {
     })
 
     it('sets to logged in if `getTokenFromStorage` returns a token', () => {
-      const instance = createSanityInstance({
+      instance = createSanityInstance({
         projectId: 'p',
         dataset: 'd',
       })
@@ -107,7 +122,7 @@ describe('authStore', () => {
     })
 
     it('otherwise it sets the state to logged out', () => {
-      const instance = createSanityInstance({
+      instance = createSanityInstance({
         projectId: 'p',
         dataset: 'd',
       })
@@ -122,9 +137,11 @@ describe('authStore', () => {
 
   describe('initialize', () => {
     let mockLocalStorage: Storage
+    let instance: ReturnType<typeof createSanityInstance>
+    let stateUnsubscribe: ReturnType<typeof vi.fn>
+    let storageEventsUnsubscribe: ReturnType<typeof vi.fn>
 
     beforeEach(() => {
-      vi.clearAllMocks()
       // Create fresh mock localStorage for each test
       mockLocalStorage = {
         getItem: vi.fn(),
@@ -138,26 +155,29 @@ describe('authStore', () => {
           return Storage
         },
       } as unknown as Storage
-    })
 
-    it('subscribes to state and storage events and unsubscribes on dispose', () => {
-      const instance = createSanityInstance({
-        projectId: 'p123abc',
-        dataset: 'production',
-        auth: {
-          storageArea: mockLocalStorage,
-        },
-      })
+      stateUnsubscribe = vi.fn()
+      storageEventsUnsubscribe = vi.fn()
 
-      const stateUnsubscribe = vi.fn()
       vi.mocked(subscribeToStateAndFetchCurrentUser).mockReturnValue({
         unsubscribe: stateUnsubscribe,
       } as unknown as Subscription)
 
-      const storageEventsUnsubscribe = vi.fn()
       vi.mocked(subscribeToStorageEventsAndSetToken).mockReturnValue({
         unsubscribe: storageEventsUnsubscribe,
       } as unknown as Subscription)
+    })
+
+    afterEach(() => {
+      instance?.dispose()
+    })
+
+    it('subscribes to state and storage events and unsubscribes on dispose', () => {
+      instance = createSanityInstance({
+        projectId: 'p',
+        dataset: 'd',
+        auth: {storageArea: mockLocalStorage},
+      })
 
       Object.defineProperty(mockLocalStorage, 'constructor', {
         get: () => Storage,
@@ -166,7 +186,8 @@ describe('authStore', () => {
       expect(subscribeToStateAndFetchCurrentUser).not.toHaveBeenCalled()
       expect(subscribeToStorageEventsAndSetToken).not.toHaveBeenCalled()
 
-      getOrCreateResource(instance, authStore)
+      // call a bound action to lazily create the store
+      getAuthState(instance)
 
       expect(subscribeToStateAndFetchCurrentUser).toHaveBeenCalled()
       expect(subscribeToStorageEventsAndSetToken).toHaveBeenCalled()
@@ -178,25 +199,13 @@ describe('authStore', () => {
     })
 
     it('does not subscribe to storage events when not using storage area', () => {
-      const instance = createSanityInstance({
-        projectId: 'p123abc',
-        dataset: 'production',
-        auth: {
-          storageArea: undefined,
-        },
+      instance = createSanityInstance({
+        projectId: 'p',
+        dataset: 'd',
+        auth: {storageArea: undefined},
       })
 
-      const stateUnsubscribe = vi.fn()
-      vi.mocked(subscribeToStateAndFetchCurrentUser).mockReturnValue({
-        unsubscribe: stateUnsubscribe,
-      } as unknown as Subscription)
-
-      const storageEventsUnsubscribe = vi.fn()
-      vi.mocked(subscribeToStorageEventsAndSetToken).mockReturnValue({
-        unsubscribe: storageEventsUnsubscribe,
-      } as unknown as Subscription)
-
-      getOrCreateResource(instance, authStore)
+      getAuthState(instance)
 
       expect(subscribeToStateAndFetchCurrentUser).toHaveBeenCalled()
       expect(subscribeToStorageEventsAndSetToken).not.toHaveBeenCalled()
@@ -209,43 +218,60 @@ describe('authStore', () => {
   })
 
   describe('getCurrentUserState', () => {
-    it('returns the current user if logged in and current user is non-null', () => {
-      const currentUser = {id: 'example-user'} as CurrentUser
-      const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
-      const state = createResourceState<AuthStoreState>({
-        authState: {type: AuthStateType.LOGGED_IN, token: 'new-token', currentUser},
-      } as AuthStoreState)
+    let instance: ReturnType<typeof createSanityInstance>
+    let currentUser: CurrentUser
 
-      const currentUserState = getCurrentUserState({instance, state})
-      expect(currentUserState.getCurrent()).toBe(currentUser)
+    beforeEach(() => {
+      currentUser = {id: 'example-user'} as CurrentUser
+    })
 
-      // pureness check
-      expect(currentUserState.getCurrent()).toBe(currentUserState.getCurrent())
+    afterEach(() => {
+      instance?.dispose()
     })
 
-    it('returns null otherwise', () => {
-      const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
-      const state = createResourceState<AuthStoreState>({
-        authState: {type: AuthStateType.LOGGED_OUT},
-      } as AuthStoreState)
+    it('returns the current user if logged in and current user is non-null', () => {
+      vi.mocked(subscribeToStateAndFetchCurrentUser).mockImplementation(({state}) => {
+        state.set('setCurrentUser', {
+          authState: {
+            type: AuthStateType.LOGGED_IN,
+            token: 'token',
+            currentUser,
+          },
+        })
+
+        return NEVER.subscribe()
+      })
+
+      instance = createSanityInstance({projectId: 'p', dataset: 'd'})
 
-      const currentUserState = getCurrentUserState({instance, state})
-      expect(currentUserState.getCurrent()).toBe(null)
+      const {getCurrent} = getCurrentUserState(instance)
 
       // pureness check
-      expect(currentUserState.getCurrent()).toBe(currentUserState.getCurrent())
+      expect(getCurrent()).toBe(getCurrent())
+    })
+
+    it('returns null otherwise', () => {
+      instance = createSanityInstance({projectId: 'p', dataset: 'd'})
+      const {getCurrent} = getCurrentUserState(instance)
+      expect(getCurrent()).toBe(null)
     })
   })
 
   describe('getTokenState', () => {
-    it('returns the token if logged in', () => {
-      const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
-      const token = 'new-token'
-      const state = createResourceState<AuthStoreState>({
-        authState: {type: AuthStateType.LOGGED_IN, token},
-      } as AuthStoreState)
+    let instance: ReturnType<typeof createSanityInstance>
+
+    afterEach(() => {
+      instance?.dispose()
+    })
 
-      const tokenState = getTokenState({instance, state})
+    it('returns the token if logged in', () => {
+      const token = 'hard-coded-token'
+      instance = createSanityInstance({
+        projectId: 'p',
+        dataset: 'd',
+        auth: {token},
+      })
+      const tokenState = getTokenState(instance)
       expect(tokenState.getCurrent()).toBe(token)
 
       // pureness check
@@ -253,12 +279,9 @@ describe('authStore', () => {
     })
 
     it('returns null otherwise', () => {
-      const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
-      const state = createResourceState<AuthStoreState>({
-        authState: {type: AuthStateType.ERROR, error: new Error('test error')},
-      } as AuthStoreState)
+      instance = createSanityInstance({projectId: 'p', dataset: 'd'})
 
-      const tokenState = getTokenState({instance, state})
+      const tokenState = getTokenState(instance)
       expect(tokenState.getCurrent()).toBe(null)
 
       // pureness check
@@ -267,55 +290,77 @@ describe('authStore', () => {
   })
 
   describe('getLoginUrlsState', () => {
-    it('returns the cached auth providers if present', () => {
-      const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
-      const providers = [{name: 'test', title: 'Test', url: 'https://example.com#withSid=true'}]
-      const state = createResourceState<AuthStoreState>({providers} as AuthStoreState)
+    let instance: ReturnType<typeof createSanityInstance>
 
-      const loginUrlsState = getLoginUrlsState({instance, state})
-      expect(loginUrlsState.getCurrent()).toBe(providers)
-
-      // pureness check
-      expect(loginUrlsState.getCurrent()).toBe(loginUrlsState.getCurrent())
+    afterEach(() => {
+      instance?.dispose()
     })
 
-    it('returns nulls otherwise', () => {
-      const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
-      const state = createResourceState<AuthStoreState>({} as AuthStoreState)
-
-      const loginUrlsState = getLoginUrlsState({instance, state})
-      expect(loginUrlsState.getCurrent()).toBe(null)
+    it('returns the default login url', () => {
+      instance = createSanityInstance({projectId: 'p', dataset: 'd'})
 
-      // pureness check
-      expect(loginUrlsState.getCurrent()).toBe(loginUrlsState.getCurrent())
+      const loginUrlState = getLoginUrlState(instance)
+      expect(loginUrlState.getCurrent()).toBe(
+        'https://www.sanity.io/login?origin=http%3A%2F%2Flocalhost&type=stampedToken&withSid=true',
+      )
     })
   })
 
   describe('getAuthState', () => {
+    let instance: ReturnType<typeof createSanityInstance>
+
+    afterEach(() => {
+      instance?.dispose()
+    })
+
     it('returns the current state in `authState`', () => {
-      const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
-      const authState: AuthStoreState['authState'] = {
-        type: AuthStateType.LOGGED_OUT,
-        isDestroyingSession: false,
-      }
-      const state = createResourceState<AuthStoreState>({authState} as AuthStoreState)
+      instance = createSanityInstance({
+        projectId: 'p',
+        dataset: 'd',
+        auth: {token: 'hard-coded-token'},
+      })
 
-      const authStateSource = getAuthState({instance, state})
-      expect(authStateSource.getCurrent()).toBe(authState)
+      const {getCurrent} = getAuthState(instance)
+      expect(getCurrent()).toEqual({
+        currentUser: null,
+        token: 'hard-coded-token',
+        type: 'logged-in',
+      })
 
       // pureness check
-      expect(authStateSource.getCurrent()).toBe(authStateSource.getCurrent())
+      expect(getCurrent()).toBe(getCurrent())
     })
   })
 
   describe('getDashboardOrganizationId', () => {
+    let instance: ReturnType<typeof createSanityInstance>
+
+    beforeEach(() => {
+      vi.mocked(getAuthCode).mockReturnValue('test-auth-code')
+    })
+
+    afterEach(() => {
+      instance?.dispose()
+    })
+
     it('returns the organization id if present', () => {
-      const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
-      const state = createResourceState<AuthStoreState>({
-        dashboardContext: {orgId: 'org-id'},
-      } as AuthStoreState)
+      instance = createSanityInstance({
+        projectId: 'p',
+        dataset: 'd',
+        auth: {
+          clientFactory: vi.fn().mockReturnValue({
+            request: vi.fn().mockResolvedValue({token: 'test-token', label: 'tes'}),
+          }),
+        },
+      })
+
+      // Create a URL with an organization ID in the _context parameter
+      const callbackUrl = `https://example.com/login/callback?sid=test-auth-code&_context=${encodeURIComponent(JSON.stringify({orgId: 'org-id'}))}`
+
+      // Call handleCallback with the URL to set the organization ID in the state
+      handleAuthCallback(instance, callbackUrl)
 
-      const organizationId = getDashboardOrganizationId({instance, state})
+      const organizationId = getDashboardOrganizationId(instance)
       expect(organizationId.getCurrent()).toBe('org-id')
     })
   })