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

package/src/projection/getProjectionState.test.ts

@@ -1,123 +1,239 @@
-import {describe, it, type Mock} from 'vitest'
-
-import {createSanityInstance} from '../instance/sanityInstance'
-import {
-  createResourceState,
-  getOrCreateResource,
-  type ResourceState,
-} from '../resources/createResource'
+import {NEVER} from 'rxjs'
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
+
+import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
+import {type StoreState} from '../store/createStoreState'
+import {hashString} from '../utils/hashString'
 import {insecureRandomId} from '../utils/ids'
 import {getProjectionState} from './getProjectionState'
-import {projectionStore, type ProjectionStoreState} from './projectionStore'
-import {STABLE_EMPTY_PROJECTION} from './util'
+import {subscribeToStateAndFetchBatches} from './subscribeToStateAndFetchBatches'
+import {type ProjectionStoreState} from './types'
+import {PROJECTION_STATE_CLEAR_DELAY, STABLE_EMPTY_PROJECTION} from './util'
+// mocking subscription counts is a little tricky.
+// all test ids in this file start at 2 because the first call to onSubscribe
+// happens within createStateSourceAction
+let mockIdCounter = 0
 
 vi.mock('../utils/ids', async (importOriginal) => {
   const util = await importOriginal<typeof import('../utils/ids')>()
-  return {...util, insecureRandomId: vi.fn(util.insecureRandomId)}
+  // Mock implementation uses the external counter
+  return {
+    ...util,
+    insecureRandomId: vi.fn(() => {
+      const id = `testSubId_${++mockIdCounter}`
+      return id
+    }),
+  }
 })
 
