@sanity/sdk 0.0.0-chore-react-18-compat.1 → 0.0.0-chore-react-18-compat.3

package/src/auth/fetchLoginUrls.test.ts

@@ -1,163 +0,0 @@
-import {createSanityInstance} from '../instance/sanityInstance'
-import {createResourceState} from '../resources/createResource'
-import {authStore} from './authStore'
-import {fetchLoginUrls} from './fetchLoginUrls'
-
-describe('fetchLoginUrls', () => {
-  it('returns providers with updated URLs', async () => {
-    const mockRequest = vi.fn().mockResolvedValue({
-      providers: [
-        {title: 'Provider A', url: 'https://auth.example.com/a'},
-        {title: 'Provider B', url: 'https://auth.example.com/b'},
-      ],
-    })
-    const clientFactory = vi.fn().mockReturnValue({request: mockRequest})
-    const instance = createSanityInstance({
-      projectId: 'p',
-      dataset: 'd',
-      auth: {clientFactory},
-    })
-    const state = createResourceState(authStore.getInitialState(instance))
-    const providers = await fetchLoginUrls({instance, state})
-
-    expect(providers.length).toBe(2)
-    expect(providers[0].url).toContain('withSid=true')
-    expect(providers[1].url).toContain('withSid=true')
-  })
-
-  it('caches the providers and early returns', async () => {
-    const clientFactory = vi.fn()
-    const instance = createSanityInstance({
-      projectId: 'p',
-      dataset: 'd',
-      auth: {clientFactory},
-    })
-    const state = createResourceState(authStore.getInitialState(instance))
-
-    const provider = {
-      name: 'cached-provided',
-      title: 'cached provider',
-      url: 'https://auth.example.com#withSid=true',
-    }
-    state.set('setInitialProviders', {providers: [provider]})
-
-    const providers = await fetchLoginUrls({instance, state})
-
-    expect(providers.length).toBe(1)
-    expect(providers[0].url).toContain('https://auth.example.com#withSid=true')
-  })
-
-  it('handles providers as a static array and merges/replaces accordingly', async () => {
-    const mockRequest = vi.fn().mockResolvedValue({
-      providers: [
-        {title: 'Provider A', name: 'provider-a', url: 'https://auth.example.com/a'},
-        {title: 'Provider B', name: 'provider-b', url: 'https://auth.example.com/b'},
-      ],
-    })
-    const clientFactory = vi.fn().mockReturnValue({request: mockRequest})
-    const instance = createSanityInstance({
-      projectId: 'p',
-      dataset: 'd',
-      auth: {
-        clientFactory,
-        providers: [
-          {
-            title: 'Custom Provider B',
-            name: 'custom-provider-b',
-            url: 'https://auth.example.com/b',
-          },
-          {title: 'Provider C', name: 'provider-c', url: 'https://auth.example.com/c'},
-        ],
-      },
-    })
-    const state = createResourceState(authStore.getInitialState(instance))
-    const providers = await fetchLoginUrls({instance, state})
-
-    expect(providers.find((p) => p.title === 'Provider A')).toBeTruthy()
-    expect(providers.find((p) => p.title === 'Custom Provider B')).toBeTruthy()
-    expect(providers.find((p) => p.title === 'Provider C')).toBeTruthy()
-    expect(providers.find((p) => p.title === 'Provider B')).toBeFalsy()
-  })
-
-  it('allows custom provider function modification', async () => {
-    const mockRequest = vi.fn().mockResolvedValue({
-      providers: [{title: 'Provider A', url: 'https://auth.example.com/a'}],
-    })
-    const clientFactory = vi.fn().mockReturnValue({request: mockRequest})
-    const instance = createSanityInstance({
-      projectId: 'p',
-      dataset: 'd',
-      auth: {
-        clientFactory,
-        providers: (defaults) => defaults.map((p) => ({...p, title: 'Modified ' + p.title})),
-      },
-    })
-    const state = createResourceState(authStore.getInitialState(instance))
-    const providers = await fetchLoginUrls({instance, state})
-
-    expect(providers[0].title).toBe('Modified Provider A')
-  })
-
-  it('uses default providers if none are specified', async () => {
-    const mockRequest = vi.fn().mockResolvedValue({
-      providers: [{title: 'Provider A', url: 'https://auth.example.com/a'}],
-    })
-    const clientFactory = vi.fn().mockReturnValue({request: mockRequest})
-    const instance = createSanityInstance({
-      projectId: 'p',
-      dataset: 'd',
-      auth: {
-        clientFactory,
-      },
-    })
-    const state = createResourceState(authStore.getInitialState(instance))
-    const providers = await fetchLoginUrls({instance, state})
-
-    expect(providers.length).toBe(1)
-    expect(providers[0].title).toBe('Provider A')
-  })
-
-  it('includes callbackUrl in provider URLs if set', async () => {
-    const mockRequest = vi.fn().mockResolvedValue({
-      providers: [{title: 'Provider A', url: 'https://auth.example.com/a'}],
-    })
-    const clientFactory = vi.fn().mockReturnValue({request: mockRequest})
-    const instance = createSanityInstance({
-      projectId: 'p',
-      dataset: 'd',
-      auth: {
-        clientFactory,
-        callbackUrl: 'http://localhost/callback',
-      },
-    })
-    const state = createResourceState(authStore.getInitialState(instance))
-    const providers = await fetchLoginUrls({instance, state})
-    expect(providers[0].url).toContain('origin=http%3A%2F%2Flocalhost%2Fcallback')
-  })
-
-  it('should allow async custom provider function', async () => {
-    const mockRequest = vi.fn().mockResolvedValue({
-      providers: [{title: 'Provider A', url: 'https://auth.example.com/a'}],
-    })
-    const clientFactory = vi.fn().mockReturnValue({request: mockRequest})
-    const instance = createSanityInstance({
-      projectId: 'p',
-      dataset: 'd',
-      auth: {
-        clientFactory,
-        providers: async (defaults) => {
-          await new Promise((r) => setTimeout(r, 10))
-          return defaults.concat([
-            {title: 'Provider C', name: 'provider-c', url: 'https://auth.example.com/c'},
-          ])
-        },
-      },
-    })
-    const state = createResourceState(authStore.getInitialState(instance))
-
-    const providers = await fetchLoginUrls({instance, state})
-
-    expect(providers.length).toBe(2)
-    expect(providers.some((p) => p.title === 'Provider C')).toBe(true)
-  })
-})

