@sanity/sdk 2.1.0 → 2.1.1

package/src/presence/bifurTransport.test.ts

@@ -0,0 +1,257 @@
+import {fromUrl} from '@sanity/bifur-client'
+import {type SanityClient} from '@sanity/client'
+import {of, Subject} from 'rxjs'
+import {beforeEach, describe, expect, it, type Mock, vi} from 'vitest'
+
+import {createBifurTransport} from './bifurTransport'
+import {type PresenceLocation, type TransportEvent} from './types'
+
+vi.mock('@sanity/bifur-client', () => ({
+  fromUrl: vi.fn(),
+}))
+
+const fromUrlMock = fromUrl as Mock
+
+type BifurStateMessage = {
+  type: 'state'
+  i: string
+  m: {
+    sessionId: string
+    locations: PresenceLocation[]
+  }
+}
+
+type BifurDisconnectMessage = {
+  type: 'disconnect'
+  i: string
+  m: {session: string}
+}
+
+type BifurRollCallEvent = {
+  type: 'rollCall'
+  i: string
+  session: string
+}
+
+type IncomingBifurEvent = BifurRollCallEvent | BifurStateMessage | BifurDisconnectMessage
+
+describe('createBifurTransport', () => {
+  let mockBifurClient: {
+    listen: Mock
+    request: Mock
+  }
+  let mockSanityClient: SanityClient
+  let token$: Subject<string | null>
+
+  beforeEach(() => {
+    vi.useFakeTimers()
+    mockBifurClient = {
+      listen: vi.fn(() => new Subject<never>()),
+      request: vi.fn(() => of(undefined)),
+    }
+    fromUrlMock.mockReturnValue(mockBifurClient)
+
+    mockSanityClient = {
+      config: () => ({
+        dataset: 'test-dataset',
+        url: 'http://localhost:3333',
+        requestTagPrefix: 'test-tag',
+      }),
+      withConfig: vi.fn().mockReturnThis(),
+    } as unknown as SanityClient
+
+    token$ = new Subject<string | null>()
+  })
+
+  it('constructs the bifur client with the correct URL', () => {
+    createBifurTransport({
+      client: mockSanityClient,
+      token$,
+      sessionId: 'session-id-123',
+    })
+
+    expect(fromUrlMock).toHaveBeenCalledWith(
+      'ws://localhost:3333/socket/test-dataset?tag=test-tag',
+      {
+        token$,
+      },
+    )
+  })
+
+  it('handles incoming rollCall events', () => {
+    const incomingBifurEvents$ = new Subject<IncomingBifurEvent>()
+    mockBifurClient.listen.mockReturnValue(incomingBifurEvents$)
+
+    const [incomingEvents$] = createBifurTransport({
+      client: mockSanityClient,
+      token$,
+      sessionId: 'session-id-123',
+    })
+
+    const receivedEvents: TransportEvent[] = []
+    incomingEvents$.subscribe((event) => receivedEvents.push(event))
+
+    incomingBifurEvents$.next({
+      type: 'rollCall',
+      i: 'user-1',
+      session: 'session-id-456',
+    })
+
+    expect(receivedEvents).toEqual([
+      {
+        type: 'rollCall',
+        userId: 'user-1',
+        sessionId: 'session-id-456',
+      },
+    ])
+  })
+
+  it('handles incoming state events', () => {
+    const date = new Date('2024-01-01T12:00:00.000Z')
+    vi.setSystemTime(date)
+
+    const incomingBifurEvents$ = new Subject<IncomingBifurEvent>()
+    mockBifurClient.listen.mockReturnValue(incomingBifurEvents$)
+
+    const [incomingEvents$] = createBifurTransport({
+      client: mockSanityClient,
+      token$,
+      sessionId: 'session-id-123',
+    })
+
+    const receivedEvents: TransportEvent[] = []
+    incomingEvents$.subscribe((event) => receivedEvents.push(event))
+
+    const locations: PresenceLocation[] = [
+      {type: 'document', documentId: 'doc1', path: ['a'], lastActiveAt: new Date().toISOString()},
+    ]
+    incomingBifurEvents$.next({
+      type: 'state',
+      i: 'user-1',
+      m: {
+        sessionId: 'session-id-456',
+        locations,
+      },
+    })
+
+    expect(receivedEvents).toEqual([
+      {
+        type: 'state',
+        userId: 'user-1',
+        sessionId: 'session-id-456',
+        timestamp: date.toISOString(),
+        locations,
+      },
+    ])
+  })
+
+  it('handles incoming disconnect events', () => {
+    const date = new Date('2024-01-01T12:00:00.000Z')
+    vi.setSystemTime(date)
+
+    const incomingBifurEvents$ = new Subject<IncomingBifurEvent>()
+    mockBifurClient.listen.mockReturnValue(incomingBifurEvents$)
+
+    const [incomingEvents$] = createBifurTransport({
+      client: mockSanityClient,
+      token$,
+      sessionId: 'session-id-123',
+    })
+
+    const receivedEvents: TransportEvent[] = []
+    incomingEvents$.subscribe((event) => receivedEvents.push(event))
+
+    incomingBifurEvents$.next({
+      type: 'disconnect',
+      i: 'user-1',
+      m: {
+        session: 'session-id-456',
+      },
+    })
+
+    expect(receivedEvents).toEqual([
+      {
+        type: 'disconnect',
+        userId: 'user-1',
+        sessionId: 'session-id-456',
+        timestamp: date.toISOString(),
+      },
+    ])
+  })
+
+  it('throws an error for unknown incoming events', () => {
+    const incomingBifurEvents$ = new Subject<IncomingBifurEvent>()
+    mockBifurClient.listen.mockReturnValue(incomingBifurEvents$)
+
+    const [incomingEvents$] = createBifurTransport({
+      client: mockSanityClient,
+      token$,
+      sessionId: 'session-id-123',
+    })
+
+    const errors: Error[] = []
+    incomingEvents$.subscribe({
+      error: (err) => errors.push(err),
+    })
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    incomingBifurEvents$.next({type: 'unknown'} as any)
+
+    expect(errors.length).toBe(1)
+    expect(errors[0]).toBeInstanceOf(Error)
+    expect(errors[0].message).toContain('Got unknown presence event')
+  })
+
+  describe('dispatchMessage', () => {
+    it('sends a "rollCall" message', () => {
+      const [, dispatchMessage] = createBifurTransport({
+        client: mockSanityClient,
+        token$,
+        sessionId: 'my-session',
+      })
+      dispatchMessage({type: 'rollCall'})
+      expect(mockBifurClient.request).toHaveBeenCalledWith('presence_rollcall', {
+        session: 'my-session',
+      })
+    })
+
+    it('sends a "state" message', () => {
+      const [, dispatchMessage] = createBifurTransport({
+        client: mockSanityClient,
+        token$,
+        sessionId: 'my-session',
+      })
+      const locations: PresenceLocation[] = [
+        {type: 'document', documentId: 'doc1', path: ['a'], lastActiveAt: new Date().toISOString()},
+      ]
+      dispatchMessage({type: 'state', locations})
+      expect(mockBifurClient.request).toHaveBeenCalledWith('presence_announce', {
+        data: {locations, sessionId: 'my-session'},
+      })
+    })
+
+    it('sends a "disconnect" message', () => {
+      const [, dispatchMessage] = createBifurTransport({
+        client: mockSanityClient,
+        token$,
+        sessionId: 'my-session',
+      })
+      dispatchMessage({type: 'disconnect'})
+      expect(mockBifurClient.request).toHaveBeenCalledWith('presence_disconnect', {
+        session: 'my-session',
+      })
+    })
+
+    it('does nothing for unknown message types', () => {
+      const [, dispatchMessage] = createBifurTransport({
+        client: mockSanityClient,
+        token$,
+        sessionId: 'my-session',
+      })
+      // The type assertion is needed to test this case
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      dispatchMessage({type: 'unknown'} as any)
+      expect(mockBifurClient.request).not.toHaveBeenCalled()
+    })
+  })
+})

