@sanity/orderable-document-list 1.3.5 → 1.4.1

package/src/DocumentListWrapper.tsx

@@ -16,6 +16,8 @@ export interface DocumentListWrapperProps {
   filter?: string
   // eslint-disable-next-line react/require-default-props
   params?: Record<string, unknown>
+  // eslint-disable-next-line react/require-default-props
+  currentVersion?: string
 }
 
 // 1. Validate first that the schema has been configured for ordering
@@ -26,6 +28,7 @@ export function DocumentListWrapper({
   resetOrderTransaction,
   filter,
   params,
+  currentVersion,
 }: DocumentListWrapperProps) {
   const toast = useToast()
   const schema = useSchema()
@@ -98,7 +101,12 @@ export function DocumentListWrapper({
 
   return (
     <OrderableContext.Provider value={{showIncrements}}>
-      <DocumentListQuery type={type} filter={filter} params={params} />
+      <DocumentListQuery
+        type={type}
+        filter={filter}
+        params={params}
+        currentVersion={currentVersion}
+      />
     </OrderableContext.Provider>
   )
 }

package/src/OrderableDocumentList.tsx

@@ -11,6 +11,7 @@ export interface OrderableDocumentListProps {
     client: SanityClient
     filter?: string
     params?: Record<string, unknown>
+    currentVersion?: string
   }
 }
 
@@ -73,6 +74,7 @@ export class OrderableDocumentList extends Component<OrderableDocumentListProps,
         type={type}
         showIncrements={this.state.showIncrements}
         resetOrderTransaction={this.state.resetOrderTransaction}
+        currentVersion={this?.props?.options?.currentVersion}
       />
     )
   }

package/src/desk-structure/orderableDocumentListDeskItem.ts

@@ -30,7 +30,11 @@ export function orderableDocumentListDeskItem(config: OrderableListConfig): List
 
   const {type, filter, menuItems = [], createIntent, params, title, icon, id, context, S} = config
   const {schema, getClient} = context
+  // 'perspectiveStack' may not exist on ConfigContext in some versions
+  const perspectiveStack = (context as any).perspectiveStack || []
   const client = getClient({apiVersion: API_VERSION})
+  // the first position in the perspective stack is the current version
+  const currentVersion = perspectiveStack[0]
 
   const listTitle = title ?? `Orderable ${type}`
   const listId = id ?? `orderable-${type}`
@@ -63,7 +67,7 @@ export function orderableDocumentListDeskItem(config: OrderableListConfig): List
 
           type: 'component',
           component: OrderableDocumentList,
