@sanity/sdk 2.9.0 → 2.10.0

package/src/document/processActions.ts

@@ -7,9 +7,9 @@ import {
   type SanityDocument,
 } from '@sanity/types'
 import {evaluateSync, type ExprNode} from 'groq-js'
-import {isEqual} from 'lodash-es'
 
 import {isReleasePerspective} from '../releases/utils/isReleasePerspective'
+import {isDeepEqual} from '../utils/object'
 import {type DocumentAction} from './actions'
 import {type Grant} from './permissions'
 import {type DocumentSet, getId, processMutations} from './processMutations'
@@ -568,7 +568,7 @@ export function processActions({
 
         // Before proceeding, verify that the working draft is identical to the base draft.
         // TODO: is it enough just to check for the _rev or nah?
-        if (!isEqual(workingDraft, baseDraft)) {
+        if (!isDeepEqual(workingDraft, baseDraft)) {
           throw new ActionError({
             documentId,
             transactionId,

package/src/document/reducers.ts

@@ -1,11 +1,11 @@
 import {DocumentId, getDraftId, getPublishedId, getVersionId} from '@sanity/id-utils'
 import {type Mutation, type PatchOperations, type SanityDocumentLike} from '@sanity/types'
-import {omit} from 'lodash-es'
 
 import {type DocumentHandle} from '../config/sanityConfig'
 import {isReleasePerspective} from '../releases/utils/isReleasePerspective'
 import {type StoreContext} from '../store/defineStore'
 import {insecureRandomId} from '../utils/ids'
+import {omitProperty} from '../utils/object'
 import {setCleanupTimeout} from '../utils/setCleanupTimeout'
 import {type DocumentAction} from './actions'
 import {DOCUMENT_STATE_CLEAR_DELAY} from './documentConstants'
@@ -392,7 +392,7 @@ export function revertOutgoingTransaction(prev: SyncTransactionState): SyncTrans
             local: documentId in working ? working[documentId] : local,
             unverifiedRevisions:
               prev.outgoing && prev.outgoing.transactionId in unverifiedRevisions
-                ? omit(unverifiedRevisions, prev.outgoing.transactionId)
+                ? omitProperty(unverifiedRevisions, prev.outgoing.transactionId)
                 : unverifiedRevisions,
           }
           return [documentId, next] as const
@@ -420,7 +420,7 @@ export function applyRemoteDocument(
   const revisionToVerify = revision ? prevUnverifiedRevisions?.[revision] : undefined
   let unverifiedRevisions = prevUnverifiedRevisions ?? EMPTY_REVISIONS
   if (revision && revisionToVerify) {
-    unverifiedRevisions = omit(prevUnverifiedRevisions, revision)
+    unverifiedRevisions = omitProperty(prevUnverifiedRevisions, revision)
   }
 
   // if this remote document is from a `'sync'` event (meaning that the whole
@@ -547,7 +547,7 @@ export function removeSubscriptionIdFromDocument(
 
   if (!prevDocState) return prev
   if (!subscriptions.length) {
-    return {...prev, documentStates: omit(prev.documentStates, documentId)}
+    return {...prev, documentStates: omitProperty(prev.documentStates, documentId)}
   }
   return {
     ...prev,

package/src/document/sharedListener.ts

@@ -14,7 +14,7 @@ import {
 } from 'rxjs'
 
 import {getClientState} from '../client/clientStore'
-import {type DocumentSource, isDatasetSource} from '../config/sanityConfig'
+import {type DocumentResource, isDatasetResource} from '../config/sanityConfig'
 import {type SanityInstance} from '../store/createSanityInstance'
 
 const API_VERSION = 'v2025-05-06'
@@ -26,13 +26,13 @@ export interface SharedListener {
 
 export function createSharedListener(
   instance: SanityInstance,
-  source?: DocumentSource,
+  resource?: DocumentResource,
 ): SharedListener {
   const dispose$ = new Subject<void>()
   const events$ = getClientState(instance, {
     apiVersion: API_VERSION,
-    // TODO: remove in v3 when we're ready for everything to be queried via source
-    source: source && !isDatasetSource(source) ? source : undefined,
+    // TODO: remove in v3 when we're ready for everything to be queried via resource
+    resource: resource && !isDatasetResource(resource) ? resource : undefined,
   }).observable.pipe(
     switchMap((client) =>
       // TODO: it seems like the client.listen method is not emitting disconnected
@@ -68,12 +68,12 @@ export function createSharedListener(
   }
 }
 
-export function createFetchDocument(instance: SanityInstance, source?: DocumentSource) {
+export function createFetchDocument(instance: SanityInstance, resource?: DocumentResource) {
   return function (documentId: string): Observable<SanityDocument | null> {
     return getClientState(instance, {
       apiVersion: API_VERSION,
-      // TODO: remove in v3 when we're ready for everything to be queried via source
-      source: source && !isDatasetSource(source) ? source : undefined,
+      // TODO: remove in v3 when we're ready for everything to be queried via resource
+      resource: resource && !isDatasetResource(resource) ? resource : undefined,
     }).observable.pipe(
       switchMap((client) => {
         // creates a observable request to the /doc/{documentId} endpoint for a given document id

package/src/presence/bifurTransport.test.ts

@@ -45,16 +45,18 @@ describe('createBifurTransport', () => {
 
   beforeEach(() => {
     vi.useFakeTimers()
+    vi.clearAllMocks()
     mockBifurClient = {
       listen: vi.fn(() => new Subject<never>()),
       request: vi.fn(() => of(undefined)),
     }
     fromUrlMock.mockReturnValue(mockBifurClient)
 
+    // Default mock is a dataset client using project hostname
     mockSanityClient = {
       config: () => ({
         dataset: 'test-dataset',
-        url: 'http://localhost:3333',
+        url: 'https://test-project.api.sanity.io/v2022-06-30',
         requestTagPrefix: 'test-tag',
       }),
       withConfig: vi.fn().mockReturnThis(),
@@ -63,7 +65,7 @@ describe('createBifurTransport', () => {
     token$ = new Subject<string | null>()
   })
 
-  it('constructs the bifur client with the correct URL', () => {
+  it('constructs the bifur client URL for a dataset resource', () => {
     createBifurTransport({
       client: mockSanityClient,
       token$,
@@ -71,13 +73,51 @@ describe('createBifurTransport', () => {
     })
 
     expect(fromUrlMock).toHaveBeenCalledWith(
-      'ws://localhost:3333/socket/test-dataset?tag=test-tag',
-      {
-        token$,
-      },
+      'wss://test-project.api.sanity.io/v2022-06-30/socket/test-dataset?tag=test-tag',
+      {token$},
+    )
+  })
+
+  it('constructs the bifur client URL for a canvas resource', () => {
+    const canvasClient = {
+      config: () => ({
+        resource: {type: 'canvas', id: 'canvas-123'},
+        url: 'https://api.sanity.io/v2022-06-30',
+        requestTagPrefix: 'test-tag',
+      }),
+      withConfig: vi.fn().mockReturnThis(),
+    } as unknown as SanityClient
+
+    createBifurTransport({
+      client: canvasClient,
+      token$,
+      sessionId: 'session-id-123',
+    })
+
+    expect(fromUrlMock).toHaveBeenCalledWith(
+      'wss://api.sanity.io/v2022-06-30/socket/canvases/canvas-123?tag=test-tag',
+      {token$},
     )
   })
 
+  it('throws when no canvas resource or dataset is configured', () => {
+    const invalidClient = {
+      config: () => ({
+        url: 'https://api.sanity.io/v2022-06-30',
+        requestTagPrefix: 'test-tag',
+      }),
+      withConfig: vi.fn().mockReturnThis(),
+    } as unknown as SanityClient
+
+    expect(() =>
+      createBifurTransport({
+        client: invalidClient,
+        token$,
+        sessionId: 'session-id-123',
+      }),
+    ).toThrow('Unable to determine presence URL')
+  })
+
   it('handles incoming rollCall events', () => {
     const incomingBifurEvents$ = new Subject<IncomingBifurEvent>()
     mockBifurClient.listen.mockReturnValue(incomingBifurEvents$)

package/src/presence/bifurTransport.ts

@@ -37,11 +37,23 @@ type IncomingBifurEvent = RollCallEvent | BifurStateMessage | BifurDisconnectMes
 function getBifurClient(client: SanityClient, token$: Observable<string | null>): BifurClient {
   const bifurVersionedClient = client.withConfig({apiVersion: '2022-06-30'})
   const {
+    resource,
     dataset,
     url: baseUrl,
     requestTagPrefix = 'sanity.sdk.presence',
   } = bifurVersionedClient.config()
-  const url = `${baseUrl.replace(/\/+$/, '')}/socket/${dataset}`.replace(/^http/, 'ws')
+
+  let resourcePath: string
+  if (resource?.type === 'canvas') {
+    resourcePath = `canvases/${resource.id}`
+  } else if (dataset) {
+    // Dataset clients use project hostname — dataset name alone is the socket path
+    resourcePath = dataset
+  } else {
+    throw new Error(`Unable to determine presence URL: no canvas resource or dataset configured`)
+  }
+
+  const url = `${baseUrl}/socket/${resourcePath}`.replace(/^http/, 'ws')
 
   const urlWithTag = `${url}?tag=${requestTagPrefix}`
 

package/src/presence/presenceStore.test.ts

@@ -48,6 +48,9 @@ describe('presenceStore', () => {
 
     mockClient = {
       withConfig: vi.fn().mockReturnThis(),
+      observable: {
+        request: vi.fn(() => of({organizationId: 'test-org-id'})),
+      },
     } as unknown as SanityClient
 
     mockTokenState = new Subject<string | null>()
@@ -243,5 +246,98 @@ describe('presenceStore', () => {
 
       unsubscribe()
     })
+
+    it('should throw an error when initialized with a media library resource', () => {
+      const mediaLibraryResource = {mediaLibraryId: 'ml123'}
+
+      expect(() => {
+        getPresence(instance, {resource: mediaLibraryResource})
+      }).toThrow('Presence is not supported for media library resources.')
+    })
+
+    it('should work with a dataset resource', () => {
+      const datasetResource = {projectId: 'test-project', dataset: 'test-dataset'}
+
+      expect(() => {
+        getPresence(instance, {resource: datasetResource})
+      }).not.toThrow()
+    })
+
+    it('should work with a canvas resource', () => {
+      const canvasResource = {canvasId: 'canvas123'}
+
+      expect(() => {
+        getPresence(instance, {resource: canvasResource})
+      }).not.toThrow()
+    })
+
+    it('creates a project-hostname client for dataset resources', () => {
+      getPresence(instance, {resource: {projectId: 'my-project', dataset: 'my-dataset'}})
+
+      expect(getClient).toHaveBeenCalledWith(instance, {
+        apiVersion: '2026-03-30',
+        projectId: 'my-project',
+        dataset: 'my-dataset',
+        useProjectHostname: true,
+      })
+    })
+
+    it('creates a resource client for canvas resources', () => {
+      const canvasResource = {canvasId: 'canvas123'}
+      getPresence(instance, {resource: canvasResource})
+
+      expect(getClient).toHaveBeenCalledWith(instance, {
+        apiVersion: '2026-03-30',
+        resource: canvasResource,
+      })
+    })
+
+    it('fetches organizationId from canvas endpoint for canvas resources', () => {
+      const canvasResource = {canvasId: 'canvas123'}
+      getPresence(instance, {resource: canvasResource})
+
+      expect(mockClient.observable.request).toHaveBeenCalledWith({
+        uri: '/canvases/canvas123',
+        tag: 'canvases.get',
+      })
+    })
+
+    it('does not fetch organizationId for dataset resources', () => {
+      getPresence(instance, {resource: {projectId: 'my-project', dataset: 'my-dataset'}})
+
+      expect(mockClient.observable.request).not.toHaveBeenCalled()
+    })
+
+    it('fetches user data for canvas users', async () => {
+      const source = getPresence(instance, {resource: {canvasId: 'canvas123'}})
+      const unsubscribe = source.subscribe(() => {})
+
+      await firstValueFrom(of(null).pipe(delay(10)))
+
+      mockIncomingEvents.next({
+        type: 'state',
+        userId: 'user-1',
+        sessionId: 'other-session',
+        timestamp: '2023-01-01T12:00:00Z',
+        locations: [
+          {
+            type: 'document',
+            documentId: 'doc-1',
+            path: ['title'],
+            lastActiveAt: '2023-01-01T12:00:00Z',
+          },
+        ],
+      })
+
+      await firstValueFrom(of(null).pipe(delay(50)))
+
+      expect(getUserState).toHaveBeenCalledWith(instance, {
+        userId: 'user-1',
+        resourceType: 'organization',
+        organizationId: 'test-org-id',
+      })
+
+      unsubscribe()
+    })
   })
 })

package/src/presence/presenceStore.ts

@@ -1,20 +1,45 @@
-import {type SanityClient} from '@sanity/client'
 import {createSelector} from 'reselect'
-import {combineLatest, distinctUntilChanged, filter, map, of, Subscription, switchMap} from 'rxjs'
+import {
+  catchError,
+  combineLatest,
+  distinctUntilChanged,
+  EMPTY,
+  filter,
+  first,
+  map,
+  type Observable,
+  of,
+  Subscription,
+  switchMap,
+} from 'rxjs'
 
 import {getTokenState} from '../auth/authStore'
 import {getClient} from '../client/clientStore'
-import {bindActionByDataset, type BoundDatasetKey} from '../store/createActionBinder'
-import {createStateSourceAction, type SelectorContext} from '../store/createStateSourceAction'
+import {
+  type DocumentResource,
+  isCanvasResource,
+  isDatasetResource,
+  isMediaLibraryResource,
+} from '../config/sanityConfig'
+import {bindActionByResource, type BoundResourceKey} from '../store/createActionBinder'
+import {type SanityInstance} from '../store/createSanityInstance'
+import {
+  createStateSourceAction,
+  type SelectorContext,
+  type StateSource,
+} from '../store/createStateSourceAction'
 import {defineStore, type StoreContext} from '../store/defineStore'
 import {type SanityUser} from '../users/types'
 import {getUserState} from '../users/usersStore'
 import {createBifurTransport} from './bifurTransport'
 import {type PresenceLocation, type TransportEvent, type UserPresence} from './types'
 
+const PRESENCE_API_VERSION = '2026-03-30'
+
 type PresenceStoreState = {
   locations: Map<string, {userId: string; locations: PresenceLocation[]}>
   users: Record<string, SanityUser | undefined>
+  organizationId?: string
 }
 
 const getInitialState = (): PresenceStoreState => ({
@@ -23,27 +48,40 @@ const getInitialState = (): PresenceStoreState => ({
 })
 
 /** @public */
-export const presenceStore = defineStore<PresenceStoreState, BoundDatasetKey>({
+export const presenceStore = defineStore<PresenceStoreState, BoundResourceKey>({
   name: 'presence',
   getInitialState,
-  initialize: (context: StoreContext<PresenceStoreState, BoundDatasetKey>) => {
+  initialize: (context: StoreContext<PresenceStoreState, BoundResourceKey>) => {
     const {
       instance,
       state,
-      key: {projectId, dataset},
+      key: {resource},
     } = context
+
+    if (isMediaLibraryResource(resource)) {
+      throw new Error('Presence is not supported for media library resources.')
+    }
+
     const sessionId = crypto.randomUUID()
 
-    const client = getClient(instance, {
-      apiVersion: '2022-06-30',
-      projectId,
-      dataset,
-    })
+    // Dataset resources must use the project hostname so the socket URL is project-specific.
+    // Canvas resources use the global API endpoint via the resource config.
+    const client = isDatasetResource(resource)
+      ? getClient(instance, {
+          apiVersion: PRESENCE_API_VERSION,
+          projectId: resource.projectId,
+          dataset: resource.dataset,
+          useProjectHostname: true,
+        })
+      : getClient(instance, {
+          apiVersion: PRESENCE_API_VERSION,
+          resource,
+        })
 
     const token$ = getTokenState(instance).observable.pipe(distinctUntilChanged())
 
     const [incomingEvents$, dispatch] = createBifurTransport({
-      client: client as SanityClient,
+      client,
       token$,
       sessionId,
     })
@@ -81,6 +119,22 @@ export const presenceStore = defineStore<PresenceStoreState, BoundDatasetKey>({
 
     dispatch({type: 'rollCall'}).subscribe()
 
+    // Canvas resources need the organizationId to resolve users — fetch it once from the canvas endpoint
+    if (isCanvasResource(resource)) {
+      const globalClient = getClient(instance, {apiVersion: PRESENCE_API_VERSION})
+      subscription.add(
+        globalClient.observable
+          .request<{organizationId: string}>({
+            uri: `/canvases/${resource.canvasId}`,
+            tag: 'canvases.get',
+          })
+          .pipe(catchError(() => EMPTY))
+          .subscribe(({organizationId}) => {
+            state.set('presence/organizationId', (prev) => ({...prev, organizationId}))
+          }),
+      )
+    }
+
     return () => {
       dispatch({type: 'disconnect'}).subscribe()
       subscription.unsubscribe()
@@ -114,13 +168,13 @@ const selectPresence = createSelector(
   },
 )
 
-/** @public */
-export const getPresence = bindActionByDataset(
+const _getPresence = bindActionByResource(
   presenceStore,
   createStateSourceAction({
-    selector: (context: SelectorContext<PresenceStoreState>, _?): UserPresence[] =>
+    selector: (context: SelectorContext<PresenceStoreState>): UserPresence[] =>
       selectPresence(context.state),
-    onSubscribe: (context: StoreContext<PresenceStoreState, BoundDatasetKey>, _?) => {
+    onSubscribe: (context: StoreContext<PresenceStoreState, BoundResourceKey>) => {
+      const resource = context.key.resource
       const userIds$ = context.state.observable.pipe(
         map((state) =>
           Array.from(state.locations.values())
@@ -130,26 +184,34 @@ export const getPresence = bindActionByDataset(
         distinctUntilChanged((a, b) => a.length === b.length && a.every((v, i) => v === b[i])),
       )
 
-      const subscription = userIds$
+      // For canvas resources, wait for organizationId to be fetched and stored in state.
+      // For dataset resources, emit undefined immediately so the stream isn't blocked.
+      const organizationId$: Observable<string | undefined> = isCanvasResource(resource)
+        ? context.state.observable.pipe(
+            map((s) => s.organizationId),
+            filter((id): id is string => id !== undefined),
+            first(),
+          )
+        : of(undefined)
+
+      const subscription = combineLatest([userIds$, organizationId$])
         .pipe(
-          switchMap((userIds) => {
+          switchMap(([userIds, organizationId]) => {
             if (userIds.length === 0) {
               return of([])
             }
             const userObservables = userIds.map((userId) =>
               getUserState(context.instance, {
                 userId,
-                resourceType: 'project',
-                projectId: context.key.projectId,
+                ...(isDatasetResource(resource)
+                  ? {resourceType: 'project', projectId: resource.projectId}
+                  : {resourceType: 'organization', organizationId}),
               }).pipe(filter((v): v is NonNullable<typeof v> => !!v)),
             )
             return combineLatest(userObservables)
           }),
         )
         .subscribe((users) => {
-          if (!users) {
-            return
-          }
           context.state.set('presence/users', (prevState) => ({
             ...prevState,
             users: {
@@ -167,3 +229,13 @@ export const getPresence = bindActionByDataset(
     },
   }),
 )
+
+/** @beta */
+export function getPresence(
+  instance: SanityInstance,
+  params?: {resource?: DocumentResource},
+): StateSource<UserPresence[]> {
+  // bit of a hack to support the old bound action by dataset
+  // in reality, this will always be passed a resource
+  return _getPresence(instance, params ?? {})
+}

package/src/preview/getPreviewState.ts

@@ -52,7 +52,7 @@ export function getPreviewState(
       return {data: null, isPending: current?.isPending ?? false}
     }
 
-    const previewValue = transformProjectionToPreview(instance, current.data, options.source)
+    const previewValue = transformProjectionToPreview(instance, current.data, options.resource)
 
     return {
       data: previewValue,

package/src/preview/previewProjectionUtils.test.ts

@@ -156,7 +156,7 @@ describe('transformProjectionToPreview', () => {
     })
   })
 
-  it('calls getClient with the provided source', async () => {
+  it('calls getClient with the provided resource', async () => {
     const projectionResult: PreviewQueryResult = {
       _id: 'doc1',
       _type: 'article',
@@ -166,14 +166,14 @@ describe('transformProjectionToPreview', () => {
       media: null,
     }
 
-    const source = {mediaLibraryId: 'test-library'}
+    const resource = {mediaLibraryId: 'test-library'}
 
-    transformProjectionToPreview(instance, projectionResult, source)
+    transformProjectionToPreview(instance, projectionResult, resource)
 
     const {getClient} = await import('../client/clientStore')
     expect(getClient).toHaveBeenCalledWith(instance, {
       apiVersion: 'v2025-05-06',
-      source,
+      resource,
     })
   })
 })

package/src/preview/previewProjectionUtils.ts

@@ -1,10 +1,10 @@
 import {type SanityClient} from '@sanity/client'
 import {createImageUrlBuilder} from '@sanity/image-url'
-import {isObject} from 'lodash-es'
 
 import {getClient} from '../client/clientStore'
-import {type DocumentSource, isDatasetSource} from '../config/sanityConfig'
+import {type DocumentResource, isDatasetResource} from '../config/sanityConfig'
 import {type SanityInstance} from '../store/createSanityInstance'
+import {isObject} from '../utils/object'
 import {SUBTITLE_CANDIDATES, TITLE_CANDIDATES} from './previewConstants'
 import {type PreviewQueryResult, type PreviewValue} from './types'
 
@@ -66,22 +66,22 @@ function findFirstDefined(
  *
  * @param projectionResult - The raw projection result from GROQ
  * @param instance - The Sanity instance to use for client configuration
- * @param source - Data source for the preview
+ * @param resource - Data resource for the preview
  * @internal
  */
 export function transformProjectionToPreview(
   instance: SanityInstance,
   projectionResult: PreviewQueryResult,
-  source?: DocumentSource,
+  resource?: DocumentResource,
 ): PreviewValue {
   const title = findFirstDefined(TITLE_CANDIDATES, projectionResult.titleCandidates)
   const subtitle = findFirstDefined(SUBTITLE_CANDIDATES, projectionResult.subtitleCandidates, title)
 
-  // Get a client for the source (if provided) or use the instance config
+  // Get a client for the resource (if provided) or use the instance config
   const client = getClient(instance, {
     apiVersion: API_VERSION,
-    // TODO: remove in v3 when we're ready for everything to be queried via source
-    source: source && !isDatasetSource(source) ? source : undefined,
+    // TODO: remove in v3 when we're ready for everything to be queried via resource
+    resource: resource && !isDatasetResource(resource) ? resource : undefined,
   })
 
   return {

package/src/preview/resolvePreview.ts

@@ -30,7 +30,11 @@ export async function resolvePreview(
   }
 
   // Transform to preview format
-  const previewValue = transformProjectionToPreview(instance, projectionResult.data, options.source)
+  const previewValue = transformProjectionToPreview(
+    instance,
+    projectionResult.data,
+    options.resource,
+  )
 
   return {
     data: previewValue,

package/src/projection/getProjectionState.ts

@@ -1,9 +1,8 @@
 import {DocumentId, getPublishedId} from '@sanity/id-utils'
 import {type SanityProjectionResult} from 'groq'
-import {omit} from 'lodash-es'
 
 import {type DocumentHandle} from '../config/sanityConfig'
-import {bindActionBySourceAndPerspective} from '../store/createActionBinder'
+import {bindActionByResourceAndPerspective} from '../store/createActionBinder'
 import {type SanityInstance} from '../store/createSanityInstance'
 import {
   createStateSourceAction,
@@ -12,6 +11,7 @@ import {
 } from '../store/createStateSourceAction'
 import {hashString} from '../utils/hashString'
 import {insecureRandomId} from '../utils/ids'
+import {omitProperty} from '../utils/object'
 import {setCleanupTimeout} from '../utils/setCleanupTimeout'
 import {projectionStore} from './projectionStore'
 import {type ProjectionStoreState, type ProjectionValuePending} from './types'
@@ -72,7 +72,7 @@ export function getProjectionState(
 /**
  * @beta
  */
-export const _getProjectionState = bindActionBySourceAndPerspective(
+export const _getProjectionState = bindActionByResourceAndPerspective(
   projectionStore,
   createStateSourceAction({
     selector: (
@@ -113,7 +113,7 @@ export const _getProjectionState = bindActionBySourceAndPerspective(
       return () => {
         setCleanupTimeout(() => {
           state.set('removeSubscription', (prev): Partial<ProjectionStoreState> => {
-            const documentSubscriptionsForHash = omit(
+            const documentSubscriptionsForHash = omitProperty(
               prev.subscriptions[documentId]?.[projectionHash],
               subscriptionId,
             )

package/src/projection/projectionStore.test.ts

@@ -30,7 +30,7 @@ describe('projectionStore', () => {
       instance,
       {
         name: 'p.d',
-        source: {projectId: 'p', dataset: 'd'},
+        resource: {projectId: 'p', dataset: 'd'},
         perspective: 'drafts',
       },
       projectionStore,
@@ -42,7 +42,7 @@ describe('projectionStore', () => {
       state,
       key: {
         name: 'p.d',
-        source: {projectId: 'p', dataset: 'd'},
+        resource: {projectId: 'p', dataset: 'd'},
         perspective: 'drafts',
       },
     })