@sanity/sdk 0.0.0-rc.6 → 0.0.0

package/src/releases/utils/sortReleases.test.ts

@@ -0,0 +1,336 @@
+import {describe, expect, it} from 'vitest'
+
+import {type ReleaseDocument} from '../releasesStore'
+import {sortReleases} from './sortReleases'
+
+// Mock function to create a release document
+function createReleaseMock(
+  value: Partial<
+    Omit<ReleaseDocument, 'metadata'> & {
+      metadata: Partial<ReleaseDocument['metadata']>
+    }
+  >,
+): ReleaseDocument {
+  const id: string = typeof value['_id'] === 'string' ? value['_id'] : 'mockId'
+  return {
+    _id: id,
+    _rev: 'rev',
+    _type: 'release',
+    _createdAt: new Date().toISOString(),
+    _updatedAt: new Date().toISOString(),
+    state: 'active',
+    ...value,
+    metadata: {
+      title: `Release ${id}`,
+      releaseType: 'asap',
+      ...value.metadata,
+    },
+    name: `Release ${id}`,
+  }
+}
+
+describe('sortReleases()', () => {
+  it('should return the asap releases ordered by createdAt', () => {
+    const releases: ReleaseDocument[] = [
+      createReleaseMock({
+        _id: '_.releases.rasap1',
+        _createdAt: '2024-10-24T00:00:00Z',
+        metadata: {
+          releaseType: 'asap',
+        },
+      }),
+      createReleaseMock({
+        _id: '_.releases.rasap2',
+        _createdAt: '2024-10-25T00:00:00Z',
+        metadata: {
+          releaseType: 'asap',
+        },
+      }),
+    ]
+    const sorted = sortReleases(releases)
+    const expectedOrder = ['rasap2', 'rasap1']
+    expectedOrder.forEach((expectedName, idx) => {
+      expect(sorted[idx]['_id']).toContain(expectedName)
+    })
+  })
+
+  it('should return the scheduled releases ordered by intendedPublishAt or publishAt', () => {
+    const releases: ReleaseDocument[] = [
+      createReleaseMock({
+        _id: '_.releases.rfuture2',
+        metadata: {
+          releaseType: 'scheduled',
+          intendedPublishAt: '2024-11-25T00:00:00Z',
+        },
+      }),
+      createReleaseMock({
+        _id: '_.releases.rfuture1',
+        metadata: {
+          releaseType: 'scheduled',
+          intendedPublishAt: '2024-11-23T00:00:00Z',
+        },
+      }),
+      createReleaseMock({
+        _id: '_.releases.rfuture4',
+        state: 'scheduled',
+        publishAt: '2024-11-31T00:00:00Z',
+        metadata: {
+          releaseType: 'scheduled',
+          intendedPublishAt: '2024-10-20T00:00:00Z',
+        },
+      }),
+      createReleaseMock({
+        _id: '_.releases.rfuture3',
+        state: 'scheduled',
+        publishAt: '2024-11-26T00:00:00Z',
+        metadata: {
+          releaseType: 'scheduled',
+        },
+      }),
+      createReleaseMock({
+        _id: '_.releases.rfuture5',
+        metadata: {
+          releaseType: 'scheduled',
+        },
+      }),
+      createReleaseMock({
+        _id: '_.releases.rfuture6',
+        metadata: {
+          releaseType: 'scheduled',
+        },
+      }),
+    ]
+    const sorted = sortReleases(releases)
+    const expectedOrder = ['rfuture4', 'rfuture3', 'rfuture2', 'rfuture1', 'rfuture5', 'rfuture6']
+    expectedOrder.forEach((expectedName, idx) => {
+      expect(sorted[idx]['_id']).toContain(expectedName)
+    })
+  })
+
+  it('should return the scheduled releases ordered by intendedPublishAt or publishAt, with missing dates at the end', () => {
+    const releases: ReleaseDocument[] = [
+      createReleaseMock({
+        _id: '_.releases.rfuture2',
+        metadata: {
+          releaseType: 'scheduled',
+          intendedPublishAt: '2024-11-25T00:00:00Z',
+        },
+      }),
+      createReleaseMock({
+        _id: '_.releases.rfuture1',
+        metadata: {
+          releaseType: 'scheduled',
+          intendedPublishAt: '2024-11-23T00:00:00Z',
+        },
+      }),
+      createReleaseMock({
+        _id: '_.releases.rfuture4',
+        state: 'scheduled',
+        publishAt: '2024-11-31T00:00:00Z',
+        metadata: {
+          releaseType: 'scheduled',
+          intendedPublishAt: '2024-10-20T00:00:00Z',
+        },
+      }),
+      createReleaseMock({
+        _id: '_.releases.rfuture3',
+        state: 'scheduled',
+        publishAt: '2024-11-26T00:00:00Z',
+        metadata: {
+          releaseType: 'scheduled',
+        },
+      }),
+      createReleaseMock({
+        _id: '_.releases.rfuture5',
+        state: 'scheduled',
+        publishAt: '2024-11-27T00:00:00Z',
+        metadata: {
+          releaseType: 'scheduled',
+        },
+      }),
+      createReleaseMock({
+        _id: '_.releases.rfuture6',
+        metadata: {
+          releaseType: 'scheduled',
+        },
+      }),
+      createReleaseMock({
+        _id: '_.releases.rfuture7',
+        metadata: {
+          releaseType: 'scheduled',
+        },
+      }),
+      createReleaseMock({
+        _id: '_.releases.rfuture8',
+        state: 'scheduled',
+        publishAt: '2024-11-28T00:00:00Z',
+        metadata: {
+          releaseType: 'scheduled',
+        },
+      }),
+    ]
+    const sorted = sortReleases(releases)
+    const expectedOrder = [
+      'rfuture4',
+      'rfuture8',
+      'rfuture5',
+      'rfuture3',
+      'rfuture2',
+      'rfuture1',
+      'rfuture6',
+      'rfuture7',
+    ]
+    expectedOrder.forEach((expectedName, idx) => {
+      expect(sorted[idx]['_id']).toContain(expectedName)
+    })
+  })
+
+  it('should correctly handle scheduled releases with and without dates in both comparison directions', () => {
+    const specificCase = [
+      createReleaseMock({
+        _id: '_.releases.rwithdate',
+        metadata: {
+          releaseType: 'scheduled',
+          intendedPublishAt: '2024-11-29T00:00:00Z',
+        },
+      }),
+      createReleaseMock({
+        _id: '_.releases.rnodate',
+        metadata: {
+          releaseType: 'scheduled',
+        },
+      }),
+    ]
+    const sortedSpecific = sortReleases(specificCase)
+    expect(sortedSpecific[0]._id).toContain('rwithdate')
+    expect(sortedSpecific[1]._id).toContain('rnodate')
+
+    // Test the reverse order to ensure we hit both comparison branches
+    const reversedSpecific = [...specificCase].reverse()
+    const sortedReversedSpecific = sortReleases(reversedSpecific)
+    expect(sortedReversedSpecific[0]._id).toContain('rwithdate')
+    expect(sortedReversedSpecific[1]._id).toContain('rnodate')
+  })
+
+  it('should return the undecided releases ordered by createdAt', () => {
+    const releases: ReleaseDocument[] = [
+      createReleaseMock({
+        _id: '_.releases.rundecided1',
+        _createdAt: '2024-10-25T00:00:00Z',
+        metadata: {
+          releaseType: 'undecided',
+        },
+      }),
+      createReleaseMock({
+        _id: '_.releases.rundecided2',
+        _createdAt: '2024-10-26T00:00:00Z',
+        metadata: {
+          releaseType: 'undecided',
+        },
+      }),
+    ]
+    const sorted = sortReleases(releases)
+    const expectedOrder = ['rundecided2', 'rundecided1']
+    expectedOrder.forEach((expectedName, idx) => {
+      expect(sorted[idx]['_id']).toContain(expectedName)
+    })
+  })
+
+  it('should correctly sort asap vs non-asap releases in both directions', () => {
+    const releases: ReleaseDocument[] = [
+      createReleaseMock({
+        _id: '_.releases.rasap1',
+        _createdAt: '2024-10-24T00:00:00Z',
+        metadata: {
+          releaseType: 'asap',
+        },
+      }),
+      createReleaseMock({
+        _id: '_.releases.rscheduled1',
+        metadata: {
+          releaseType: 'scheduled',
+          intendedPublishAt: '2024-11-23T00:00:00Z',
+        },
+      }),
+      createReleaseMock({
+        _id: '_.releases.runknown1',
+        metadata: {
+          releaseType: 'unknown' as unknown as 'asap' | 'scheduled' | 'undecided',
+        },
+      }),
+      createReleaseMock({
+        _id: '_.releases.rasap2',
+        _createdAt: '2024-10-25T00:00:00Z',
+        metadata: {
+          releaseType: 'asap',
+        },
+      }),
+    ]
+    const sorted = sortReleases(releases)
+    const expectedOrder = ['rscheduled1', 'runknown1', 'rasap2', 'rasap1']
+    expectedOrder.forEach((expectedName, idx) => {
+      expect(sorted[idx]['_id']).toContain(expectedName)
+    })
+
+    // Test with releases in reverse order to ensure both comparison directions are covered
+    const reversedReleases = [...releases].reverse()
+    const sortedReversed = sortReleases(reversedReleases)
+    const expectedReversedOrder = ['runknown1', 'rscheduled1', 'rasap2', 'rasap1']
+    expectedReversedOrder.forEach((expectedName, idx) => {
+      expect(sortedReversed[idx]['_id']).toContain(expectedName)
+    })
+  })
+
+  it("should gracefully combine all release types, and sort them by 'undecided', 'scheduled', 'asap'", () => {
+    const releases = [
+      createReleaseMock({
+        _id: '_.releases.rasap2',
+        _createdAt: '2024-10-25T00:00:00Z',
+        metadata: {
+          releaseType: 'asap',
+        },
+      }),
+      createReleaseMock({
+        _id: '_.releases.rasap1',
+        _createdAt: '2024-10-24T00:00:00Z',
+        metadata: {
+          releaseType: 'asap',
+        },
+      }),
+      createReleaseMock({
+        _id: '_.releases.rundecided2',
+        _createdAt: '2024-10-26T00:00:00Z',
+        metadata: {
+          releaseType: 'undecided',
+        },
+      }),
+      createReleaseMock({
+        _id: '_.releases.rfuture4',
+        state: 'scheduled',
+        publishAt: '2024-11-31T00:00:00Z',
+        metadata: {
+          releaseType: 'scheduled',
+          intendedPublishAt: '2024-10-20T00:00:00Z',
+        },
+      }),
+      createReleaseMock({
+        _id: '_.releases.rfuture1',
+        metadata: {
+          releaseType: 'scheduled',
+          intendedPublishAt: '2024-11-23T00:00:00Z',
+        },
+      }),
+      createReleaseMock({
+        _id: '_.releases.runknown1',
+        metadata: {
+          releaseType: 'unknown' as unknown as 'asap' | 'scheduled' | 'undecided',
+        },
+      }),
+    ]
+    const sorted = sortReleases(releases)
+    const expectedOrder = ['rundecided2', 'rfuture4', 'rfuture1', 'runknown1', 'rasap2', 'rasap1']
+    expectedOrder.forEach((expectedName, idx) => {
+      expect(sorted[idx]['_id']).toContain(expectedName)
+    })
+  })
+})

