@sanity/sdk 0.0.0-alpha.21 → 0.0.0-alpha.23

package/src/common/createLiveEventSubscriber.test.ts

@@ -1,121 +0,0 @@
-import {type LiveEventMessage, SanityClient} from '@sanity/client'
-import {Observable, of, Subject} from 'rxjs'
-import {describe, it, vi} from 'vitest'
-
-import {getClientState} from '../client/clientStore'
-import {createSanityInstance} from '../instance/sanityInstance'
-import {createResourceState, type ResourceState} from '../resources/createResource'
-import {type StateSource} from '../resources/createStateSourceAction'
-import {createLiveEventSubscriber} from './createLiveEventSubscriber'
-import {type LiveEventAwareState} from './types'
-
-vi.mock('../client/clientStore.ts', () => ({getClientState: vi.fn()}))
-
-vi.mock('../resources/createResource', async (importOriginal) => {
-  const original = await importOriginal<typeof import('../resources/createResource')>()
-  return {...original, getOrCreateResource: vi.fn()}
-})
-
-describe('createLiveEventSubscriber', () => {
-  const TEST_TAG = 'test-tag'
-  const instance = createSanityInstance({projectId: 'exampleProject', dataset: 'exampleDataset'})
-  const initialState: LiveEventAwareState = {
-    lastLiveEventId: null,
-    syncTags: {},
-  }
-  let state: ResourceState<LiveEventAwareState>
-
-  beforeEach(() => {
-    state = createResourceState(initialState)
-    vi.clearAllMocks()
-  })
-
-  it('listens for matching sync tags and updates the `lastLiveEventId`', async () => {
-    const mockLiveEvents = new Observable<LiveEventMessage>((observer) => {
-      observer.next({
-        type: 'message',
-        id: 'event123',
-        tags: ['s1:tag1', 's1:tag2'],
-      })
-    })
-
-    const mockClient = {
-      live: {
-        events: vi.fn().mockReturnValue(mockLiveEvents),
-      },
-      config: vi.fn().mockReturnValue({}),
-    }
-
-    // Mock the getSubscribableClient to emit our mock client
-    vi.mocked(getClientState).mockReturnValue({
-      observable: of(mockClient as unknown as SanityClient),
-    } as StateSource<SanityClient>)
-
-    // Set up initial state with a matching sync tag
-    state.set('setSyncTags', {
-      syncTags: {
-        's1:tag1': true,
-      },
-    })
-
-    // Create and subscribe to live events
-    const subscribeToLiveAndSetLastLiveEventId =
-      createLiveEventSubscriber<LiveEventAwareState>(TEST_TAG)
-    const subscription = subscribeToLiveAndSetLastLiveEventId({instance, state})
-
-    // Verify the client was configured correctly
-    expect(mockClient.live.events).toHaveBeenCalledWith({
-      includeDrafts: false,
-      tag: TEST_TAG,
-    })
-
-    // Verify the state was updated with the new event ID
-    expect(state.get().lastLiveEventId).toBe('event123')
-
-    // Clean up subscription
-    subscription.unsubscribe()
-  })
-
-  it('unsubscribes from the previous live content connection if any', () => {
-    const unsubscribe = vi.fn()
-
-    const mockLiveEvents = new Observable<LiveEventMessage>((observer) => {
-      observer.next({
-        type: 'message',
-        id: 'event123',
-        tags: ['s1:tag1'],
-      })
-
-      return unsubscribe
-    })
-
-    const mockClient = {
-      live: {
-        events: vi.fn().mockReturnValue(mockLiveEvents),
-      },
-      config: vi.fn().mockReturnValue({}),
-    }
-
-    const clientSubject = new Subject()
-
-    vi.mocked(getClientState).mockReturnValue({
-      observable: clientSubject as Observable<SanityClient>,
-    } as StateSource<SanityClient>)
-
-    // Create and subscribe to live events
-    const subscribeToLiveAndSetLastLiveEventId =
-      createLiveEventSubscriber<LiveEventAwareState>(TEST_TAG)
-    const liveSubscription = subscribeToLiveAndSetLastLiveEventId({instance, state})
-    clientSubject.next(mockClient)
-
-    expect(mockClient.live.events).toHaveBeenCalledTimes(1)
-
-    const newClient = {...mockClient}
-    clientSubject.next(newClient)
-    expect(unsubscribe).toHaveBeenCalledTimes(1)
-
-    // Clean up subscriptions
-    liveSubscription.unsubscribe()
-    expect(unsubscribe).toHaveBeenCalledTimes(2)
-  })
-})

