@sanity/orderable-document-list 1.5.1 → 2.0.0

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

@@ -1,327 +0,0 @@
-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/__tests__/initialRank.test.ts

@@ -1,20 +0,0 @@
-import {describe, expect, it} from 'vitest'
-import {LexoRank} from 'lexorank'
-
-import {initialRank} from '../initialRank'
-
-describe('initialRank', () => {
-  it('handles invalid/non-string compareRankValue without throwing', () => {
-    const action = () => initialRank(1 as unknown as string)
-    expect(action).not.toThrow()
-
-    const rank = action()
-    expect(typeof rank).toBe('string')
-    expect(() => LexoRank.parse(rank)).not.toThrow()
-  })
-
-  it('falls back to LexoRank.min when parse fails', () => {
-    const rank = initialRank('not-a-rank', 'after')
-    expect(() => LexoRank.parse(rank)).not.toThrow()
-  })
-})

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

@@ -1,39 +0,0 @@
-import {describe, expect, it} from 'vitest'
-import {LexoRank} from 'lexorank'
-
-import {parseOrderRank} from '../parseOrderRank'
-
-describe('parseOrderRank', () => {
-  it('parses valid lexorank strings', () => {
-    const valid = '0|10000o:'
-    const result = parseOrderRank(valid, LexoRank.min())
-
-    expect(result).toEqual(LexoRank.parse(valid))
-  })
-
-  it('returns fallback for non-string values', () => {
-    const fallback = LexoRank.max()
-
-    expect(parseOrderRank(1, fallback)).toBe(fallback)
-    expect(parseOrderRank(null, fallback)).toBe(fallback)
-    expect(parseOrderRank(undefined, fallback)).toBe(fallback)
-    expect(parseOrderRank({}, fallback)).toBe(fallback)
-    expect(parseOrderRank([], fallback)).toBe(fallback)
-  })
-
-  it('returns fallback for invalid lexorank strings', () => {
-    const fallback = LexoRank.min()
-
-    expect(parseOrderRank('not-a-rank', fallback)).toBe(fallback)
-    expect(parseOrderRank('invalid', fallback)).toBe(fallback)
-    expect(parseOrderRank('', fallback)).toBe(fallback)
-  })
-
-  it('respects different fallback values', () => {
-    const minFallback = LexoRank.min()
-    const maxFallback = LexoRank.max()
-
-    expect(parseOrderRank('invalid', minFallback)).toBe(minFallback)
-    expect(parseOrderRank('invalid', maxFallback)).toBe(maxFallback)
-  })
-})

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

@@ -1,45 +0,0 @@
-import {describe, expect, it} from 'vitest'
-import {LexoRank} from 'lexorank'
-
-import {SanityDocumentWithOrder} from '../../types'
-import {ORDER_FIELD_NAME} from '../constants'
-import {reorderDocuments} from '../reorderDocuments'
-
-describe('reorderDocuments', () => {
-  it('handles non-string orderRank values without throwing', () => {
-    const entities: SanityDocumentWithOrder[] = [
-      {
-        _id: 'a',
-        _type: 'orderableCategory',
-        orderRank: '0|00000a:',
-        _createdAt: new Date().toISOString(),
-        _updatedAt: new Date().toISOString(),
-        _rev: '1',
-      },
-      {
-        _id: 'b',
-        _type: 'orderableCategory',
-        orderRank: 1 as unknown as any,
-        _createdAt: new Date().toISOString(),
-        _updatedAt: new Date().toISOString(),
-        _rev: '1',
-      },
-    ]
-
-    const action = () =>
-      reorderDocuments({
-        entities: [...entities],
-        selectedIds: ['b'],
-        source: {index: 1},
-        destination: {index: 0},
-      })
-
-    expect(action).not.toThrow()
-
-    const result = action()
-    const updatedRank = result.patches.find(([id]) => id === 'b')?.[1].set?.[ORDER_FIELD_NAME]
-
-    expect(typeof updatedRank).toBe('string')
-    expect(() => LexoRank.parse(updatedRank as string)).not.toThrow()
-  })
-})

package/src/helpers/client.ts

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

package/src/helpers/constants.ts

@@ -1,4 +0,0 @@
-export const ORDER_FIELD_NAME = `orderRank` 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

@@ -1,103 +0,0 @@
-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/initialRank.ts

@@ -1,16 +0,0 @@
-import {LexoRank} from 'lexorank'
-import {NewItemPosition} from '../types'
-import {parseOrderRank} from './parseOrderRank'
-
-// Use in initial value field by passing in the rank value of the last document
-// If not value passed, generate a sensibly low rank
-export function initialRank(
-  compareRankValue = ``,
-  newItemPosition: NewItemPosition = 'after',
-): string {
-  const compareRank = parseOrderRank(compareRankValue, LexoRank.min())
-  const rank =
-    newItemPosition === 'before' ? compareRank.genPrev().genPrev() : compareRank.genNext().genNext()
-
-  return rank.toString()
-}

package/src/helpers/parseOrderRank.ts

@@ -1,21 +0,0 @@
-import {LexoRank} from 'lexorank'
-
-// Safely parse a LexoRank string; fall back if invalid
-export function parseOrderRank(value: unknown, fallback: LexoRank): LexoRank {
-  if (typeof value !== 'string') {
-    console.warn('[orderable-document-list] Invalid orderRank value (expected string):', value)
-    return fallback
-  }
-
-  try {
-    return LexoRank.parse(value)
-  } catch (err) {
-    console.warn(
-      '[orderable-document-list] Failed to parse orderRank value:',
-      value,
-      'Error:',
-      err instanceof Error ? err.message : String(err),
-    )
-    return fallback
-  }
-}

package/src/helpers/query.ts

@@ -1,50 +0,0 @@
-import {ORDER_FIELD_NAME} from './constants'
-
-export interface DocumentListQueryProps {
-  type: string
-  filter?: string
-  params?: Record<string, unknown>
-  currentVersion?: string
-}
-
-export interface DocumentListQueryResult {
-  query: string
-  queryParams: Record<string, string | number | boolean | string[]>
-}
-
-const DEFAULT_PARAMS = {}
-
-export function getDocumentQuery({
-  type,
-  filter,
-  params = DEFAULT_PARAMS,
-  currentVersion,
-}: DocumentListQueryProps): DocumentListQueryResult {
-  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}}`
-
-  const query = `${querySelect}${queryOrder}${queryFields}`
-  const queryParams = {
-    ...params,
-    type,
-    order: ORDER_FIELD_NAME,
-    ...(currentVersion && {currentVersion}),
-  }
-
-  return {query, queryParams}
-}