package/src/releases/utils/sortReleases.ts

@@ -0,0 +1,48 @@
+import {type ReleaseDocument} from '../releasesStore'
+
+// mirrors the order of the releases in the releases list in Studio
+// https://github.com/sanity-io/sanity/blob/main/packages/sanity/src/core/releases/hooks/utils.ts
+export function sortReleases(releases: ReleaseDocument[] = []): ReleaseDocument[] {
+  // The order should always be:
+  // [undecided (sortByCreatedAt), scheduled(sortBy publishAt || metadata.intendedPublishAt), asap(sortByCreatedAt)]
+  return [...releases].sort((a, b) => {
+    // undecided are always first, then by createdAt descending
+    if (a.metadata.releaseType === 'undecided' && b.metadata.releaseType !== 'undecided') {
+      return -1
+    }
+    if (a.metadata.releaseType !== 'undecided' && b.metadata.releaseType === 'undecided') {
+      return 1
+    }
+    if (a.metadata.releaseType === 'undecided' && b.metadata.releaseType === 'undecided') {
+      // Sort by createdAt
+      return new Date(b._createdAt).getTime() - new Date(a._createdAt).getTime()
+    }
+
+    // Scheduled are always at the middle, then by publishAt descending
+    if (a.metadata.releaseType === 'scheduled' && b.metadata.releaseType === 'scheduled') {
+      const aPublishAt = a['publishAt'] || a.metadata['intendedPublishAt']
+      if (!aPublishAt) {
+        return 1
+      }
+      const bPublishAt = b['publishAt'] || b.metadata['intendedPublishAt']
+      if (!bPublishAt) {
+        return -1
+      }
+      return new Date(bPublishAt).getTime() - new Date(aPublishAt).getTime()
+    }
+
+    // ASAP are always last, then by createdAt descending
+    if (a.metadata.releaseType === 'asap' && b.metadata.releaseType !== 'asap') {
+      return 1
+    }
+    if (a.metadata.releaseType !== 'asap' && b.metadata.releaseType === 'asap') {
+      return -1
+    }
+    if (a.metadata.releaseType === 'asap' && b.metadata.releaseType === 'asap') {
+      // Sort by createdAt
+      return new Date(b._createdAt).getTime() - new Date(a._createdAt).getTime()
+    }
+
+    return 0
+  })
+}