package/src/common/createLiveEventSubscriber.ts

@@ -1,55 +0,0 @@
-import {combineLatest, distinctUntilChanged, filter, map, type Subscription, switchMap} from 'rxjs'
-
-import {getClientState} from '../client/clientStore'
-import {type ActionContext, createInternalAction} from '../resources/createAction'
-import {type LiveEventAwareState} from './types'
-
-/*
- * Factory function for creating a subscribeToLiveAndSetLastLiveEventId action.
- * Typically invoked in the initialization of stores that depend on the live events API.
- * It listens to events associated with sync tags (also kept internally in the store)
-
- * Usage like:
- *
- * const subscribeToLiveAndSetLastLiveEventId = createLiveEventSubscriber<ProjectionStoreState<TValue>>(TAG)
- * const liveSubscription = subscribeToLiveAndSetLastLiveEventId(this)
- *
- * return () => {
- *   stateSubscriptionForBatches.unsubscribe()
- *   liveSubscription.unsubscribe()
- */
-export function createLiveEventSubscriber<TState extends LiveEventAwareState>(
-  tag: string,
-): (actionContext: ActionContext<TState>) => Subscription {
-  return createInternalAction(({instance, state}: ActionContext<TState>) => {
-    const client$ = getClientState(instance, {apiVersion: 'vX'}).observable
-    const syncTags$ = state.observable.pipe(
-      map((i) => i.syncTags),
-      distinctUntilChanged(),
-    )
-
-    return function () {
-      const messageEvents$ = client$.pipe(
-        switchMap((client) =>
-          client.live
-            .events({includeDrafts: !!client.config().token, tag})
-            .pipe(filter((e): e is Extract<typeof e, {type: 'message'}> => e.type === 'message')),
-        ),
-      )
-
-      return combineLatest([messageEvents$, syncTags$]).subscribe({
-        next: ([event, currentSyncTags]) => {
-          for (const eventTag of event.tags) {
-            if (currentSyncTags[eventTag]) {
-              state.set('setLastLiveEventId', (prevState: TState) => ({
-                ...prevState,
-                lastLiveEventId: event.id,
-              }))
-              return
-            }
-          }
-        },
-      })
-    }
-  })
-}

package/src/common/types.ts

@@ -1,4 +0,0 @@
-export interface LiveEventAwareState {
-  lastLiveEventId: string | null
-  syncTags: Record<string, true>
-}

package/src/instance/identity.test.ts

@@ -1,46 +0,0 @@
-import {describe, expect, it} from 'vitest'
-
-import {getSdkIdentity} from './identity'
-
-describe('identity', () => {
-  describe('getSdkIdentity', () => {
-    it('creates a frozen object with expected properties', () => {
-      const identity = getSdkIdentity({
-        projectId: 'test-project',
-        dataset: 'test-dataset',
-      })
-
-      // Check if object is frozen
-      expect(Object.isFrozen(identity)).toBe(true)
-
-      // Check if all expected properties exist
-      expect(identity).toHaveProperty('id')
-      expect(identity).toHaveProperty('projectId', 'test-project')
-      expect(identity).toHaveProperty('dataset', 'test-dataset')
-    })
-
-    it('generates unique ids for different instances', () => {
-      const identity1 = getSdkIdentity({
-        projectId: 'test-project',
-        dataset: 'test-dataset',
-      })
-
-      const identity2 = getSdkIdentity({
-        projectId: 'test-project',
-        dataset: 'test-dataset',
-      })
-
-      expect(identity1.id).not.toBe(identity2.id)
-    })
-
-    it('generates id with correct format', () => {
-      const identity = getSdkIdentity({
-        projectId: 'test-project',
-        dataset: 'test-dataset',
-      })
-
-      // ID should be 16 characters long (8 pairs of hex digits)
-      expect(identity.id).toMatch(/^[0-9a-f]{16}$/)
-    })
-  })
-})

