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

package/src/projection/getProjectionState.test.ts

@@ -1,52 +1,52 @@
-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 {describe, it} from 'vitest'
+
+import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
+import {type StoreState} from '../store/createStoreState'
 import {insecureRandomId} from '../utils/ids'
 import {getProjectionState} from './getProjectionState'
-import {projectionStore, type ProjectionStoreState} from './projectionStore'
-import {STABLE_EMPTY_PROJECTION} from './util'
+import {type ProjectionStoreState} from './projectionStore'
+import {subscribeToStateAndFetchBatches} from './subscribeToStateAndFetchBatches'
+import {PROJECTION_STATE_CLEAR_DELAY, STABLE_EMPTY_PROJECTION} from './util'
 
 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('./subscribeToStateAndFetchBatches.ts')
 
 describe('getProjectionState', () => {
-  const instance = createSanityInstance({projectId: 'exampleProject', dataset: 'exampleDataset'})
-  const document = {_id: 'exampleId', _type: 'exampleType'}
+  let instance: SanityInstance
+  const docHandle = {documentId: 'exampleId', documentType: 'exampleType'}
   const projection = '{exampleProjection}'
-  const initialState: ProjectionStoreState = {
-    values: {},
-    documentProjections: {},
-    subscriptions: {},
-    syncTags: {},
-    lastLiveEventId: null,
-  }
-  let state: ResourceState<ProjectionStoreState>
+  let state: StoreState<ProjectionStoreState & {extra?: unknown}>
 
   beforeEach(() => {
-    state = createResourceState(initialState)
+    // 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 after each test
   })
 
   it('returns a state source that emits when the projection value changes', () => {
-    const projectionState = getProjectionState({state, instance}, {document, projection})
+    const projectionState = getProjectionState(instance, {projection, ...docHandle})
     expect(projectionState.getCurrent()).toBe(STABLE_EMPTY_PROJECTION)
 
     const subscriber = vi.fn()
     projectionState.subscribe(subscriber)
 
     // emit unrelated state changes
-    state.set('updateLastLiveEventId', {lastLiveEventId: 'newLastLiveEventId'})
+    state.set('updateLastLiveEventId', {extra: 'unrelated change'})
     expect(subscriber).toHaveBeenCalledTimes(0)
 
     state.set('relatedChange', (prev) => ({
@@ -69,55 +69,75 @@ describe('getProjectionState', () => {
   })
 
   it('adds a subscription ID and projection to the state on subscription', () => {
-    const projectionState = getProjectionState({state, instance}, {document, projection})
+    const projectionState = getProjectionState(instance, {projection, ...docHandle})
 
     expect(state.get().subscriptions).toEqual({})
-    vi.mocked(insecureRandomId)
-      .mockImplementationOnce(() => 'pseudoRandomId1')
-      .mockImplementationOnce(() => 'pseudoRandomId2')
+    vi.mocked(insecureRandomId).mockImplementationOnce(() => 'pseudoRandomId1')
 
     const unsubscribe1 = projectionState.subscribe(vi.fn())
-    const unsubscribe2 = projectionState.subscribe(vi.fn())
 
     expect(state.get().subscriptions).toEqual({
-      exampleId: {pseudoRandomId1: true, pseudoRandomId2: true},
+      exampleId: {pseudoRandomId1: true},
     })
     expect(state.get().documentProjections).toEqual({
       exampleId: projection,
     })
 
-    unsubscribe2()
+    // Unsubscribe the last one - state should NOT clear immediately
+    unsubscribe1()
     expect(state.get().subscriptions).toEqual({
       exampleId: {pseudoRandomId1: true},
     })
+    // Projection data might also remain initially
+    expect(state.get().documentProjections).toEqual({
+      exampleId: projection,
+    })
 
-    unsubscribe1()
+    // Advance timers past the clear delay
+    vi.advanceTimersByTime(PROJECTION_STATE_CLEAR_DELAY)
+
+    // NOW the state related to this document should be cleared
     expect(state.get().subscriptions).toEqual({})
+    expect(state.get().documentProjections).toEqual({exampleId: projection})
   })
 
   it('resets to pending false on unsubscribe if the subscription is the last one', () => {
+    const projectionState = getProjectionState(instance, {projection, ...docHandle})
+
     state.set('presetValueToPending', (prev) => ({
-      values: {...prev.values, [document._id]: {data: {field: 'Foo'}, isPending: true}},
+      values: {...prev.values, [docHandle.documentId]: {data: {field: 'Foo'}, isPending: true}},
     }))
 
-    const projectionState = getProjectionState({state, instance}, {document, projection})
-
     const unsubscribe1 = projectionState.subscribe(vi.fn())
-    const unsubscribe2 = projectionState.subscribe(vi.fn())
 
-    expect(state.get().values[document._id]).toEqual({data: {field: 'Foo'}, isPending: true})
+    expect(state.get().values[docHandle.documentId]).toEqual({
+      data: {field: 'Foo'},
+      isPending: true,
+    })
 
+    // Unsubscribe one - pending state remains
     unsubscribe1()
-    expect(state.get().values[document._id]).toEqual({data: {field: 'Foo'}, isPending: true})
+    expect(state.get().values[docHandle.documentId]).toEqual({
+      data: {field: 'Foo'},
+      isPending: true,
+    })
 
-    unsubscribe2()
-    expect(state.get().subscriptions).toEqual({})
-    expect(state.get().values[document._id]).toEqual({data: {field: 'Foo'}, isPending: false})
-  })
+    // Unsubscribe the last one - pending state should NOT reset immediately
+    expect(Object.keys(state.get().subscriptions['exampleId'] || {}).length).toBeGreaterThan(0)
+    expect(state.get().values[docHandle.documentId]).toEqual({
+      data: {field: 'Foo'},
+      isPending: true, // Still pending
+    })
+
+    // Advance timers past the clear delay
+    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
+    expect(state.get().values[docHandle.documentId]).toEqual({
+      data: {field: 'Foo'},
+      isPending: false, // Reset to false
+    })
+    // And subscriptions should be cleared now
+    expect(state.get().subscriptions).toEqual({})
   })
 })

package/src/projection/getProjectionState.ts

@@ -1,9 +1,13 @@
 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 {type DocumentHandle} from '../config/sanityConfig'
+import {bindActionByDataset} from '../store/createActionBinder'
+import {type SanityInstance} from '../store/createSanityInstance'
+import {
+  createStateSourceAction,
+  type SelectorContext,
+  type StateSource,
+} from '../store/createStateSourceAction'
 import {getPublishedId, insecureRandomId} from '../utils/ids'
 import {
   projectionStore,
@@ -11,31 +15,24 @@ import {
   type ProjectionValuePending,
   type ValidProjection,
 } from './projectionStore'
-import {STABLE_EMPTY_PROJECTION, validateProjection} from './util'
+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,39 +47,34 @@ 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> =>
+      state.values[options.documentId] ?? STABLE_EMPTY_PROJECTION,
+    onSubscribe: ({state}, {projection, ...docHandle}: GetProjectionStateOptions) => {
+      const subscriptionId = insecureRandomId()
+      const documentId = getPublishedId(docHandle.documentId)
 
-        state.set('addSubscription', (prev) => ({
-          documentProjections: {
-            ...prev.documentProjections,
-            [documentId]: validateProjection(projection),
-          },
-          subscriptions: {
-            ...prev.subscriptions,
-            [documentId]: {
-              ...prev.subscriptions[documentId],
-              [subscriptionId]: true,
-            },
+      state.set('addSubscription', (prev) => ({
+        documentProjections: {
+          ...prev.documentProjections,
+          [documentId]: validateProjection(projection),
+        },
+        subscriptions: {
+          ...prev.subscriptions,
+          [documentId]: {
+            ...prev.subscriptions[documentId],
+            [subscriptionId]: true,
           },
-        }))
-
-        const unsubscribe = projectionState.subscribe(subscriber)
-
-        return () => {
-          unsubscribe()
+        },
+      }))
 
+      return () => {
+        setTimeout(() => {
           state.set('removeSubscription', (prev): Partial<ProjectionStoreState> => {
             const documentSubscriptions = omit(prev.subscriptions[documentId], subscriptionId)
             const hasSubscribers = !!Object.keys(documentSubscriptions).length
@@ -98,8 +90,8 @@ export const _getProjectionState = createAction(projectionStore, ({state}) => {
                 : {...prev.values, [documentId]: {data: projectionValue, isPending: false}},
             }
           })
-        }
-      },
-    }
-  }
-})
+        }, PROJECTION_STATE_CLEAR_DELAY)
+      }
+    },
+  }),
+)

