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

package/src/projection/resolveProjection.test.ts

@@ -1,144 +1,49 @@
-import {describe, it, type Mock} from 'vitest'
-
-import {createSanityInstance} from '../instance/sanityInstance'
-import {
-  createResourceState,
-  getOrCreateResource,
-  type InitializedResource,
-  type ResourceState,
-} from '../resources/createResource'
-import {insecureRandomId} from '../utils/ids'
-import {
-  projectionStore,
-  type ProjectionStoreState,
-  type ProjectionValuePending,
-} from './projectionStore'
+import {type SanityDocumentLike} from '@sanity/types'
+import {of} from 'rxjs'
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
+
+import {type DocumentHandle} from '../config/sanityConfig'
+import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
+import {type StateSource} from '../store/createStateSourceAction'
+import {getProjectionState} from './getProjectionState'
 import {resolveProjection} from './resolveProjection'
+import {type ProjectionValuePending, type ValidProjection} from './types'
 
-vi.mock('../utils/ids', async (importOriginal) => {
-  const util = await importOriginal<typeof import('../utils/ids')>()
-  return {...util, insecureRandomId: vi.fn(util.insecureRandomId)}
-})
-
-vi.mock('../resources/createResource', async (importOriginal) => {
-  const original = await importOriginal<typeof import('../resources/createResource')>()
-  return {...original, getOrCreateResource: vi.fn()}
-})
+vi.mock('./getProjectionState')
 
 describe('resolveProjection', () => {
-  const instance = createSanityInstance({projectId: 'exampleProject', dataset: 'exampleDataset'})
-  const document = {_id: 'exampleId', _type: 'exampleType'}
-  const projectionString = '{title, description}'
-  const initialState: ProjectionStoreState = {
-    documentProjections: {},
-    lastLiveEventId: null,
-    subscriptions: {},
-    syncTags: {},
-    values: {},
-  }
-  let state: ResourceState<ProjectionStoreState>
+  let instance: SanityInstance
 
   beforeEach(() => {
-    state = createResourceState(initialState)
+    vi.resetAllMocks()
+    // Create a mock that returns the correct ProjectionValuePending type
+    vi.mocked(getProjectionState).mockReturnValue({
+      observable: of({
+        data: {title: 'test'},
+        isPending: false,
+      } as ProjectionValuePending<Record<string, unknown>>),
+    } as StateSource<ProjectionValuePending<Record<string, unknown>>>)
+
+    instance = createSanityInstance({projectId: 'p', dataset: 'd'})
   })
 
-  it('subscribes and resolves when the projection value is non-null', async () => {
-    expect(state.get().subscriptions).toEqual({})
-    ;(insecureRandomId as Mock).mockImplementationOnce(() => 'pseudoRandomId')
-
-    const projectionPromise = resolveProjection(
-      {state, instance},
-      {document, projection: projectionString},
-    )
-    expect(state.get().subscriptions).toEqual({exampleId: {pseudoRandomId: true}})
-    expect(state.get().documentProjections).toEqual({exampleId: projectionString})
-
-    state.set('updateDifferentDocument', (prev) => ({
-      values: {
-        ...prev.values,
-        differentId: {data: {title: 'Different Document'}, isPending: false},
-      },
-    }))
-
-    expect(state.get().subscriptions).toEqual({exampleId: {pseudoRandomId: true}})
-
-    state.set('updateCorrectDocumentButNull', (prev) => ({
-      values: {...prev.values, exampleId: {data: null, isPending: true}},
-    }))
-
-    expect(state.get().subscriptions).toEqual({exampleId: {pseudoRandomId: true}})
-
-    state.set('updateCorrectDocument', (prev) => ({
-      values: {
-        ...prev.values,
-        exampleId: {
-          data: {title: 'Correct Document', description: 'Test'},
-          isPending: false,
-        },
-      },
-    }))
-
-    const projectionResult = await projectionPromise
-    expect(projectionResult).toEqual({
-      data: {title: 'Correct Document', description: 'Test'},
-      isPending: false,
-    })
-
-    // subscription is removed after
-    expect(state.get().subscriptions).toEqual({})
+  afterEach(() => {
+    instance.dispose()
   })
 
-  it('resolves with the next emitted state (not current state)', async () => {
-    const currentValue: ProjectionValuePending<Record<string, unknown>> = {
-      data: {title: 'Current Document', description: 'Test'},
-      isPending: false,
+  it('resolves a projection and returns the first emitted value with results', async () => {
+    const docHandle: DocumentHandle<SanityDocumentLike> = {
+      documentId: 'doc123',
+      documentType: 'movie',
     }
-    state.set('setInitialDocument', (prev) => ({
-      values: {...prev.values, exampleId: currentValue},
-    }))
-    vi.mocked(insecureRandomId).mockImplementationOnce(() => 'pseudoRandomId')
-    expect(state.get().subscriptions).toEqual({})
+    const projection = '{title}' as ValidProjection
 
-    const projectionPromise = resolveProjection(
-      {state, instance},
-      {document, projection: projectionString},
-    )
-    expect(state.get().subscriptions).toEqual({exampleId: {pseudoRandomId: true}})
+    const result = await resolveProjection(instance, {...docHandle, projection})
 
-    state.set('updateDifferentDocument', (prev) => ({
-      values: {
-        ...prev.values,
-        differentId: {data: {title: 'Different Document'}, isPending: false},
-      },
-    }))
-    expect(state.get().subscriptions).toEqual({exampleId: {pseudoRandomId: true}})
-
-    state.set('updateWithCurrentValue', (prev) => ({
-      values: {...prev.values, exampleId: currentValue},
-    }))
-    expect(state.get().subscriptions).toEqual({exampleId: {pseudoRandomId: true}})
-
-    state.set('updateWithNewValue', (prev) => ({
-      values: {
-        ...prev.values,
-        exampleId: {
-          data: {title: 'New Value', description: 'Updated'},
-          isPending: false,
-        },
-      },
-    }))
-    expect(state.get().subscriptions).toEqual({})
-
-    const projectionResult = await projectionPromise
-    expect(projectionResult).toEqual({
-      data: {title: 'New Value', description: 'Updated'},
+    expect(getProjectionState).toHaveBeenCalledWith(instance, {...docHandle, projection})
+    expect(result).toEqual({
+      data: {title: 'test'},
       isPending: false,
     })
   })
-
-  it('calls getOrCreateResource if no state is provided', () => {
-    vi.mocked(getOrCreateResource).mockReturnValue({state} as InitializedResource<unknown>)
-    resolveProjection(instance, {document, projection: projectionString})
-    expect(getOrCreateResource).toHaveBeenCalledWith(instance, projectionStore)
-  })
 })

package/src/projection/resolveProjection.ts

@@ -1,36 +1,24 @@
-import {type DocumentHandle} from '../document/patchOperations'
-import {type ActionContext, createAction} from '../resources/createAction'
+import {filter, firstValueFrom} from 'rxjs'
+
+import {type DocumentHandle} from '../config/sanityConfig'
+import {bindActionByDataset} from '../store/createActionBinder'
 import {getProjectionState} from './getProjectionState'
-import {
-  projectionStore,
-  type ProjectionStoreState,
-  type ProjectionValuePending,
-  type ValidProjection,
-} from './projectionStore'
+import {projectionStore} from './projectionStore'
+import {type ValidProjection} from './types'
 
-interface ResolveProjectionOptions {
-  document: DocumentHandle
+interface ResolveProjectionOptions extends DocumentHandle {
   projection: ValidProjection
 }
 
 /**
  * @beta
  */
-export const resolveProjection = createAction(projectionStore, () => {
-  return function <TResult extends Record<string, unknown> = Record<string, unknown>>(
-    this: ActionContext<ProjectionStoreState>,
-    {document, projection}: ResolveProjectionOptions,
-  ): Promise<ProjectionValuePending<TResult>> {
-    const {getCurrent, subscribe} = getProjectionState<TResult>(this, {document, projection})
-
-    return new Promise<ProjectionValuePending<TResult>>((resolve) => {
-      const unsubscribe = subscribe(() => {
-        const current = getCurrent()
-        if (current?.data) {
-          resolve(current)
-          unsubscribe()
-        }
-      })
-    })
-  }
-})
+export const resolveProjection = bindActionByDataset(
+  projectionStore,
+  ({instance}, {projection, ...docHandle}: ResolveProjectionOptions) =>
+    firstValueFrom(
+      getProjectionState(instance, {...docHandle, projection}).observable.pipe(
+        filter((i) => !!i.data),
+      ),
+    ),
+)

package/src/projection/subscribeToStateAndFetchBatches.test.ts

@@ -1,51 +1,40 @@
-import {SanityClient, type SyncTag} from '@sanity/client'
-import {Observable, of, Subject} from 'rxjs'
-import {describe, expect, it, type Mock, vi} from 'vitest'
-
-import {getClientState} from '../client/clientStore'
-import {hashString} from '../common/util'
-import {createSanityInstance} from '../instance/sanityInstance'
-import {createResourceState, type ResourceState} from '../resources/createResource'
-import {type StateSource} from '../resources/createStateSourceAction'
-import {type ProjectionQueryResult, type ProjectionStoreState} from './projectionStore'
+import {NEVER, Observable, type Observer} from 'rxjs'
+import {describe, expect, it, vi} from 'vitest'
+
+import {getQueryState, resolveQuery} from '../query/queryStore'
+import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
+import {type StateSource} from '../store/createStateSourceAction'
+import {createStoreState, type StoreState} from '../store/createStoreState'
+import {hashString} from '../utils/hashString'
+import {type ProjectionQueryResult} from './projectionQuery'
 import {subscribeToStateAndFetchBatches} from './subscribeToStateAndFetchBatches'
+import {type ProjectionStoreState} from './types'
 
-vi.mock('../client/clientStore.ts', () => ({getClientState: vi.fn()}))
-vi.mock('../resources/createResource', async (importOriginal) => {
-  const original = await importOriginal<typeof import('../resources/createResource')>()
-  return {...original, getOrCreateResource: vi.fn()}
-})
+vi.mock('../query/queryStore')
 
 describe('subscribeToStateAndFetchBatches', () => {
-  const instance = createSanityInstance({projectId: 'test', dataset: 'test'})
-
-  let state: ResourceState<ProjectionStoreState>
-  let fetchResults: Subject<{result: ProjectionQueryResult[]; syncTags: SyncTag[]}>
-  let mockFetch: Mock
+  let instance: SanityInstance
+  let state: StoreState<ProjectionStoreState>
 
   beforeEach(() => {
-    state = createResourceState<ProjectionStoreState>({
+    vi.clearAllMocks()
+    instance = createSanityInstance({projectId: 'test', dataset: 'test'})
+    state = createStoreState<ProjectionStoreState>({
       documentProjections: {},
-      lastLiveEventId: null,
       subscriptions: {},
-      syncTags: {},
       values: {},
     })
-    fetchResults = new Subject()
-
-    mockFetch = vi.fn().mockImplementation(
-      () =>
-        new Observable((subscriber) => {
-          const subscription = fetchResults.subscribe({
-            next: (val) => subscriber.next(val),
-            complete: () => subscriber.complete(),
-          })
-          return () => subscription.unsubscribe()
-        }),
-    )
-    vi.mocked(getClientState).mockReturnValue({
-      observable: of({observable: {fetch: mockFetch}} as unknown as SanityClient),
-    } as StateSource<SanityClient>)
+
+    vi.mocked(getQueryState).mockReturnValue({
+      getCurrent: () => undefined,
+      observable: NEVER as Observable<ProjectionQueryResult[] | undefined>,
+    } as StateSource<ProjectionQueryResult[] | undefined>)
+
+    vi.mocked(resolveQuery).mockResolvedValue(undefined)
+  })
+
+  afterEach(() => {
+    instance.dispose()
   })
 
   it('batches rapid subscription changes into single requests', async () => {
@@ -55,169 +44,267 @@ describe('subscribeToStateAndFetchBatches', () => {
 
     // Add multiple subscriptions rapidly
     state.set('addSubscription1', {
-      documentProjections: {doc1: projection},
-      subscriptions: {doc1: {sub1: true}},
+      documentProjections: {doc1: {[projectionHash]: projection}},
+      // Add projectionHash level to subscriptions
+      subscriptions: {doc1: {[projectionHash]: {sub1: true}}},
     })
 
     state.set('addSubscription2', (prev) => ({
-      documentProjections: {...prev.documentProjections, doc2: projection},
-      subscriptions: {...prev.subscriptions, doc2: {sub2: true}},
+      documentProjections: {
+        ...prev.documentProjections,
+        doc2: {[projectionHash]: projection},
+      },
+      // Add projectionHash level to subscriptions
+      subscriptions: {
+        ...prev.subscriptions,
+        doc2: {[projectionHash]: {sub2: true}},
+      },
     }))
 
     // Wait for debounce
     await new Promise((resolve) => setTimeout(resolve, 100))
 
-    expect(mockFetch).toHaveBeenCalledTimes(1)
-    expect(mockFetch.mock.calls[0][1]).toMatchObject({
-      [`__ids_${projectionHash}`]: ['doc1', 'drafts.doc1', 'doc2', 'drafts.doc2'],
-    })
+    // Should still be 1 call because projections are identical
+    expect(getQueryState).toHaveBeenCalledTimes(1)
+    expect(getQueryState).toHaveBeenCalledWith(
+      instance,
+      expect.any(String),
+      expect.objectContaining({
+        params: {
+          [`__ids_${projectionHash}`]: expect.arrayContaining([
+            'doc1',
+            'drafts.doc1',
+            'doc2',
+            'drafts.doc2',
+          ]),
+        },
+      }),
+    )
 
     subscription.unsubscribe()
   })
 
-  it('always uses latest client/eventId state when fetching', async () => {
+  it('processes query results and updates state with resolved values', async () => {
+    const teardown = vi.fn()
+    const subscriber = vi
+      .fn<(observer: Observer<ProjectionQueryResult[] | undefined>) => () => void>()
+      .mockReturnValue(teardown)
+
+    vi.mocked(getQueryState).mockReturnValue({
+      getCurrent: () => undefined,
+      observable: new Observable(subscriber),
+    } as StateSource<ProjectionQueryResult[] | undefined>)
+
     const subscription = subscribeToStateAndFetchBatches({instance, state})
+    const projection = '{title}'
+    const projectionHash = hashString(projection)
+
+    expect(subscriber).not.toHaveBeenCalled()
 
     // Add a subscription
     state.set('addSubscription', {
-      documentProjections: {doc1: '{title, description}'},
-      subscriptions: {doc1: {sub1: true}},
+      documentProjections: {doc1: {[projectionHash]: projection}},
+      subscriptions: {doc1: {[projectionHash]: {sub1: true}}},
     })
 
-    // Update lastLiveEventId
-    state.set('updateEventId', {lastLiveEventId: 'event1'})
+    expect(subscriber).not.toHaveBeenCalled()
 
     // Wait for debounce
     await new Promise((resolve) => setTimeout(resolve, 100))
 
-    expect(mockFetch).toHaveBeenCalledWith(
-      expect.any(String),
-      expect.any(Object),
-      expect.objectContaining({
-        lastLiveEventId: 'event1',
-      }),
-    )
+    expect(subscriber).toHaveBeenCalled()
+    expect(teardown).not.toHaveBeenCalled()
+
+    const [observer] = subscriber.mock.lastCall!
+
+    const timestamp = new Date().toISOString()
+
+    observer.next([
+      {
+        _id: 'doc1',
+        _type: 'doc',
+        _updatedAt: timestamp,
+        result: {title: 'resolved'},
+        __projectionHash: projectionHash,
+      },
+      {
+        _id: 'drafts.doc1',
+        _type: 'doc',
+        _updatedAt: timestamp,
+        result: {title: 'resolved'},
+        __projectionHash: projectionHash,
+      },
+    ])
+
+    const {values} = state.get()
+    expect(values['doc1']?.[projectionHash]).toEqual({
+      isPending: false,
+      data: {
+        title: 'resolved',
+        status: {
+          lastEditedDraftAt: timestamp,
+          lastEditedPublishedAt: timestamp,
+        },
+      },
+    })
 
     subscription.unsubscribe()
+    expect(teardown).toHaveBeenCalled()
   })
 
   it('handles new subscriptions optimistically with pending states', async () => {
+    const projection = '{title, description}'
+    const projectionHash = hashString(projection)
+
     state.set('initializeValues', {
-      documentProjections: {doc1: '{title, description}', doc2: '{title, description}'},
-      values: {doc1: {data: {title: 'Doc 1'}, isPending: false}},
-      subscriptions: {doc1: {sub1: true}},
+      documentProjections: {
+        doc1: {[projectionHash]: projection},
+        doc2: {[projectionHash]: projection},
+      },
+      values: {doc1: {[projectionHash]: {data: {title: 'Doc 1'}, isPending: false}}},
+      // Add projectionHash level to subscriptions
+      subscriptions: {doc1: {[projectionHash]: {sub1: true}}},
     })
 
     const subscription = subscribeToStateAndFetchBatches({instance, state})
 
-    // Add a subscription for a document already in the batch
+    // Add another subscription for doc1 (same hash)
     state.set('addSubscriptionAlreadyInBatch', (prev) => ({
-      subscriptions: {doc1: {sub1: true, ...prev.subscriptions['doc1'], sub2: true}},
+      // Only need to update subscriptions here
+      subscriptions: {
+        ...prev.subscriptions,
+        doc1: {
+          ...(prev.subscriptions['doc1'] ?? {}),
+          [projectionHash]: {
+            ...(prev.subscriptions['doc1']?.[projectionHash] ?? {}),
+            sub2: true,
+          },
+        },
+      },
     }))
 
     // this isn't a new subscription so it isn't pending by design.
     // the pending state is intended to only appear for new documents
-    expect(state.get().values['doc1']).toEqual({data: {title: 'Doc 1'}, isPending: false})
+    expect(state.get().values['doc1']?.[projectionHash]).toEqual({
+      data: {title: 'Doc 1'},
+      isPending: false,
+    })
 
     expect(state.get().values['doc2']).toBeUndefined()
 
-    state.set('addSubscriptionNotInBatch', {
-      subscriptions: {doc2: {sub1: true}},
-    })
+    // Add subscription for doc2 (same hash)
+    state.set('addSubscriptionNotInBatch', (prev) => ({
+      // Only need to update subscriptions here
+      subscriptions: {
+        ...prev.subscriptions,
+        doc2: {
+          ...(prev.subscriptions['doc2'] ?? {}),
+          [projectionHash]: {
+            ...(prev.subscriptions['doc2']?.[projectionHash] ?? {}),
+            sub1: true,
+          },
+        },
+      },
+    }))
 
-    await new Promise((resolve) => setTimeout(resolve, 100))
+    // Wait for the debounced optimistic update to occur
+    await new Promise((resolve) => setTimeout(resolve, 50 + 10)) // Wait slightly longer than debounce (50ms)
 
-    expect(state.get().values['doc2']).toEqual({data: null, isPending: true})
+    // Check state for doc2 (should now be pending)
+    expect(state.get().values['doc2']?.[projectionHash]).toEqual({data: null, isPending: true})
 
     subscription.unsubscribe()
   })
 
   it('cancels and restarts fetches when subscription set changes', async () => {
+    const abortSpy = vi.spyOn(AbortController.prototype, 'abort')
     const subscription = subscribeToStateAndFetchBatches({instance, state})
+    const projection = '{title, description}'
+    const projectionHash = hashString(projection)
+    const projection2 = '{_id}' // Different projection
+    const projectionHash2 = hashString(projection2)
 
     // Add initial subscription
     state.set('addSubscription1', {
-      documentProjections: {doc1: '{title, description}'},
-      subscriptions: {doc1: {sub1: true}},
+      documentProjections: {doc1: {[projectionHash]: projection}},
+      // Add projectionHash level to subscriptions
+      subscriptions: {doc1: {[projectionHash]: {sub1: true}}},
     })
 
     await new Promise((resolve) => setTimeout(resolve, 100))
+    const initialQueryCallCount = vi.mocked(getQueryState).mock.calls.length
 
-    // Add another subscription before first fetch completes
+    // Add another subscription (different doc, different projection) - This should trigger abort + new fetch
     state.set('addSubscription2', (prev) => ({
-      documentProjections: {...prev.documentProjections, doc2: '{title, description}'},
-      subscriptions: {...prev.subscriptions, doc2: {sub2: true}},
+      documentProjections: {...prev.documentProjections, doc2: {[projectionHash2]: projection2}},
+      // Add projectionHash level to subscriptions
+      subscriptions: {
+        ...prev.subscriptions,
+        doc2: {[projectionHash2]: {sub2: true}},
+      },
     }))
 
     await new Promise((resolve) => setTimeout(resolve, 100))
 
-    expect(mockFetch).toHaveBeenCalledTimes(2)
+    // Expected calls:
+    // 1. Initial fetch (doc1, hash1)
+    // 2. Adding doc2 subscription (optimistic update, no fetch)
+    // 3. Debounced fetch for (doc1, hash1) AND (doc2, hash2)
+    expect(getQueryState).toHaveBeenCalledTimes(initialQueryCallCount + 1)
+    // Abort should have been called because the required projections changed
+    expect(abortSpy).toHaveBeenCalled()
 
     subscription.unsubscribe()
   })
 
-  it('only refetches when actually needed due to distinctUntilChanged() usage', async () => {
-    const subscription = subscribeToStateAndFetchBatches({instance, state})
-
-    // Add a subscription
-    state.set('addSubscription', {
-      documentProjections: {doc1: '{title, description}'},
-      subscriptions: {doc1: {sub1: true}},
-    })
-
-    await new Promise((resolve) => setTimeout(resolve, 100))
-
-    // Update state but don't change subscriptions
-    state.set('unrelatedChange', {
-      syncTags: {'s1:tag1': true},
-    })
-
-    await new Promise((resolve) => setTimeout(resolve, 100))
-
-    expect(mockFetch).toHaveBeenCalledTimes(1)
+  it('processes and applies fetch results correctly', async () => {
+    const subscriber =
+      vi.fn<(observer: Observer<ProjectionQueryResult[] | undefined>) => () => void>()
 
-    subscription.unsubscribe()
-  })
+    vi.mocked(getQueryState).mockReturnValue({
+      getCurrent: () => undefined,
+      observable: new Observable(subscriber),
+    } as StateSource<ProjectionQueryResult[] | undefined>)
 
-  it('processes and applies fetch results correctly', async () => {
     const subscription = subscribeToStateAndFetchBatches({instance, state})
+    const projection = '{title, description}'
+    const projectionHash = hashString(projection)
 
     // Add a subscription
     state.set('addSubscription', {
-      documentProjections: {doc1: '{title, description}'},
-      subscriptions: {doc1: {sub1: true}},
+      documentProjections: {doc1: {[projectionHash]: projection}},
+      // Add projectionHash level to subscriptions
+      subscriptions: {doc1: {[projectionHash]: {sub1: true}}},
     })
 
     await new Promise((resolve) => setTimeout(resolve, 100))
 
+    expect(subscriber).toHaveBeenCalled()
+    const [observer] = subscriber.mock.lastCall!
+
     // Emit fetch results
-    fetchResults.next({
-      result: [
-        {
-          _id: 'doc1',
-          _type: 'test',
-          _updatedAt: '2024-01-01T00:00:00Z',
-          result: {title: 'Test Document', description: 'Test Description'},
-        },
-      ],
-      syncTags: ['s1:tag1', 's1:tag2'],
-    })
+    const timestamp = '2024-01-01T00:00:00Z'
+    observer.next([
+      {
+        _id: 'doc1',
+        _type: 'test',
+        _updatedAt: timestamp,
+        result: {title: 'Test Document', description: 'Test Description'},
+        __projectionHash: projectionHash,
+      },
+    ])
 
     // Check that the state was updated
-    expect(state.get().values['doc1']).toEqual({
+    expect(state.get().values['doc1']?.[projectionHash]).toEqual({
       data: expect.objectContaining({
         title: 'Test Document',
         description: 'Test Description',
         status: {
-          lastEditedPublishedAt: '2024-01-01T00:00:00Z',
+          lastEditedPublishedAt: timestamp,
         },
       }),
       isPending: false,
     })
-    expect(state.get().syncTags).toEqual({
-      's1:tag1': true,
-      's1:tag2': true,
-    })
 
     subscription.unsubscribe()
   })