package/src/instance/identity.ts

@@ -1,29 +0,0 @@
-import {type SdkIdentity} from './types'
-
-/**
- * thoughtLevel 2 - Primarily what we want is to have an object that we can bind stores/memoizations to, but let the things that depend on it (eg projectId, dataset) be internals that can't be overwritten by accident/intentionally
- * @public
- */
-export function getSdkIdentity({
-  projectId,
-  dataset,
-}: {
-  projectId: string
-  dataset: string
-}): SdkIdentity {
-  const id = generateId()
-  return Object.freeze({
-    id,
-    projectId,
-    dataset,
-    resourceId: `${projectId}.${dataset}`,
-  })
-}
-
-function generateId() {
-  return Array.from({length: 8}, () =>
-    Math.floor(Math.random() * 16)
-      .toString(16)
-      .padStart(2, '0'),
-  ).join('')
-}

package/src/instance/sanityInstance.test.ts

@@ -1,77 +0,0 @@
-import {beforeEach, describe, expect, test} from 'vitest'
-
-import {disposeResources} from '../resources/createResource'
-import {createSanityInstance, getOrCreateResource} from './sanityInstance'
-import {type SanityConfig} from './types'
-
-vi.mock('../resources/createResource')
-
-describe('sanityInstance', () => {
-  let config: SanityConfig
-
-  beforeEach(() => {
-    config = {
-      projectId: 'test-project',
-      dataset: 'test-dataset',
-    }
-  })
-
-  describe('createSanityInstance', () => {
-    test('creates instance with correct configuration', () => {
-      const instance = createSanityInstance(config)
-
-      expect(instance.identity).toEqual(
-        expect.objectContaining({
-          projectId: 'test-project',
-          dataset: 'test-dataset',
-        }),
-      )
-    })
-
-    test('instance.dispose', () => {
-      const instance = createSanityInstance(config)
-      instance.dispose()
-
-      expect(disposeResources).toHaveBeenCalled()
-    })
-  })
-
-  describe('getOrCreateResource', () => {
-    test('creates and caches resource', () => {
-      const instance = createSanityInstance(config)
-      let createCount = 0
-
-      const creator = () => {
-        createCount++
-        return {value: 'test-resource'}
-      }
-
-      // First call should create new resource
-      const resource1 = getOrCreateResource(instance, 'test-key', creator)
-      expect(resource1).toEqual({value: 'test-resource'})
-      expect(createCount).toBe(1)
-
-      // Second call should return cached resource
-      const resource2 = getOrCreateResource(instance, 'test-key', creator)
-      expect(resource2).toBe(resource1)
-      expect(createCount).toBe(1)
-    })
-
-    test('different instances have separate resource caches', () => {
-      const instance1 = createSanityInstance({...config, projectId: 'project1'})
-      const instance2 = createSanityInstance({...config, projectId: 'project2'})
-      let createCount = 0
-
-      const creator = () => {
-        createCount++
-        return {value: 'test-resource'}
-      }
-
-      const resource1 = getOrCreateResource(instance1, 'test-key', creator)
-      const resource2 = getOrCreateResource(instance2, 'test-key', creator)
-
-      expect(resource1).not.toBe(resource2)
-      expect(createCount).toBe(2)
-    })
-  })
-})

package/src/instance/sanityInstance.ts