-vi.mock('../resources/createResource', async (importOriginal) => {
-  const original = await importOriginal<typeof import('../resources/createResource')>()
-  return {...original, getOrCreateResource: vi.fn()}
-})
+vi.mock('./subscribeToStateAndFetchBatches.ts')
 
 describe('getProjectionState', () => {
-  const instance = createSanityInstance({projectId: 'exampleProject', dataset: 'exampleDataset'})
-  const document = {_id: 'exampleId', _type: 'exampleType'}
-  const projection = '{exampleProjection}'
-  const initialState: ProjectionStoreState = {
-    values: {},
-    documentProjections: {},
-    subscriptions: {},
-    syncTags: {},
-    lastLiveEventId: null,
-  }
-  let state: ResourceState<ProjectionStoreState>
+  let instance: SanityInstance
+  const docHandle = {documentId: 'exampleId', documentType: 'exampleType'}
+  const projection1 = '{exampleProjection1}'
+  const hash1 = hashString(projection1)
+  const projection2 = '{exampleProjection2}'
+  const hash2 = hashString(projection2)
+
+  let state: StoreState<ProjectionStoreState & {extra?: unknown}>
 
   beforeEach(() => {
-    state = createResourceState(initialState)
+    mockIdCounter = 0
+    vi.mocked(insecureRandomId).mockClear()
+
+    // Capture state
+    vi.mocked(subscribeToStateAndFetchBatches).mockImplementation((context) => {
+      state = context.state
+      return NEVER.subscribe()
+    })
+
+    instance = createSanityInstance({projectId: 'exampleProject', dataset: 'exampleDataset'})
+    vi.useFakeTimers() // Enable fake timers for each test
+  })
+
+  afterEach(() => {
+    instance.dispose()
+    vi.useRealTimers() // Restore real timers
   })
 
-  it('returns a state source that emits when the projection value changes', () => {
-    const projectionState = getProjectionState({state, instance}, {document, projection})
-    expect(projectionState.getCurrent()).toBe(STABLE_EMPTY_PROJECTION)
+  it('returns a state source that emits when the specific projection value changes', () => {
+    const projectionState = getProjectionState(instance, {projection: projection1, ...docHandle})
+    expect(projectionState.getCurrent()).toEqual(STABLE_EMPTY_PROJECTION)
 
     const subscriber = vi.fn()
-    projectionState.subscribe(subscriber)
+    const unsubscribe = projectionState.subscribe(subscriber)
 
-    // emit unrelated state changes
-    state.set('updateLastLiveEventId', {lastLiveEventId: 'newLastLiveEventId'})
-    expect(subscriber).toHaveBeenCalledTimes(0)
+    // 1. Update the specific projection
+    state.set('update_doc1_proj1', (prev: ProjectionStoreState) => ({
+      values: {
+        ...prev.values,
+        [docHandle.documentId]: {
+          ...prev.values[docHandle.documentId],
+          [hash1]: {data: {name: 'Update 1'}, isPending: false},
+        },
+      },
+    }))
+    expect(subscriber).toHaveBeenCalledTimes(1)
+    expect(projectionState.getCurrent()).toEqual({data: {name: 'Update 1'}, isPending: false})
 
-    state.set('relatedChange', (prev) => ({
-      values: {...prev.values, exampleId: {data: {field: 'Changed!'}, isPending: false}},
+    // 2. Update a different projection for the same document
+    state.set('update_doc1_proj2', (prev: ProjectionStoreState) => ({
+      values: {
+        ...prev.values,
+        [docHandle.documentId]: {
+          ...prev.values[docHandle.documentId],
+          [hash2]: {data: {_type: 'type1'}, isPending: false},
+        },
+      },
     }))
+    // Should NOT trigger the subscriber for projection1
     expect(subscriber).toHaveBeenCalledTimes(1)
+    expect(projectionState.getCurrent()).toEqual({data: {name: 'Update 1'}, isPending: false})
 
-    state.set('unrelatedChange', (prev) => ({
+    // 3. Update a different document
+    state.set('update_doc2', (prev: ProjectionStoreState) => ({
       values: {
         ...prev.values,
-        unrelatedId: {data: {field: 'Unrelated Document'}, isPending: false},
+        doc2: {
+          [hash1]: {data: {name: 'Other Doc'}, isPending: false},
+        },
       },
     }))
+    // Should NOT trigger the subscriber for doc1/projection1
     expect(subscriber).toHaveBeenCalledTimes(1)
 
-    state.set('relatedChange', (prev) => ({
-      values: {...prev.values, exampleId: {data: {field: 'Changed again!'}, isPending: false}},
+    // 4. Update the specific projection again
+    state.set('update_doc1_proj1_again', (prev: ProjectionStoreState) => ({
+      values: {
+        ...prev.values,
+        [docHandle.documentId]: {
+          ...prev.values[docHandle.documentId],
+          [hash1]: {data: {name: 'Update 2'}, isPending: false},
+        },
+      },
     }))
     expect(subscriber).toHaveBeenCalledTimes(2)
+    expect(projectionState.getCurrent()).toEqual({data: {name: 'Update 2'}, isPending: false})
+
+    unsubscribe()
   })
 
-  it('adds a subscription ID and projection to the state on subscription', () => {
-    const projectionState = getProjectionState({state, instance}, {document, projection})
+  it('adds a subscription ID and projection to the correct hash on subscription and cleans up', () => {
+    const projectionState1 = getProjectionState(instance, {projection: projection1, ...docHandle})
+    const projectionState2 = getProjectionState(instance, {projection: projection2, ...docHandle})
 
     expect(state.get().subscriptions).toEqual({})
-    vi.mocked(insecureRandomId)
-      .mockImplementationOnce(() => 'pseudoRandomId1')
-      .mockImplementationOnce(() => 'pseudoRandomId2')
+    expect(state.get().documentProjections).toEqual({})
 
-    const unsubscribe1 = projectionState.subscribe(vi.fn())
-    const unsubscribe2 = projectionState.subscribe(vi.fn())
+    const unsubscribe1 = projectionState1.subscribe(vi.fn()) // Should use ID 3
+    expect(state.get().subscriptions).toEqual({
+      [docHandle.documentId]: {[hash1]: {testSubId_2: true}},
+    })
+    expect(state.get().documentProjections).toEqual({
+      [docHandle.documentId]: {[hash1]: projection1},
+    })
 
+    const unsubscribe2 = projectionState2.subscribe(vi.fn()) // Should use ID 4
     expect(state.get().subscriptions).toEqual({
-      exampleId: {pseudoRandomId1: true, pseudoRandomId2: true},
+      [docHandle.documentId]: {
+        [hash1]: {testSubId_2: true},
+        [hash2]: {testSubId_3: true},
+      },
     })
     expect(state.get().documentProjections).toEqual({
-      exampleId: projection,
+      [docHandle.documentId]: {
+        [hash1]: projection1,
+        [hash2]: projection2,
+      },
     })
 
-    unsubscribe2()
+    const unsubscribe3 = projectionState1.subscribe(vi.fn()) // Should use ID 5
     expect(state.get().subscriptions).toEqual({
-      exampleId: {pseudoRandomId1: true},
+      [docHandle.documentId]: {
+        [hash1]: {testSubId_2: true, testSubId_4: true},
+        [hash2]: {testSubId_3: true},
+      },
     })
 
-    unsubscribe1()
-    expect(state.get().subscriptions).toEqual({})
-  })
+    // projections state should remain the same, even with multiple subscribers
+    expect(state.get().documentProjections).toEqual({
+      [docHandle.documentId]: {
+        [hash1]: projection1,
+        [hash2]: projection2,
+      },
+    })
 
-  it('resets to pending false on unsubscribe if the subscription is the last one', () => {
-    state.set('presetValueToPending', (prev) => ({
-      values: {...prev.values, [document._id]: {data: {field: 'Foo'}, isPending: true}},
-    }))
+    // --- Test Unsubscribe ---
+    unsubscribe1() // Unsubscribes ID 3
+    expect(state.get().subscriptions[docHandle.documentId]?.[hash1]).toEqual({
+      testSubId_2: true,
+      testSubId_4: true,
+    })
+    vi.advanceTimersByTime(PROJECTION_STATE_CLEAR_DELAY)
+    expect(state.get().subscriptions[docHandle.documentId]?.[hash1]).toEqual({testSubId_4: true})
+    expect(state.get().documentProjections[docHandle.documentId]?.[hash1]).toEqual(projection1)
+
+    unsubscribe3() // Unsubscribes ID 5
+    vi.advanceTimersByTime(PROJECTION_STATE_CLEAR_DELAY)
+    expect(state.get().subscriptions[docHandle.documentId]?.[hash1]).toBeUndefined()
+    expect(state.get().documentProjections[docHandle.documentId]?.[hash1]).toBeUndefined()
+    expect(state.get().subscriptions[docHandle.documentId]?.[hash2]).toEqual({testSubId_3: true})
+    expect(state.get().documentProjections[docHandle.documentId]?.[hash2]).toEqual(projection2)
+
+    unsubscribe2() // Unsubscribes ID 4
+    vi.advanceTimersByTime(PROJECTION_STATE_CLEAR_DELAY)
+    expect(state.get().subscriptions[docHandle.documentId]).toBeUndefined()
+    expect(state.get().documentProjections[docHandle.documentId]).toBeUndefined()
+  })
 
-    const projectionState = getProjectionState({state, instance}, {document, projection})
+  it('resets isPending to false for the specific projection on final unsubscribe for that projection', () => {
+    const projectionState = getProjectionState(instance, {projection: projection1, ...docHandle})
+    const initialData = {name: 'Initial Name'}
+    const hash = hashString(projection1)
 
-    const unsubscribe1 = projectionState.subscribe(vi.fn())
-    const unsubscribe2 = projectionState.subscribe(vi.fn())
+    state.set('presetValueToPending', (prev: ProjectionStoreState) => ({
+      values: {
+        ...prev.values,
+        [docHandle.documentId]: {
+          ...prev.values[docHandle.documentId],
+          [hash]: {data: initialData, isPending: true},
+        },
+      },
+    }))
 
-    expect(state.get().values[document._id]).toEqual({data: {field: 'Foo'}, isPending: true})
+    const unsubscribe1 = projectionState.subscribe(vi.fn()) // Should use ID 2
+    const unsubscribe2 = projectionState.subscribe(vi.fn()) // Should use ID 3
 
-    unsubscribe1()
-    expect(state.get().values[document._id]).toEqual({data: {field: 'Foo'}, isPending: true})
+    expect(state.get().values[docHandle.documentId]?.[hash]).toEqual({
+      data: initialData,
+      isPending: true,
+    })
 
-    unsubscribe2()
-    expect(state.get().subscriptions).toEqual({})
-    expect(state.get().values[document._id]).toEqual({data: {field: 'Foo'}, isPending: false})
-  })
+    unsubscribe1() // Unsubscribes ID 2
+    vi.advanceTimersByTime(PROJECTION_STATE_CLEAR_DELAY)
+    expect(state.get().values[docHandle.documentId]?.[hash]).toEqual({
+      data: initialData,
+      isPending: true,
+    })
+    expect(Object.keys(state.get().subscriptions[docHandle.documentId]?.[hash] ?? {}).length).toBe(
+      1,
+    )
+    expect(state.get().subscriptions[docHandle.documentId]?.[hash]).toEqual({testSubId_3: true})
+
+    unsubscribe2() // Unsubscribes ID 3
+    expect(state.get().values[docHandle.documentId]?.[hash]).toEqual({
+      data: initialData,
+      isPending: true,
+    })
+    vi.advanceTimersByTime(PROJECTION_STATE_CLEAR_DELAY)
 
-  it('calls getOrCreateResource if no state is provided', () => {
-    ;(getOrCreateResource as Mock).mockReturnValue({state})
-    getProjectionState(instance, {document, projection})
-    expect(getOrCreateResource).toHaveBeenCalledWith(instance, projectionStore)
+    // NOW the pending state should be reset for this specific projection
+    expect(state.get().values[docHandle.documentId]?.[hash]).toEqual({
+      data: initialData,
+      isPending: false,
+    })
+    expect(state.get().subscriptions[docHandle.documentId]?.[hash]).toBeUndefined()
+    expect(state.get().documentProjections[docHandle.documentId]?.[hash]).toBeUndefined()
   })
 })

package/src/projection/getProjectionState.ts

@@ -1,41 +1,35 @@
 import {omit} from 'lodash-es'
 
-import {type DocumentHandle} from '../document/patchOperations'
-import {type SanityInstance} from '../instance/types'
-import {type ActionContext, createAction} from '../resources/createAction'
-import {createStateSourceAction, type StateSource} from '../resources/createStateSourceAction'
-import {getPublishedId, insecureRandomId} from '../utils/ids'
+import {type DocumentHandle} from '../config/sanityConfig'
+import {bindActionByDataset} from '../store/createActionBinder'
+import {type SanityInstance} from '../store/createSanityInstance'
 import {
-  projectionStore,
-  type ProjectionStoreState,
-  type ProjectionValuePending,
-  type ValidProjection,
-} from './projectionStore'
-import {STABLE_EMPTY_PROJECTION, validateProjection} from './util'
+  createStateSourceAction,
+  type SelectorContext,
+  type StateSource,
+} from '../store/createStateSourceAction'
+import {hashString} from '../utils/hashString'
+import {getPublishedId, insecureRandomId} from '../utils/ids'
+import {projectionStore} from './projectionStore'
+import {type ProjectionStoreState, type ProjectionValuePending, type ValidProjection} from './types'
+import {PROJECTION_STATE_CLEAR_DELAY, STABLE_EMPTY_PROJECTION, validateProjection} from './util'
 
-interface GetProjectionStateOptions {
-  document: DocumentHandle
+interface GetProjectionStateOptions extends DocumentHandle {
   projection: ValidProjection
 }
 
-const getProjectStateSourceAction = createStateSourceAction(
-  projectionStore,
-  (state, {document}: GetProjectionStateOptions): ProjectionValuePending<object> =>
-    state.values[document._id] ?? STABLE_EMPTY_PROJECTION,
-)
-
 /**
  * @beta
  */
 export function getProjectionState<TResult extends object>(
-  instance: SanityInstance | ActionContext<ProjectionStoreState>,
+  instance: SanityInstance,
   options: GetProjectionStateOptions,
 ): StateSource<ProjectionValuePending<TResult>>
 /**
  * @beta
  */
 export function getProjectionState(
-  instance: SanityInstance | ActionContext<ProjectionStoreState>,
+  instance: SanityInstance,
   options: GetProjectionStateOptions,
 ): StateSource<ProjectionValuePending<Record<string, unknown>>>
 /**
@@ -50,56 +44,92 @@ export function getProjectionState(
 /**
  * @beta
  */
-export const _getProjectionState = createAction(projectionStore, ({state}) => {
-  return function ({
-    document,
-    projection,
-  }: GetProjectionStateOptions): StateSource<ProjectionValuePending<object>> {
-    const {_id} = document
-    const documentId = getPublishedId(_id)
-    const projectionState = getProjectStateSourceAction(this, {document, projection})
-
-    return {
-      ...projectionState,
-      subscribe: (subscriber) => {
-        const subscriptionId = insecureRandomId()
+export const _getProjectionState = bindActionByDataset(
+  projectionStore,
+  createStateSourceAction({
+    selector: (
+      {state}: SelectorContext<ProjectionStoreState>,
+      options: GetProjectionStateOptions,
+    ): ProjectionValuePending<object> => {
+      const documentId = getPublishedId(options.documentId)
+      const projectionHash = hashString(options.projection)
+      return state.values[documentId]?.[projectionHash] ?? STABLE_EMPTY_PROJECTION
+    },
+    onSubscribe: ({state}, {projection, ...docHandle}: GetProjectionStateOptions) => {
+      const subscriptionId = insecureRandomId()
+      const documentId = getPublishedId(docHandle.documentId)
+      const validProjection = validateProjection(projection)
+      const projectionHash = hashString(validProjection)
 
-        state.set('addSubscription', (prev) => ({
-          documentProjections: {
-            ...prev.documentProjections,
-            [documentId]: validateProjection(projection),
+      state.set('addSubscription', (prev) => ({
+        documentProjections: {
+          ...prev.documentProjections,
+          [documentId]: {
+            ...prev.documentProjections[documentId],
+            [projectionHash]: validProjection,
           },
-          subscriptions: {
-            ...prev.subscriptions,
-            [documentId]: {
-              ...prev.subscriptions[documentId],
+        },
+        subscriptions: {
+          ...prev.subscriptions,
+          [documentId]: {
+            ...prev.subscriptions[documentId],
+            [projectionHash]: {
+              ...prev.subscriptions[documentId]?.[projectionHash],
               [subscriptionId]: true,
             },
           },
-        }))
+        },
+      }))
 
-        const unsubscribe = projectionState.subscribe(subscriber)
+      return () => {
+        setTimeout(() => {
+          state.set('removeSubscription', (prev): Partial<ProjectionStoreState> => {
+            const documentSubscriptionsForHash = omit(
+              prev.subscriptions[documentId]?.[projectionHash],
+              subscriptionId,
+            )
+            const hasSubscribersForProjection = !!Object.keys(documentSubscriptionsForHash).length
 
-        return () => {
-          unsubscribe()
+            const nextSubscriptions = {...prev.subscriptions}
+            const nextDocumentProjections = {...prev.documentProjections}
+            const nextValues = {...prev.values}
 
-          state.set('removeSubscription', (prev): Partial<ProjectionStoreState> => {
-            const documentSubscriptions = omit(prev.subscriptions[documentId], subscriptionId)
-            const hasSubscribers = !!Object.keys(documentSubscriptions).length
-            const prevValue = prev.values[documentId]
-            const projectionValue = prevValue?.data ? prevValue.data : null
+            // clean up the subscription and documentProjection if there are no subscribers
+            if (!hasSubscribersForProjection) {
+              delete nextSubscriptions[documentId]![projectionHash]
+              delete nextDocumentProjections[documentId]![projectionHash]
+
+              const currentProjectionValue = prev.values[documentId]?.[projectionHash]
+              if (currentProjectionValue && nextValues[documentId]) {
+                nextValues[documentId]![projectionHash] = {
+                  data: currentProjectionValue.data,
+                  isPending: false,
+                }
+              }
+            } else {
+              if (nextSubscriptions[documentId]) {
+                nextSubscriptions[documentId]![projectionHash] = documentSubscriptionsForHash
+              }
+            }
+
+            const hasAnySubscribersForDocument = Object.values(
+              nextSubscriptions[documentId] ?? {},
+            ).some((subs) => Object.keys(subs).length > 0)
+
+            if (!hasAnySubscribersForDocument) {
+              delete nextSubscriptions[documentId]
+              delete nextDocumentProjections[documentId]
+              // Keep nextValues[documentId] as cache
+            }
 
             return {
-              subscriptions: hasSubscribers
-                ? {...prev.subscriptions, [documentId]: documentSubscriptions}
-                : omit(prev.subscriptions, documentId),
-              values: hasSubscribers
-                ? prev.values
-                : {...prev.values, [documentId]: {data: projectionValue, isPending: false}},
+              subscriptions: nextSubscriptions,
+              documentProjections: nextDocumentProjections,
+              values: nextValues,
             }
           })
-        }
-      },
-    }
-  }
-})
+        }, PROJECTION_STATE_CLEAR_DELAY)
+      }
+    },
+  }),
+)