package/src/presence/bifurTransport.ts

@@ -0,0 +1,108 @@
+import {type BifurClient, fromUrl} from '@sanity/bifur-client'
+import {type SanityClient} from '@sanity/client'
+import {EMPTY, fromEvent, type Observable} from 'rxjs'
+import {map, share, switchMap} from 'rxjs/operators'
+
+import {
+  type BifurTransportOptions,
+  type PresenceLocation,
+  type PresenceTransport,
+  type TransportEvent,
+  type TransportMessage,
+} from './types'
+
+type BifurStateMessage = {
+  type: 'state'
+  i: string
+  m: {
+    sessionId: string
+    locations: PresenceLocation[]
+  }
+}
+
+type BifurDisconnectMessage = {
+  type: 'disconnect'
+  i: string
+  m: {session: string}
+}
+
+type RollCallEvent = {
+  type: 'rollCall'
+  i: string
+  session: string
+}
+
+type IncomingBifurEvent = RollCallEvent | BifurStateMessage | BifurDisconnectMessage
+
+function getBifurClient(client: SanityClient, token$: Observable<string | null>): BifurClient {
+  const bifurVersionedClient = client.withConfig({apiVersion: '2022-06-30'})
+  const {dataset, url: baseUrl, requestTagPrefix = 'sanity.studio'} = bifurVersionedClient.config()
+  const url = `${baseUrl.replace(/\/+$/, '')}/socket/${dataset}`.replace(/^http/, 'ws')
+  const urlWithTag = `${url}?tag=${requestTagPrefix}`
+
+  return fromUrl(urlWithTag, {token$})
+}
+
+const handleIncomingMessage = (event: IncomingBifurEvent): TransportEvent => {
+  switch (event.type) {
+    case 'rollCall':
+      return {
+        type: 'rollCall',
+        userId: event.i,
+        sessionId: event.session,
+      }
+    case 'state': {
+      const {sessionId, locations} = event.m
+      return {
+        type: 'state',
+        userId: event.i,
+        sessionId,
+        timestamp: new Date().toISOString(),
+        locations,
+      }
+    }
+    case 'disconnect':
+      return {
+        type: 'disconnect',
+        userId: event.i,
+        sessionId: event.m.session,
+        timestamp: new Date().toISOString(),
+      }
+    default: {
+      throw new Error(`Got unknown presence event: ${JSON.stringify(event)}`)
+    }
+  }
+}
+
+export const createBifurTransport = (options: BifurTransportOptions): PresenceTransport => {
+  const {client, token$, sessionId} = options
+  const bifur = getBifurClient(client, token$)
+
+  const incomingEvents$: Observable<TransportEvent> = bifur
+    .listen<IncomingBifurEvent>('presence')
+    .pipe(map(handleIncomingMessage))
+
+  const dispatchMessage = (message: TransportMessage): Observable<void> => {
+    switch (message.type) {
+      case 'rollCall':
+        return bifur.request('presence_rollcall', {session: sessionId})
+      case 'state':
+        return bifur.request('presence_announce', {
+          data: {locations: message.locations, sessionId},
+        })
+      case 'disconnect':
+        return bifur.request('presence_disconnect', {session: sessionId})
+      default: {
+        return EMPTY
+      }
+    }
+  }
+
+  if (typeof window !== 'undefined') {
+    fromEvent(window, 'beforeunload')
+      .pipe(switchMap(() => dispatchMessage({type: 'disconnect'})))
+      .subscribe()
+  }
+
+  return [incomingEvents$.pipe(share()), dispatchMessage]
+}