package/src/utils/listenQuery.test.ts

@@ -0,0 +1,302 @@
+import {
+  type ListenEvent,
+  type MutationEvent,
+  type SanityClient,
+  type SanityDocument,
+  type WelcomeEvent,
+} from '@sanity/client'
+import {of, Subject, throwError} from 'rxjs'
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
+
+import {listenQuery} from './listenQuery'
+
+describe('listenQuery', () => {
+  const mockFetch = vi.fn()
+  const mockListen = vi.fn()
+
+  const mockClient = {
+    observable: {
+      fetch: mockFetch,
+    },
+    listen: mockListen,
+  } as unknown as SanityClient
+
+  const mockDoc: SanityDocument = {
+    _id: 'doc1',
+    _type: 'test',
+    _rev: 'rev1',
+    _createdAt: new Date().toISOString(),
+    _updatedAt: new Date().toISOString(),
+  }
+  const mockQuery = '*[_type == "test"]'
+
+  const createMutationEvent = (
+    transition: 'update' | 'appear' | 'disappear',
+    eventId: string,
+    transactionId: string,
+  ): MutationEvent<SanityDocument> => ({
+    type: 'mutation',
+    documentId: 'doc1',
+    eventId,
+    identity: 'test-user',
+    mutations: [{create: mockDoc}],
+    timestamp: new Date().toISOString(),
+    transition,
+    visibility: 'query',
+    effects: {
+      apply: [],
+      revert: [],
+    },
+    result: mockDoc,
+    transactionId,
+    transactionTotalEvents: 1,
+    transactionCurrentEvent: 1,
+  })
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.useFakeTimers()
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+    vi.clearAllMocks()
+  })
+
+  it('performs initial fetch and listens for updates', async () => {
+    const events$ = new Subject<ListenEvent<SanityDocument>>()
+    mockListen.mockReturnValue(events$)
+    mockFetch.mockReturnValue(of([mockDoc]))
+
+    const results: ListenEvent<Record<string, unknown>>[] = []
+    const promise = new Promise<void>((resolve) => {
+      listenQuery(mockClient, mockQuery).subscribe({
+        next: (result) => {
+          results.push(result as ListenEvent<Record<string, unknown>>)
+          if (results.length === 2) {
+            expect(results).toEqual([[mockDoc], [mockDoc, mockDoc]])
+            resolve()
+          }
+        },
+      })
+    })
+
+    // Emit welcome event to trigger initial fetch
+    events$.next({
+      type: 'welcome',
+      listenerName: 'test-listener',
+    } as WelcomeEvent)
+
+    // Emit mutation event to trigger refetch
+    mockFetch.mockReturnValue(of([mockDoc, mockDoc]))
+    events$.next(createMutationEvent('update', 'evt1', 'tx1'))
+    vi.advanceTimersByTime(1000)
+
+    await promise
+  })
+
+  it('handles separate fetch and listen queries', async () => {
+    const events$ = new Subject<ListenEvent<SanityDocument>>()
+    mockListen.mockReturnValue(events$)
+    mockFetch.mockReturnValue(of([mockDoc]))
+
+    const query = {
+      fetch: '*[_type == "test"] {_id, _type}',
+      listen: '*[_type == "test"]',
+    }
+
+    const promise = new Promise<void>((resolve) => {
+      listenQuery(mockClient, query).subscribe({
+        next: () => {
+          expect(mockListen).toHaveBeenCalledWith(
+            query.listen,
+            {},
+            expect.objectContaining({
+              events: ['welcome', 'mutation', 'reconnect'],
+              includeResult: false,
+            }),
+          )
+          expect(mockFetch).toHaveBeenCalledWith(
+            query.fetch,
+            {},
+            expect.objectContaining({
+              filterResponse: true,
+            }),
+          )
+          resolve()
+        },
+      })
+    })
+
+    events$.next({
+      type: 'welcome',
+      listenerName: 'test-listener',
+    } as WelcomeEvent)
+    await promise
+  })
+
+  it('filters mutation events based on transitions option', async () => {
+    const events$ = new Subject<ListenEvent<SanityDocument>>()
+    mockListen.mockReturnValue(events$)
+    mockFetch.mockReturnValueOnce(of([mockDoc])).mockReturnValueOnce(of([mockDoc, mockDoc]))
+
+    const results: ListenEvent<Record<string, unknown>>[] = []
+    const promise = new Promise<void>((resolve) => {
+      listenQuery(mockClient, mockQuery, {}, {transitions: ['update']}).subscribe({
+        next: (result) => {
+          results.push(result as ListenEvent<Record<string, unknown>>)
+          if (results.length === 2) {
+            expect(results).toEqual([[mockDoc], [mockDoc, mockDoc]])
+            resolve()
+          }
+        },
+      })
+    })
+
+    events$.next({
+      type: 'welcome',
+      listenerName: 'test-listener',
+    } as WelcomeEvent)
+
+    // Should trigger refetch (update transition is allowed)
+    events$.next(createMutationEvent('update', 'evt1', 'tx1'))
+    vi.advanceTimersByTime(1000)
+
+    // Should not trigger refetch (appear transition not in allowed list)
+    events$.next(createMutationEvent('appear', 'evt2', 'tx2'))
+
+    await promise
+  })
+
+  it('handles errors in fetch', async () => {
+    const events$ = new Subject<ListenEvent<SanityDocument>>()
+    mockListen.mockReturnValue(events$)
+    mockFetch.mockReturnValue(throwError(() => new Error('Fetch failed')))
+
+    const promise = new Promise<void>((resolve) => {
+      listenQuery(mockClient, mockQuery).subscribe({
+        error: (error) => {
+          expect(error.message).toBe('Fetch failed')
+          resolve()
+        },
+      })
+    })
+
+    events$.next({
+      type: 'welcome',
+      listenerName: 'test-listener',
+    } as WelcomeEvent)
+    await promise
+  })
+
+  it('handles errors in listen stream', async () => {
+    const error = new Error('Listen failed')
+    mockListen.mockReturnValue(throwError(() => error))
+
+    const promise = new Promise<void>((resolve) => {
+      listenQuery(mockClient, mockQuery).subscribe({
+        error: (err) => {
+          expect(err).toBe(error)
+          resolve()
+        },
+      })
+    })
+
+    await promise
+  })
+
+  it('throttles subsequent fetches after mutations', async () => {
+    const events$ = new Subject<ListenEvent<SanityDocument>>()
+    mockListen.mockReturnValue(events$)
+    mockFetch.mockReturnValue(of([mockDoc]))
+
+    const results: ListenEvent<Record<string, unknown>>[] = []
+    const promise = new Promise<void>((resolve) => {
+      listenQuery(mockClient, mockQuery, {}, {throttleTime: 500}).subscribe({
+        next: (result) => {
+          results.push(result as ListenEvent<Record<string, unknown>>)
+          if (results.length === 2) {
+            resolve()
+          }
+        },
+      })
+    })
+
+    events$.next({
+      type: 'welcome',
+      listenerName: 'test-listener',
+    } as WelcomeEvent)
+
+    // Emit two mutations in quick succession
+    events$.next(createMutationEvent('update', 'evt1', 'tx1'))
+    // Emit another mutation event quickly, should be debounced
+    events$.next(createMutationEvent('update', 'evt2', 'tx2'))
+    vi.advanceTimersByTime(500) // Advance timer for debounceTime (using specified throttleTime)
+
+    await promise
+
+    expect(mockFetch).toHaveBeenCalledTimes(2)
+  })
+
+  it('handles reconnect events', async () => {
+    const events$ = new Subject<ListenEvent<SanityDocument>>()
+    mockListen.mockReturnValue(events$)
+    mockFetch.mockReturnValue(of([mockDoc]))
+
+    const results: ListenEvent<Record<string, unknown>>[] = []
+    const promise = new Promise<void>((resolve) => {
+      listenQuery(mockClient, mockQuery).subscribe({
+        next: (result) => {
+          results.push(result as ListenEvent<Record<string, unknown>>)
+          if (results.length === 2) {
+            expect(results).toEqual([[mockDoc], [mockDoc]])
+            resolve()
+          }
+        },
+      })
+    })
+
+    events$.next({
+      type: 'welcome',
+      listenerName: 'test-listener',
+    } as WelcomeEvent)
+    events$.next({type: 'reconnect'})
+    vi.advanceTimersByTime(1000)
+
+    await promise
+  })
+
+  it('rejects first non-welcome reconnect event', async () => {
+    const events$ = new Subject<ListenEvent<SanityDocument>>()
+    mockListen.mockReturnValue(events$)
+
+    const promise = new Promise<void>((resolve) => {
+      listenQuery(mockClient, mockQuery).subscribe({
+        error: (error) => {
+          expect(error.message).toBe('Could not establish EventSource connection')
+          resolve()
+        },
+      })
+    })
+
+    events$.next({type: 'reconnect'})
+    await promise
+  })
+
+  it('rejects first non-welcome mutation event', async () => {
+    const events$ = new Subject<ListenEvent<SanityDocument>>()
+    mockListen.mockReturnValue(events$)
+
+    const promise = new Promise<void>((resolve) => {
+      listenQuery(mockClient, mockQuery).subscribe({
+        error: (error) => {
+          expect(error.message).toBe('Received unexpected type of first event "mutation"')
+          resolve()
+        },
+      })
+    })
+
+    events$.next(createMutationEvent('update', 'evt1', 'tx1'))
+    await promise
+  })
+})