package/src/auth/fetchLoginUrls.ts

@@ -1,74 +0,0 @@
-import {type AuthProvider} from '@sanity/client'
-
-import {createAction} from '../resources/createAction'
-import {DEFAULT_API_VERSION, REQUEST_TAG_PREFIX} from './authConstants'
-import {authStore} from './authStore'
-import {getDefaultLocation} from './utils'
-
-/**
- * @public
- */
-export const fetchLoginUrls = createAction(authStore, ({state}) => {
-  const {callbackUrl, clientFactory, apiHost, customProviders} = state.get().options
-  const client = clientFactory({
-    apiVersion: DEFAULT_API_VERSION,
-    requestTagPrefix: REQUEST_TAG_PREFIX,
-    useProjectHostname: false,
-    ...(apiHost && {apiHost}),
-  })
-
-  return async function () {
-    const cachedProviders = state.get().providers
-    if (cachedProviders) return cachedProviders
-
-    const {providers: defaultProviders} = await client.request<{providers: AuthProvider[]}>({
-      uri: '/auth/providers',
-      tag: 'fetch-providers',
-    })
-
-    let providers: AuthProvider[]
-
-    if (typeof customProviders === 'function') {
-      providers = await customProviders(defaultProviders)
-    } else if (!customProviders?.length) {
-      providers = defaultProviders
-    } else {
-      const customProviderUrls = new Set(customProviders.map((p) => p.url))
-      providers = defaultProviders
-        .filter((official) => !customProviderUrls.has(official.url))
-        .concat(customProviders)
-    }
-
-    const configuredProviders = providers.map((provider) => {
-      const url = new URL(provider.url)
-      const origin = new URL(
-        callbackUrl
-          ? new URL(callbackUrl, new URL(getDefaultLocation()).origin).toString()
-          : getDefaultLocation(),
-      )
-
-      // `getDefaultLocation()` may be populated with an `sid` from a previous
-      // failed login attempt and should be omitted from the next login URL
-      const hashParams = new URLSearchParams(origin.hash.slice(1))
-      hashParams.delete('sid')
-      origin.hash = hashParams.toString()
-      origin.searchParams.delete('sid')
-      origin.searchParams.delete('url')
-
-      // similarly, the origin may be populated with an `error` query param if
-      // the auth provider redirects back to the application. this should also
-      // be omitted from the origin sent
-      origin.searchParams.delete('error')
-
-      url.searchParams.set('origin', origin.toString())
-      url.searchParams.set('withSid', 'true')
-      url.searchParams.set('type', 'stampedToken')
-
-      return {...provider, url: url.toString()}
-    })
-
-    state.set('fetchedLoginUrls', {providers: configuredProviders})
-
-    return configuredProviders
-  }
-})

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
-}