package/src/presence/presenceStore.test.ts

@@ -0,0 +1,247 @@
+import {type SanityClient} from '@sanity/client'
+import {delay, firstValueFrom, of, Subject} from 'rxjs'
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
+
+import {getTokenState} from '../auth/authStore'
+import {getClient} from '../client/clientStore'
+import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
+import {type SanityUser} from '../users/types'
+import {getUserState} from '../users/usersStore'
+import {createBifurTransport} from './bifurTransport'
+import {getPresence} from './presenceStore'
+import {type PresenceLocation, type TransportEvent} from './types'
+
+vi.mock('../auth/authStore')
+vi.mock('../client/clientStore')
+vi.mock('../users/usersStore')
+vi.mock('./bifurTransport')
+
+describe('presenceStore', () => {
+  let instance: SanityInstance
+  let mockClient: SanityClient
+  let mockTokenState: Subject<string | null>
+  let mockIncomingEvents: Subject<TransportEvent>
+  let mockDispatchMessage: ReturnType<typeof vi.fn>
+  let mockGetUserState: ReturnType<typeof vi.fn>
+
+  const mockUser: SanityUser = {
+    sanityUserId: 'u123',
+    profile: {
+      id: 'user-1',
+      displayName: 'Test User',
+      email: 'test@example.com',
+      provider: 'google',
+      createdAt: '2023-01-01T00:00:00Z',
+    },
+    memberships: [],
+  }
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+
+    // Mock crypto.randomUUID
+    Object.defineProperty(global, 'crypto', {
+      value: {
+        randomUUID: vi.fn(() => 'test-session-id'),
+      },
+    })
+
+    mockClient = {
+      withConfig: vi.fn().mockReturnThis(),
+    } as unknown as SanityClient
+
+    mockTokenState = new Subject<string | null>()
+    mockIncomingEvents = new Subject<TransportEvent>()
+    mockDispatchMessage = vi.fn(() => of(undefined))
+
+    vi.mocked(getClient).mockReturnValue(mockClient)
+    vi.mocked(getTokenState).mockReturnValue({
+      observable: mockTokenState.asObservable(),
+      getCurrent: vi.fn(),
+      subscribe: vi.fn(),
+    })
+
+    vi.mocked(createBifurTransport).mockReturnValue([
+      mockIncomingEvents.asObservable(),
+      mockDispatchMessage,
+    ])
+
+    mockGetUserState = vi.fn(() => of(mockUser))
+    vi.mocked(getUserState).mockImplementation(mockGetUserState)
+
+    instance = createSanityInstance({projectId: 'test-project', dataset: 'test-dataset'})
+  })
+
+  afterEach(() => {
+    instance.dispose()
+  })
+
+  describe('getPresence', () => {
+    it('creates bifur transport with correct parameters', () => {
+      getPresence(instance)
+
+      expect(createBifurTransport).toHaveBeenCalledWith({
+        client: mockClient,
+        token$: expect.any(Object),
+        sessionId: 'test-session-id',
+      })
+    })
+
+    it('sends rollCall message on initialization', () => {
+      getPresence(instance)
+
+      expect(mockDispatchMessage).toHaveBeenCalledWith({type: 'rollCall'})
+    })
+
+    it('returns empty array when no users present', () => {
+      const source = getPresence(instance)
+      expect(source.getCurrent()).toEqual([])
+    })
+
+    it('handles state events from other users', async () => {
+      const source = getPresence(instance)
+
+      // Subscribe to initialize the store
+      const unsubscribe = source.subscribe(() => {})
+
+      // Wait a bit for initialization
+      await firstValueFrom(of(null).pipe(delay(10)))
+
+      const locations: PresenceLocation[] = [
+        {
+          type: 'document',
+          documentId: 'doc-1',
+          path: ['title'],
+          lastActiveAt: '2023-01-01T12:00:00Z',
+        },
+      ]
+
+      mockIncomingEvents.next({
+        type: 'state',
+        userId: 'user-1',
+        sessionId: 'other-session',
+        timestamp: '2023-01-01T12:00:00Z',
+        locations,
+      })
+
+      // Wait for processing
+      await firstValueFrom(of(null).pipe(delay(20)))
+
+      const presence = source.getCurrent()
+      expect(presence).toHaveLength(1)
+      expect(presence[0].sessionId).toBe('other-session')
+      expect(presence[0].locations).toEqual(locations)
+
+      unsubscribe()
+    })
+
+    it('ignores events from own session', async () => {
+      const source = getPresence(instance)
+      const unsubscribe = source.subscribe(() => {})
+
+      await firstValueFrom(of(null).pipe(delay(10)))
+
+      mockIncomingEvents.next({
+        type: 'state',
+        userId: 'user-1',
+        sessionId: 'test-session-id', // Same as our session
+        timestamp: '2023-01-01T12:00:00Z',
+        locations: [],
+      })
+
+      await firstValueFrom(of(null).pipe(delay(20)))
+
+      const presence = source.getCurrent()
+      expect(presence).toHaveLength(0)
+
+      unsubscribe()
+    })
+
+    it('handles disconnect events', async () => {
+      const source = getPresence(instance)
+      const unsubscribe = source.subscribe(() => {})
+
+      await firstValueFrom(of(null).pipe(delay(10)))
+
+      // First add a user
+      mockIncomingEvents.next({
+        type: 'state',
+        userId: 'user-1',
+        sessionId: 'other-session',
+        timestamp: '2023-01-01T12:00:00Z',
+        locations: [],
+      })
+
+      await firstValueFrom(of(null).pipe(delay(20)))
+      expect(source.getCurrent()).toHaveLength(1)
+
+      // Then disconnect them
+      mockIncomingEvents.next({
+        type: 'disconnect',
+        userId: 'user-1',
+        sessionId: 'other-session',
+        timestamp: '2023-01-01T12:01:00Z',
+      })
+
+      await firstValueFrom(of(null).pipe(delay(20)))
+      expect(source.getCurrent()).toHaveLength(0)
+
+      unsubscribe()
+    })
+
+    it('fetches user data for present users', async () => {
+      const source = getPresence(instance)
+      const unsubscribe = source.subscribe(() => {})
+
+      await firstValueFrom(of(null).pipe(delay(10)))
+
+      mockIncomingEvents.next({
+        type: 'state',
+        userId: 'user-1',
+        sessionId: 'other-session',
+        timestamp: '2023-01-01T12:00:00Z',
+        locations: [
+          {
+            type: 'document',
+            documentId: 'doc-1',
+            path: ['title'],
+            lastActiveAt: '2023-01-01T12:00:00Z',
+          },
+        ],
+      })
+
+      await firstValueFrom(of(null).pipe(delay(50)))
+
+      expect(getUserState).toHaveBeenCalledWith(instance, {
+        userId: 'user-1',
+        resourceType: 'project',
+        projectId: 'test-project',
+      })
+
+      unsubscribe()
+    })
+
+    it('handles presence events correctly', async () => {
+      const source = getPresence(instance)
+      const unsubscribe = source.subscribe(() => {})
+
+      await firstValueFrom(of(null).pipe(delay(10)))
+
+      mockIncomingEvents.next({
+        type: 'state',
+        userId: 'test-user',
+        sessionId: 'other-session',
+        timestamp: '2023-01-01T12:00:00Z',
+        locations: [],
+      })
+
+      await firstValueFrom(of(null).pipe(delay(50)))
+
+      const presence = source.getCurrent()
+      expect(presence).toHaveLength(1)
+      expect(presence[0].sessionId).toBe('other-session')
+
+      unsubscribe()
+    })
+  })
+})