package/src/projection/projectionQuery.ts

@@ -1,4 +1,4 @@
-import {hashString} from '../common/util'
+import {hashString} from '../utils/hashString'
 import {getDraftId, getPublishedId} from '../utils/ids'
 import {type ProjectionValuePending, type ValidProjection} from './projectionStore'
 import {validateProjection} from './util'

package/src/projection/projectionStore.test.ts

@@ -1,11 +1,10 @@
-import {type Subscription} from 'rxjs'
-import {describe, expect, it, type Mock, vi} from 'vitest'
+import {Observable} from 'rxjs'
+import {describe, it, vi} from 'vitest'
 
-import {createSanityInstance} from '../instance/sanityInstance'
-import {createResourceState} from '../resources/createResource'
+import {createSanityInstance} from '../store/createSanityInstance'
+import {createStoreInstance} from '../store/createStoreInstance'
 import {projectionStore} from './projectionStore'
 import {subscribeToStateAndFetchBatches} from './subscribeToStateAndFetchBatches'
-import {PROJECTION_TAG} from './util'
 
 // Mock the module with a factory function
 vi.mock('../common/createLiveEventSubscriber', () => {
@@ -15,61 +14,24 @@ vi.mock('../common/createLiveEventSubscriber', () => {
   }
 })
 
-vi.mock('./subscribeToStateAndFetchBatches', () => ({
-  subscribeToStateAndFetchBatches: vi.fn(),
-}))
+vi.mock('./subscribeToStateAndFetchBatches')
 
 describe('projectionStore', () => {
   it('is a resource that initializes with state and subscriptions', async () => {
-    const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
-    const initialState = projectionStore.getInitialState(instance)
-
-    expect(initialState).toEqual({
-      values: {},
-      documentProjections: {},
-      subscriptions: {},
-      syncTags: {},
-      lastLiveEventId: null,
-    })
-
-    const liveUnsubscribe = vi.fn()
-    const stateUnsubscribe = vi.fn()
-
-    const {createLiveEventSubscriber} = vi.mocked(
-      await import('../common/createLiveEventSubscriber'),
+    const teardown = vi.fn()
+    const subscriber = vi.fn().mockReturnValue(teardown)
+    vi.mocked(subscribeToStateAndFetchBatches).mockReturnValue(
+      new Observable(subscriber).subscribe(),
     )
-    const mockLiveSubscriber = vi
-      .mocked(createLiveEventSubscriber(PROJECTION_TAG))
-      .mockReturnValue({
-        unsubscribe: liveUnsubscribe,
-      } as unknown as Subscription)
-
-    ;(subscribeToStateAndFetchBatches as Mock).mockImplementation(() => ({
-      unsubscribe: stateUnsubscribe,
-    }))
 
-    const dispose = projectionStore.initialize!.call(
-      {
-        instance,
-        state: createResourceState(initialState),
-      },
-      instance,
-    )
-
-    // Verify the factory was called with the correct tag
-    expect(createLiveEventSubscriber).toHaveBeenCalledWith(PROJECTION_TAG)
+    const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
 
-    // Verify the subscriber was called with the correct context
-    expect(mockLiveSubscriber).toHaveBeenCalledWith({
-      instance,
-      state: expect.any(Object),
-    })
+    const {state, dispose} = createStoreInstance(instance, projectionStore)
 
     expect(subscribeToStateAndFetchBatches).toHaveBeenCalledOnce()
+    expect(subscribeToStateAndFetchBatches).toHaveBeenCalledWith({instance, state})
 
     dispose()
-
-    expect(liveUnsubscribe).toHaveBeenCalledOnce()
-    expect(stateUnsubscribe).toHaveBeenCalledOnce()
+    instance.dispose()
   })
 })

package/src/projection/projectionStore.ts

@@ -1,8 +1,5 @@
-import {createLiveEventSubscriber} from '../common/createLiveEventSubscriber'
-import {type LiveEventAwareState} from '../common/types'
-import {createResource} from '../resources/createResource'
+import {defineStore} from '../store/defineStore'
 import {subscribeToStateAndFetchBatches} from './subscribeToStateAndFetchBatches'
-import {PROJECTION_TAG} from './util'
 
 /**
  * @beta
@@ -24,32 +21,23 @@ export interface ProjectionValuePending<TValue extends object> {
   isPending: boolean
 }
 
-export interface ProjectionStoreState<TValue extends object = object> extends LiveEventAwareState {
+export interface ProjectionStoreState<TValue extends object = object> {
   values: {[TDocumentId in string]?: ProjectionValuePending<TValue>}
   documentProjections: {[TDocumentId in string]?: ValidProjection}
   subscriptions: {[TDocumentId in string]?: {[TSubscriptionId in string]?: true}}
 }
 
-export const projectionStore = createResource<ProjectionStoreState>({
+export const projectionStore = defineStore<ProjectionStoreState>({
   name: 'Projection',
   getInitialState() {
     return {
       values: {},
       documentProjections: {},
       subscriptions: {},
-      syncTags: {},
-      lastLiveEventId: null,
     }
   },
-  initialize() {
-    const subscribeToLiveAndSetLastLiveEventId =
-      createLiveEventSubscriber<ProjectionStoreState>(PROJECTION_TAG)
-    const liveSubscription = subscribeToLiveAndSetLastLiveEventId(this)
-    const batchSubscription = subscribeToStateAndFetchBatches(this)
-
-    return () => {
-      liveSubscription.unsubscribe()
-      batchSubscription.unsubscribe()
-    }
+  initialize(context) {
+    const batchSubscription = subscribeToStateAndFetchBatches(context)
+    return () => batchSubscription.unsubscribe()
   },
 })

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 {type ProjectionValuePending, type ValidProjection} from './projectionStore'
 import {resolveProjection} from './resolveProjection'
 
-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)
-  })
 })