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

package/src/projection/projectionQuery.test.ts

@@ -1,48 +1,67 @@
 import {describe, expect, it} from 'vitest'
 
 import {createProjectionQuery, processProjectionQuery} from './projectionQuery'
+import {type ValidProjection} from './types'
 
 describe('createProjectionQuery', () => {
   it('creates a query and params for given ids and projections', () => {
     const ids = new Set(['doc1', 'doc2'])
+    const projectionHash: ValidProjection = '{title, description}'
     const documentProjections = {
-      doc1: '{title, description}',
-      doc2: '{title, description}',
+      doc1: {[projectionHash]: projectionHash},
+      doc2: {[projectionHash]: projectionHash},
     }
 
     const {query, params} = createProjectionQuery(ids, documentProjections)
     expect(query).toMatch(/.*_id in \$__ids_.*/)
     expect(Object.keys(params)).toHaveLength(1)
+    expect(params[`__ids_${projectionHash}`]).toBeDefined()
+    expect(params[`__ids_${projectionHash}`]).toHaveLength(4)
   })
 
   it('handles multiple different projections', () => {
     const ids = new Set(['doc1', 'doc2'])
+    const projectionHash1: ValidProjection = '{title, description}'
+    const projectionHash2: ValidProjection = '{name, age}'
     const documentProjections = {
-      doc1: '{title, description}',
-      doc2: '{name, age}',
+      doc1: {[projectionHash1]: projectionHash1},
+      doc2: {[projectionHash2]: projectionHash2},
     }
 
     const {query, params} = createProjectionQuery(ids, documentProjections)
     expect(query).toMatch(/.*_id in \$__ids_.*/)
     expect(Object.keys(params)).toHaveLength(2)
+    expect(params[`__ids_${projectionHash1}`]).toBeDefined()
+    expect(params[`__ids_${projectionHash1}`]).toHaveLength(2)
+    expect(params[`__ids_${projectionHash2}`]).toBeDefined()
+    expect(params[`__ids_${projectionHash2}`]).toHaveLength(2)
   })
 
   it('filters out ids without projections', () => {
     const ids = new Set(['doc1', 'doc2', 'doc3'])
+    const projectionHash1: ValidProjection = '{title}'
+    // projectionHash2 missing intentionally
+    const projectionHash3: ValidProjection = '{name}'
+
     const documentProjections = {
-      doc1: '{title}',
-      // doc2 missing intentionally
-      doc3: '{name}',
+      doc1: {[projectionHash1]: projectionHash1},
+      doc3: {[projectionHash3]: projectionHash3},
     }
 
     const {query, params} = createProjectionQuery(ids, documentProjections)
     expect(query).toMatch(/.*_id in \$__ids_.*/)
     expect(Object.keys(params)).toHaveLength(2)
+    expect(params[`__ids_${projectionHash1}`]).toBeDefined()
+    expect(params[`__ids_${projectionHash1}`]).toHaveLength(2)
+    expect(params[`__ids_${projectionHash3}`]).toBeDefined()
+    expect(params[`__ids_${projectionHash3}`]).toHaveLength(2)
   })
 })
 
 describe('processProjectionQuery', () => {
-  it('returns null if no results found', () => {
+  const testProjectionHash = '{...}'
+
+  it('returns structure with empty object if no results found', () => {
     const ids = new Set(['doc1'])
     const result = processProjectionQuery({
       projectId: 'p',
@@ -51,7 +70,39 @@ describe('processProjectionQuery', () => {
       results: [], // no results
     })
 
-    expect(result['doc1']).toEqual({data: null, isPending: false})
+    expect(result['doc1']).toEqual({})
+  })
+
+  it('returns structure with isPending:false and null data for ids with no results', () => {
+    const ids = new Set(['doc1', 'doc2'])
+    const results = [
+      {
+        _id: 'doc1',
+        _type: 'document',
+        _updatedAt: '2021-01-01',
+        result: {title: 'Hello', description: 'World'},
+        __projectionHash: testProjectionHash,
+      },
+    ]
+
+    const processed = processProjectionQuery({
+      projectId: 'p',
+      dataset: 'd',
+      ids,
+      results,
+    })
+
+    expect(processed['doc1']?.[testProjectionHash]).toEqual({
+      data: {
+        title: 'Hello',
+        description: 'World',
+        status: {
+          lastEditedPublishedAt: '2021-01-01',
+        },
+      },
+      isPending: false,
+    })
+    expect(processed['doc2']).toEqual({})
   })
 
   it('processes query results into projection values', () => {
@@ -61,6 +112,7 @@ describe('processProjectionQuery', () => {
         _type: 'document',
         _updatedAt: '2021-01-01',
         result: {title: 'Hello', description: 'World'},
+        __projectionHash: testProjectionHash,
       },
     ]
 
@@ -71,7 +123,7 @@ describe('processProjectionQuery', () => {
       results,
     })
 
-    expect(processed['doc1']).toEqual({
+    expect(processed['doc1']?.[testProjectionHash]).toEqual({
       data: {
         title: 'Hello',
         description: 'World',
@@ -90,12 +142,14 @@ describe('processProjectionQuery', () => {
         _type: 'document',
         _updatedAt: '2021-01-02',
         result: {title: 'Draft'},
+        __projectionHash: testProjectionHash,
       },
       {
         _id: 'doc1',
         _type: 'document',
         _updatedAt: '2021-01-01',
         result: {title: 'Published'},
+        __projectionHash: testProjectionHash,
       },
     ]
 
@@ -106,7 +160,7 @@ describe('processProjectionQuery', () => {
       results,
     })
 
-    expect(processed['doc1']).toEqual({
+    expect(processed['doc1']?.[testProjectionHash]).toEqual({
       data: {
         title: 'Draft',
         status: {
@@ -125,6 +179,7 @@ describe('processProjectionQuery', () => {
         _type: 'document',
         _updatedAt: '2021-01-01',
         result: {title: 'Published'},
+        __projectionHash: testProjectionHash,
       },
     ]
 
@@ -135,7 +190,7 @@ describe('processProjectionQuery', () => {
       results,
     })
 
-    expect(processed['doc1']).toEqual({
+    expect(processed['doc1']?.[testProjectionHash]).toEqual({
       data: {
         title: 'Published',
         status: {
@@ -145,4 +200,51 @@ describe('processProjectionQuery', () => {
       isPending: false,
     })
   })
+
+  it('handles multiple projections for the same document', () => {
+    const hash1 = '{title}'
+    const hash2 = '{description}'
+    const results = [
+      {
+        _id: 'doc1',
+        _type: 'document',
+        _updatedAt: '2021-01-01',
+        result: {title: 'Published Title'},
+        __projectionHash: hash1,
+      },
+      {
+        _id: 'doc1',
+        _type: 'document',
+        _updatedAt: '2021-01-01',
+        result: {description: 'Published Desc'},
+        __projectionHash: hash2,
+      },
+    ]
+
+    const processed = processProjectionQuery({
+      projectId: 'p',
+      dataset: 'd',
+      ids: new Set(['doc1']),
+      results,
+    })
+
+    expect(processed['doc1']?.[hash1]).toEqual({
+      data: {
+        title: 'Published Title',
+        status: {
+          lastEditedPublishedAt: '2021-01-01',
+        },
+      },
+      isPending: false,
+    })
+    expect(processed['doc1']?.[hash2]).toEqual({
+      data: {
+        description: 'Published Desc',
+        status: {
+          lastEditedPublishedAt: '2021-01-01',
+        },
+      },
+      isPending: false,
+    })
+  })
 })

package/src/projection/projectionQuery.ts

@@ -1,13 +1,16 @@
-import {hashString} from '../common/util'
 import {getDraftId, getPublishedId} from '../utils/ids'
-import {type ProjectionValuePending, type ValidProjection} from './projectionStore'
-import {validateProjection} from './util'
+import {
+  type DocumentProjections,
+  type DocumentProjectionValues,
+  type ValidProjection,
+} from './types'
 
-type ProjectionQueryResult = {
+export type ProjectionQueryResult = {
   _id: string
   _type: string
   _updatedAt: string
   result: Record<string, unknown>
+  __projectionHash: string
 }
 
 interface CreateProjectionQueryResult {
@@ -19,14 +22,18 @@ type ProjectionMap = Record<string, {projection: ValidProjection; documentIds: S
 
 export function createProjectionQuery(
   documentIds: Set<string>,
-  documentProjections: {[TDocumentId in string]?: string},
+  documentProjections: {[TDocumentId in string]?: DocumentProjections},
 ): CreateProjectionQueryResult {
   const projections = Array.from(documentIds)
-    .filter((id) => documentProjections[id])
-    .map((id) => {
-      const projection = validateProjection(documentProjections[id]!)
-      const projectionHash = hashString(projection)
-      return {documentId: id, projection, projectionHash}
+    .flatMap((id) => {
+      const projectionsForDoc = documentProjections[id]
+      if (!projectionsForDoc) return []
+
+      return Object.entries(projectionsForDoc).map(([projectionHash, projection]) => ({
+        documentId: id,
+        projection,
+        projectionHash,
+      }))
     })
     .reduce<ProjectionMap>((acc, {documentId, projection, projectionHash}) => {
       const obj = acc[projectionHash] ?? {documentIds: new Set(), projection}
@@ -38,7 +45,7 @@ export function createProjectionQuery(
 
   const query = `[${Object.entries(projections)
     .map(([projectionHash, {projection}]) => {
-      return `...*[_id in $__ids_${projectionHash}]{_id,_type,_updatedAt,"result":{...${projection}}}`
+      return `...*[_id in $__ids_${projectionHash}]{_id,_type,_updatedAt,"__projectionHash":"${projectionHash}","result":{...${projection}}}`
     })
     .join(',')}]`
 
@@ -64,33 +71,69 @@ interface ProcessProjectionQueryOptions {
 }
 
 export function processProjectionQuery({ids, results}: ProcessProjectionQueryOptions): {
-  [TDocumentId in string]?: ProjectionValuePending<Record<string, unknown>>
+  [TDocumentId in string]?: DocumentProjectionValues<Record<string, unknown>>
 } {
-  const resultMap = results.reduce<{[TDocumentId in string]?: ProjectionQueryResult}>(
-    (acc, next) => {
-      acc[next._id] = next
-      return acc
-    },
-    {},
-  )
+  const groupedResults: {
+    [docId: string]: {
+      [hash: string]: {
+        draft?: ProjectionQueryResult
+        published?: ProjectionQueryResult
+      }
+    }
+  } = {}
+
+  for (const result of results) {
+    const originalId = getPublishedId(result._id)
+    const hash = result.__projectionHash
+    const isDraft = result._id.startsWith('drafts.')
+
+    if (!ids.has(originalId)) continue
+
+    if (!groupedResults[originalId]) {
+      groupedResults[originalId] = {}
+    }
+    if (!groupedResults[originalId][hash]) {
+      groupedResults[originalId][hash] = {}
+    }
+
+    if (isDraft) {
+      groupedResults[originalId][hash].draft = result
+    } else {
+      groupedResults[originalId][hash].published = result
+    }
+  }
+
+  const finalValues: {
+    [docId: string]: DocumentProjectionValues<Record<string, unknown>>
+  } = {}
 
-  return Object.fromEntries(
-    Array.from(ids).map((id): [string, ProjectionValuePending<Record<string, unknown>>] => {
-      const publishedId = getPublishedId(id)
-      const draftId = getDraftId(id)
+  for (const originalId of ids) {
+    finalValues[originalId] = {}
 
-      const draftResult = resultMap[draftId]
-      const publishedResult = resultMap[publishedId]
+    const projectionsForDoc = groupedResults[originalId]
+    if (!projectionsForDoc) continue
 
-      const projectionResult = draftResult?.result ?? publishedResult?.result
-      if (!projectionResult) return [id, {data: null, isPending: false}]
+    for (const hash in projectionsForDoc) {
+      const {draft, published} = projectionsForDoc[hash]
+
+      const projectionResultData = draft?.result ?? published?.result
+
+      if (!projectionResultData) {
+        finalValues[originalId][hash] = {data: null, isPending: false}
+        continue
+      }
 
       const status = {
-        ...(draftResult?._updatedAt && {lastEditedDraftAt: draftResult._updatedAt}),
-        ...(publishedResult?._updatedAt && {lastEditedPublishedAt: publishedResult._updatedAt}),
+        ...(draft?._updatedAt && {lastEditedDraftAt: draft._updatedAt}),
+        ...(published?._updatedAt && {lastEditedPublishedAt: published._updatedAt}),
       }
 
-      return [id, {data: {...projectionResult, status}, isPending: false}]
-    }),
-  )
+      finalValues[originalId][hash] = {
+        data: {...projectionResultData, status},
+        isPending: false,
+      }
+    }
+  }
+
+  return finalValues
 }

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,55 +1,18 @@
-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'
+import {type ProjectionStoreState} from './types'
 
-/**
- * @beta
- */
-export type ValidProjection = `{${string}}`
-
-export interface ProjectionQueryResult<TValue = Record<string, unknown>> {
-  _id: string
-  _type: string
-  _updatedAt: string
-  result: TValue
-}
-
-/**
- * @beta
- */
-export interface ProjectionValuePending<TValue extends object> {
-  data: TValue | null
-  isPending: boolean
-}
-
-export interface ProjectionStoreState<TValue extends object = object> extends LiveEventAwareState {
-  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()
   },
 })