@@ -1,57 +0,0 @@
-import {disposeResources} from '../resources/createResource'
-import {getSdkIdentity} from './identity'
-import {type SanityConfig, type SanityInstance, type SdkIdentity} from './types'
-
-/**
- * Returns a new instance of dependencies required for SanitySDK.
- *
- * @public
- *
- * @param config - The configuration for this instance
- *
- * @returns A new "instance" of a Sanity SDK, used to bind resources/configuration to it
- */
-export function createSanityInstance({
-  projectId = '',
-  dataset = '',
-  ...config
-}: SanityConfig): SanityInstance {
-  const identity = getSdkIdentity({projectId, dataset})
-  return {
-    identity,
-    config,
-    dispose: () => disposeResources(identity),
-  }
-}
-
-const resourceStorage = new WeakMap<SdkIdentity, Map<string, unknown>>()
-
-function getResource(instance: SanityInstance, key: string) {
-  const instanceMap = resourceStorage.get(instance.identity)
-  return instanceMap?.get(key)
-}
-
-function setResource(instance: SanityInstance, key: string, value: unknown) {
-  let instanceMap = resourceStorage.get(instance.identity)
-  if (!instanceMap) {
-    instanceMap = new Map()
-    resourceStorage.set(instance.identity, instanceMap)
-  }
-  instanceMap.set(key, value)
-}
-
-/**
- * This is an internal function that retrieves or creates a Zustand store resource.
- * @internal
- */
-export function getOrCreateResource<T>(instance: SanityInstance, key: string, creator: () => T): T {
-  const cached = getResource(instance, key)
-
-  if (cached) {
-    return cached as T
-  }
-
-  const resource = creator()
-  setResource(instance, key, resource)
-  return resource
-}

package/src/instance/types.ts

@@ -1,37 +0,0 @@
-/* eslint-disable import/consistent-type-specifier-style */
-// NOTE: These have to be type import because we do not want the side-effect
-// of importing these modules, we just want the types for their configs
-import type {AuthConfig} from '../auth/authStore'
-import type {ResourceId} from '../document/patchOperations'
-
-/**
- * @public
- */
-export interface SanityConfig {
-  projectId: string
-  dataset: string
-  auth?: AuthConfig
-}
-
-/** @public */
-export interface SanityInstance {
-  /**
-   * The following is used to look up resources associated with this instance,
-   * and can be used to retrieve an "id" for the instance - useful in debugging.
-   *
-   * @public
-   */
-  readonly identity: SdkIdentity
-
-  config: Omit<SanityConfig, 'projectId' | 'dataset'>
-
-  dispose: () => void
-}
-
-/** @public */
-export interface SdkIdentity {
-  readonly id: string
-  readonly projectId: string
-  readonly dataset: string
-  readonly resourceId: ResourceId
-}

package/src/preview/getPreviewProjection.ts

@@ -1,45 +0,0 @@
-/**
- * The fields to check for a title.
- * The order of the items in the array defines the priority.
- *
- * @internal
- */
-export const TITLE_CANDIDATES = ['title', 'name', 'label', 'heading', 'header', 'caption']
-
-/**
- * The fields to check for a subtitle.
- * The order of the items in the array defines the priority.
- *
- * @internal
- */
-export const SUBTITLE_CANDIDATES = ['description', 'subtitle', ...TITLE_CANDIDATES]
-
-/**
- * Generates a GROQ projection for preview data without requiring a schema.
- * Uses common field names to make educated guesses about which fields to use.
- *
- * @internal
- */
-export function getPreviewProjection(): string {
-  return `{
-    // Get all potential title fields
-    "titleCandidates": {
-      ${TITLE_CANDIDATES.map((field) => `"${field}": ${field}`).join(',\n      ')}
-    },
-    // Get all potential subtitle fields
-    "subtitleCandidates": {
-      ${SUBTITLE_CANDIDATES.map((field) => `"${field}": ${field}`).join(',\n      ')}
-    },
-    "media": coalesce(
-      select(
-        defined(asset) => {"type": "image-asset", "_ref": asset._ref},
-        defined(image.asset) => {"type": "image-asset", "_ref": image.asset._ref},
-        defined(mainImage.asset) => {"type": "image-asset", "_ref": mainImage.asset._ref},
-        null
-      )
-    ),
-    _type,
-    _id,
-    _updatedAt
-  }`
-}