-          options: {type, filter, params, client},
+          options: {type, filter, params, client, currentVersion},
           menuItems: [
             ...menuItems,
             S.menuItem().title(`Reset Order`).icon(GenerateIcon).action(`resetOrder`).serialize(),

package/src/helpers/__tests__/getFilteredDeduppedDocs.test.ts

@@ -0,0 +1,327 @@
+import {describe, it, expect} from 'vitest'
+import {type SanityDocumentWithOrder} from '../../types'
+import {getFilteredDedupedDocs} from '../getFilteredDedupedDocs'
+
+describe('getFilteredDedupedDocs', () => {
+  const mockDocumentsFromVersionPerspective: SanityDocumentWithOrder[] = [
+    {
+      _id: 'drafts.document-1',
+      _type: 'orderableCategory',
+      orderRank: '0|10000o:',
+      _createdAt: new Date().toISOString(),
+      _updatedAt: new Date().toISOString(),
+      _rev: '123',
+    },
+    {
+      _id: 'versions.rmWGG9z1W.document-2',
+      _type: 'orderableCategory',
+      orderRank: '0|100014:',
+      _createdAt: new Date().toISOString(),
+      _updatedAt: new Date().toISOString(),
+      _rev: '123',
+    },
+    {
+      _id: 'drafts.document-3',
+      _type: 'orderableCategory',
+      orderRank: '0|10001k:',
+      _createdAt: new Date().toISOString(),
+      _updatedAt: new Date().toISOString(),
+      _rev: '123',
+    },
+    {
+      _id: 'document-4',
+      _type: 'orderableCategory',
+      orderRank: '0|100020:',
+      _createdAt: new Date().toISOString(),
+      _updatedAt: new Date().toISOString(),
+      _rev: '123',
+    },
+    {
+      _id: 'versions.rmWGG9z1W.document-6',
+      _type: 'orderableCategory',
+      orderRank: '0|10002w:',
+      _createdAt: new Date().toISOString(),
+      _updatedAt: new Date().toISOString(),
+      _rev: '123',
+    },
+    {
+      _id: 'document-5',
+      _type: 'orderableCategory',
+      orderRank: '0|100034:',
+      _createdAt: new Date().toISOString(),
+      _updatedAt: new Date().toISOString(),
+      _rev: '123',
+    },
+    {
+      _id: 'drafts.document-5',
+      _type: 'orderableCategory',
+      orderRank: '0|100034:',
+      _createdAt: new Date().toISOString(),
+      _updatedAt: new Date().toISOString(),
+      _rev: '123',
+    },
+    {
+      _id: 'document-9',
+      _type: 'orderableCategory',
+      orderRank: '0|10003c:',
+      _createdAt: new Date().toISOString(),
+      _updatedAt: new Date().toISOString(),
+      _rev: '123',
+    },
+    {
+      _id: 'drafts.document-8',
+      _type: 'orderableCategory',
+      orderRank: '0|10003s:',
+      _createdAt: new Date().toISOString(),
+      _updatedAt: new Date().toISOString(),
+      _rev: '123',
+    },
+    {
+      _id: 'versions.rmWGG9z1W.document-3',
+      _type: 'orderableCategory',
+      orderRank: '0|100048:',
+      _createdAt: new Date().toISOString(),
+      _updatedAt: new Date().toISOString(),
+      _rev: '123',
+    },
+  ]
+
+  const mockDocumentsInDraftsPerspective: SanityDocumentWithOrder[] = [
+    {
+      _id: 'drafts.document-1',
+      _type: 'orderableCategory',
+      orderRank: '0|10000o:',
+      _createdAt: new Date().toISOString(),
+      _updatedAt: new Date().toISOString(),
+      _rev: '123',
+    },
+    {
+      _id: 'drafts.document-3',
+      _type: 'orderableCategory',
+      orderRank: '0|10001k:',
+      _createdAt: new Date().toISOString(),
+      _updatedAt: new Date().toISOString(),
+      _rev: '123',
+    },
+    {
+      _id: 'document-4',
+      _type: 'orderableCategory',
+      orderRank: '0|100020:',
+      _createdAt: new Date().toISOString(),
+      _updatedAt: new Date().toISOString(),
+      _rev: '123',
+    },
+    {
+      _id: 'document-5',
+      _type: 'orderableCategory',
+      orderRank: '0|100034:',
+      _createdAt: new Date().toISOString(),
+      _updatedAt: new Date().toISOString(),
+      _rev: '123',
+    },
+    {
+      _id: 'drafts.document-5',
+      _type: 'orderableCategory',
+      orderRank: '0|100034:',
+      _createdAt: new Date().toISOString(),
+      _updatedAt: new Date().toISOString(),
+      _rev: '123',
+    },
+    {
+      _id: 'document-7',
+      _type: 'orderableCategory',
+      orderRank: '0|10003c:',
+      _createdAt: new Date().toISOString(),
+      _updatedAt: new Date().toISOString(),
+      _rev: '123',
+    },
+    {
+      _id: 'drafts.document-8',
+      _type: 'orderableCategory',
+      orderRank: '0|10003s:',
+      _createdAt: new Date().toISOString(),
+      _updatedAt: new Date().toISOString(),
+      _rev: '123',
+    },
+  ]
+
+  const mockDocumentsPublishedPerspective: SanityDocumentWithOrder[] = [
+    {
+      _id: '123',
+      _type: 'orderableCategory',
+      orderRank: '0|100035:',
+      _createdAt: new Date().toISOString(),
+      _updatedAt: new Date().toISOString(),
+      _rev: '123',
+    },
+    {
+      _id: '456',
+      _type: 'orderableCategory',
+      orderRank: '0|100036:',
+      _createdAt: new Date().toISOString(),
+      _updatedAt: new Date().toISOString(),
+      _rev: '123',
+    },
+    {
+      _id: '789',
+      _type: 'orderableCategory',
+      orderRank: '0|10003h:',
+      _createdAt: new Date().toISOString(),
+      _updatedAt: new Date().toISOString(),
+      _rev: '123',
+    },
+  ]
+
+  it('should filter and deduplicate documents in draft perspective', () => {
+    const result = getFilteredDedupedDocs(
+      mockDocumentsInDraftsPerspective as SanityDocumentWithOrder[],
+      'drafts',
+    )
+
+    // Should only include drafts and published (if it doesn't have a published)
+    expect(result).toHaveLength(6)
+    expect(result.map((doc) => doc._id)).toEqual([
+      'drafts.document-1',
+      'drafts.document-3',
+      'document-4',
+      'drafts.document-5',
+      'document-7',
+      'drafts.document-8',
+    ])
+  })
+
+  it('should prioritize drafts over published in draft perspective', () => {
+    const documentsWithDuplicates = [
+      {
+        _id: 'drafts.123',
+        _type: 'test',
+        orderRank: 'a',
+        _createdAt: new Date().toISOString(),
+        _updatedAt: new Date().toISOString(),
+        _rev: '123',
+      },
+      {
+        _id: '123',
+        _type: 'test',
+        orderRank: 'b',
+        _createdAt: new Date().toISOString(),
+        _updatedAt: new Date().toISOString(),
+        _rev: '123',
+      },
+    ]
+
+    const result = getFilteredDedupedDocs(documentsWithDuplicates, 'drafts')
+
+    // Should only show the draft version
+    expect(result).toHaveLength(1)
+    expect(result[0]._id).toBe('drafts.123')
+  })
+
+  it('should filter and deduplicate documents in published perspective', () => {
+    const result = getFilteredDedupedDocs(mockDocumentsPublishedPerspective, 'published')
+
+    // Should only include published documents
+    expect(result).toHaveLength(3)
+    expect(result.map((doc) => doc._id)).toEqual(['123', '456', '789'])
+  })
+
+  it('should filter and deduplicate documents in version perspective', () => {
+    const result = getFilteredDedupedDocs(
+      mockDocumentsFromVersionPerspective as SanityDocumentWithOrder[],
+      'rmWGG9z1W',
+    )
+
+    // Should include versions for the specific release, drafts, and published
+    expect(result).toHaveLength(8)
+    expect(result.map((doc) => doc._id)).toEqual([
+      'drafts.document-1',
+      'versions.rmWGG9z1W.document-2',
+      'document-4',
+      'versions.rmWGG9z1W.document-6',
+      'drafts.document-5',
+      'document-9',
+      'drafts.document-8',
+      'versions.rmWGG9z1W.document-3',
+    ])
+  })
+
+  it('should prioritize versions over drafts in version perspective', () => {
+    const documentsWithVersionAndDraft: SanityDocumentWithOrder[] = [
+      {
+        _id: 'drafts.document-1',
+        _type: 'orderableCategory',
+        orderRank: '0|10001k:',
+        _createdAt: new Date().toISOString(),
+        _updatedAt: new Date().toISOString(),
+        _rev: '123',
+      },
+      {
+        _id: 'versions.rEZnogJnx.document-1',
+        _type: 'orderableCategory',
+        orderRank: '0|10000o:',
+        _createdAt: new Date().toISOString(),
+        _updatedAt: new Date().toISOString(),
+        _rev: '123',
+      },
+    ]
+
+    const result = getFilteredDedupedDocs(documentsWithVersionAndDraft, 'rEZnogJnx')
+
+    // Should prioritize the version over the draft
+    expect(result).toHaveLength(1)
+    expect(result.map((doc) => doc._id)).toEqual(['versions.rEZnogJnx.document-1'])
+  })
+
+  it('should show draft of other versions when the selected version doesnt exist for the document', () => {
+    const result = getFilteredDedupedDocs(
+      [
+        {
+          _id: 'drafts.123',
+          _type: 'test',
+          orderRank: 'a',
+          _createdAt: new Date().toISOString(),
+          _updatedAt: new Date().toISOString(),
+          _rev: '123',
+        },
+        {
+          _id: 'versions.rEZnogJnx.123',
+          _type: 'test',
+          orderRank: 'b',
+          _createdAt: new Date().toISOString(),
+          _updatedAt: new Date().toISOString(),
+          _rev: '123',
+        },
+        {
+          _id: 'versions.other-version.456',
+          _type: 'test',
+          orderRank: 'b',
+          _createdAt: new Date().toISOString(),
+          _updatedAt: new Date().toISOString(),
+          _rev: '123',
+        },
+        {
+          _id: '789',
+          _type: 'test',
+          orderRank: 'b',
+          _createdAt: new Date().toISOString(),
+          _updatedAt: new Date().toISOString(),
+          _rev: '123',
+        },
+      ],
+      'other-version',
+    )
+
+    // Should show the draft of the other version
+    expect(result).toHaveLength(3)
+    expect(result.map((doc) => doc._id)).toEqual([
+      'drafts.123',
+      'versions.other-version.456',
+      '789',
+    ])
+  })
+
+  it('should handle empty input', () => {
+    const result = getFilteredDedupedDocs([], 'drafts')
+    expect(result).toEqual([])
+  })
+})

package/src/helpers/client.ts

@@ -1,6 +1,8 @@
-import {type SanityClient, useClient} from 'sanity'
+import {type SanityClient, useClient, usePerspective} from 'sanity'
 import {API_VERSION} from './constants'
 
 export function useSanityClient(): SanityClient {
-  return useClient({apiVersion: API_VERSION})
+  const {perspectiveStack} = usePerspective()
+
+  return useClient({apiVersion: API_VERSION}).withConfig({perspective: perspectiveStack})
 }

package/src/helpers/constants.ts

@@ -1,3 +1,4 @@
 export const ORDER_FIELD_NAME = `orderRank` as const
 
-export const API_VERSION = `2021-09-01` as const
+// same version we are using in the vision plugin
+export const API_VERSION = `v2025-06-27` as const

package/src/helpers/getFilteredDedupedDocs.ts

@@ -0,0 +1,103 @@
+import {getPublishedId, getVersionFromId, isDraftId, isPublishedId, isVersionId} from 'sanity'
+import {type SanityDocumentWithOrder} from '../types'
+
+const isVersionForCurrentPerspective = (
+  document: SanityDocumentWithOrder,
+  perspectiveName: string,
+  publishedId: string,
+) => {
+  return (
+    document._id &&
+    isVersionId(document._id) &&
+    getVersionFromId(document._id) === perspectiveName &&
+    getPublishedId(document._id) === publishedId
+  )
+}
+
+// this removes dedupped docs from the list and makes sure that it keeps the right docs
+// in the list while preserving the order established by the orderRank field
+export const getFilteredDedupedDocs = (
+  documents: SanityDocumentWithOrder[],
+  perspectiveName?: string,
+): SanityDocumentWithOrder[] => {
+  // Flatten the documents array in case it's nested (like in test data)
+  const flatDocuments = documents.flat()
+
+  return flatDocuments.reduce<SanityDocumentWithOrder[]>((acc, cur) => {
+    if (!cur._id) {
+      return acc
+    }
+
+    // Handle version-only documents
+    if (isVersionId(cur._id)) {
+      const versionFromId = getVersionFromId(cur._id)
+      const isCorrectVersion = versionFromId === perspectiveName
+
+      // Only include versions that match the current perspective
+      if (
+        perspectiveName &&
+        perspectiveName !== 'drafts' &&
+        perspectiveName !== 'published' &&
+        isCorrectVersion
+      ) {
+        return [...acc, cur]
+      }
+      return acc
+    }
+
+    // Handle published perspective - only include published documents
+    if (perspectiveName === 'published') {
+      if (isPublishedId(cur._id)) {
+        return [...acc, cur]
+      }
+      return acc
+    }
+
+    // in situations where the document is not a draft, we need to check if
+    // the version should override a published document or a draft
+    if (!isDraftId(cur._id)) {
+      const publishedId = getPublishedId(cur._id)
+
+      const countNrPublished = JSON.stringify(flatDocuments).match(`/${publishedId}/g`)
+
+      // Check if there's a version that matches the perspectiveName
+      const hasMatchingVersion =
+        perspectiveName && perspectiveName !== 'drafts' && perspectiveName !== 'published'
+          ? flatDocuments.some((doc) =>
+              isVersionForCurrentPerspective(doc, perspectiveName, publishedId),
+            )
+          : false
+
+      // Check if there's a draft
+      const hasDraft = flatDocuments.some((doc) => doc._id === `drafts.${cur._id}`)
+
+      // Priority: version > draft > published
+      // If there's a matching version, skip published
+      if (hasMatchingVersion) {
+        return acc
+      }
+
+      // eslint-disable-next-line max-nested-callbacks
+      const alsoHasDraft = hasDraft || countNrPublished
+      return alsoHasDraft ? acc : [...acc, cur]
+    }
+
+    // For drafts, check if there's a version for this document in version perspective
+    if (perspectiveName && perspectiveName !== 'drafts' && perspectiveName !== 'published') {
+      const baseId = getPublishedId(cur._id)
+      const hasVersion = flatDocuments.some((doc) =>
+        isVersionForCurrentPerspective(doc, perspectiveName, baseId),
+      )
+
+      // If there's a version for this document, skip the draft
+      if (hasVersion) {
+        return acc
+      }
+    }
+
+    // Check if the draft has a published version
+    cur.hasPublished = flatDocuments.some((doc) => doc._id === cur._id.replace(`drafts.`, ``))
+
+    return [...acc, cur]
+  }, [])
+}

package/src/helpers/query.ts

@@ -4,6 +4,7 @@ export interface DocumentListQueryProps {
   type: string
   filter?: string
   params?: Record<string, unknown>
+  currentVersion?: string
 }
 
 export interface DocumentListQueryResult {
@@ -17,8 +18,23 @@ export function getDocumentQuery({
   type,
   filter,
   params = DEFAULT_PARAMS,
+  currentVersion,
 }: DocumentListQueryProps): DocumentListQueryResult {
-  const querySelect = `*[_type == $type ${filter ? `&& ${filter}` : ''}]`
+  let perspectiveFilter = null
+  if (currentVersion === 'published') {
+    perspectiveFilter = '!(_id in path("drafts.**")) && !(_id in path("versions.**"))'
+  } else if (currentVersion === 'drafts') {
+    // Show drafts, and published when no draft exists
+    perspectiveFilter = `
+      (_id in path("drafts.**") || (!(_id in path("drafts.**")) && !(_id in path("versions.**"))))
+    `
+  } else {
+    // Default behavior: prioritize drafts over published when both exist
+    // the priority should be a version
+    perspectiveFilter = `(sanity::partOfRelease($currentVersion) || (!(_id in path("drafts.**")) && !(_id in path("versions.**"))) || (_id in path("drafts.**")))`
+  }
+
+  const querySelect = `*[_type == $type ${perspectiveFilter ? `&& ${perspectiveFilter}` : ''}${filter ? `&& ${filter}` : ''}]`
   const queryOrder = `|order(@[$order] asc)`
   const queryFields = `{_id, _type, ${ORDER_FIELD_NAME}}`
 
@@ -27,6 +43,7 @@ export function getDocumentQuery({
     ...params,
     type,
     order: ORDER_FIELD_NAME,
+    ...(currentVersion && {currentVersion}),
   }
 
   return {query, queryParams}

package/src/helpers/resetOrder.ts

@@ -5,13 +5,15 @@ import {DocumentListQueryProps, getDocumentQuery} from './query'
 
 export interface ResetOrderParams extends DocumentListQueryProps {
   client: SanityClient
+  currentVersion?: string
 }
 
 // Function to wipe and re-do ordering with LexoRank
 // Will at least attempt to start with the current order
 export async function resetOrder(params: ResetOrderParams): Promise<MultipleMutationResult | null> {
-  const {client, ...queryProps} = params
-  const {query, queryParams} = getDocumentQuery(queryProps)
+  const {client, currentVersion, ...queryProps} = params
+  const {query, queryParams} = getDocumentQuery({...queryProps, currentVersion})
+
   const documents = await client.fetch<
     Array<{
       _id: string