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

package/src/utils/createFetcherStore.ts

@@ -14,15 +14,14 @@ import {
   tap,
 } from 'rxjs/operators'
 
-import {type SanityInstance} from '../instance/types'
+import {bindActionGlobally, type BoundStoreAction} from '../store/createActionBinder'
+import {type SanityInstance} from '../store/createSanityInstance'
 import {
-  type ActionContext,
-  createAction,
-  createInternalAction,
-  type ResourceAction,
-} from '../resources/createAction'
-import {createResource} from '../resources/createResource'
-import {createStateSourceAction, type StateSource} from '../resources/createStateSourceAction'
+  createStateSourceAction,
+  type SelectorContext,
+  type StateSource,
+} from '../store/createStateSourceAction'
+import {defineStore, type StoreContext} from '../store/defineStore'
 import {insecureRandomId} from '../utils/ids'
 
 interface CreateFetcherStoreOptions<TParams extends unknown[], TData> {
@@ -38,7 +37,7 @@ interface CreateFetcherStoreOptions<TParams extends unknown[], TData> {
    * The function used to convert the params into keys that state related to
    * those params will be stored.
    */
-  getKey: (...params: TParams) => string
+  getKey: (instance: SanityInstance, ...params: TParams) => string
   /**
    * Delay in ms before clearing state after the last subscription is removed.
    * This results in react components suspending again due to no previous state
@@ -53,6 +52,7 @@ interface CreateFetcherStoreOptions<TParams extends unknown[], TData> {
 
 interface StoreEntry<TParams extends unknown[], TData> {
   params: TParams
+  instance: SanityInstance
   key: string
   data?: TData
   error?: unknown
@@ -74,12 +74,12 @@ export interface FetcherStoreState<TParams extends unknown[], TData> {
  * @public
  */
 export interface FetcherStore<TParams extends unknown[], TData> {
-  getState: ResourceAction<
+  getState: BoundStoreAction<
     FetcherStoreState<TParams, TData>,
     TParams,
     StateSource<TData | undefined>
   >
-  resolveState: ResourceAction<FetcherStoreState<TParams, TData>, TParams, Promise<TData>>
+  resolveState: BoundStoreAction<FetcherStoreState<TParams, TData>, TParams, Promise<TData>>
 }
 
 /**
@@ -108,13 +108,13 @@ export function createFetcherStore<TParams extends unknown[], TData>({
   fetchThrottleInternal = 1000,
   stateExpirationDelay = 5000,
 }: CreateFetcherStoreOptions<TParams, TData>): FetcherStore<TParams, TData> {
-  const store = createResource<FetcherStoreState<TParams, TData>>({
+  const store = defineStore<FetcherStoreState<TParams, TData>>({
     name,
     getInitialState: () => ({
       stateByParams: {},
     }),
-    initialize() {
-      const subscription = subscribeToSubscriptionsAndFetch(this)
+    initialize: (context) => {
+      const subscription = subscribeToSubscriptionsAndFetch(context)
       return () => subscription.unsubscribe()
     },
   })
@@ -125,160 +125,157 @@ export function createFetcherStore<TParams extends unknown[], TData>({
    * and if enough time has elapsed since the last fetch, we update the timestamp
    * and call the factory function for that key.
    */
-  const subscribeToSubscriptionsAndFetch = createInternalAction(
-    ({instance, state}: ActionContext<FetcherStoreState<TParams, TData>>) => {
-      return function () {
-        const factoryFn = getObservable(instance)
+  const subscribeToSubscriptionsAndFetch = ({
+    state,
+  }: StoreContext<FetcherStoreState<TParams, TData>>) => {
+    return state.observable
+      .pipe(
+        // Map the state to an array of [serialized, entry] pairs.
+        switchMap((s: FetcherStoreState<TParams, TData>) => {
+          const entries = Object.entries(s.stateByParams)
+          return entries.length > 0 ? from(entries) : EMPTY
+        }),
+        // Group by the serialized key.
+        groupBy(([key]) => key),
+        mergeMap((group$) =>
+          group$.pipe(
+            // Emit an initial value for pairwise comparisons.
+            startWith<[string, StoreEntry<TParams, TData> | undefined]>([group$.key, undefined]),
+            pairwise(),
+            // Trigger only when the subscriptions array grows.
+            filter(([[, prevEntry], [, currEntry]]) => {
+              const prevSubs = prevEntry?.subscriptions ?? []
+              const currSubs = currEntry?.subscriptions ?? []
+              return currSubs.length > prevSubs.length
+            }),
+            map(([, [, currEntry]]) => currEntry),
 
-        return state.observable
-          .pipe(
-            // Map the state to an array of [serialized, entry] pairs.
-            switchMap((s: FetcherStoreState<TParams, TData>) => {
-              const entries = Object.entries(s.stateByParams)
-              return entries.length > 0 ? from(entries) : EMPTY
+            // Only trigger if we haven't fetched recently.
+            filter((entry) => {
+              const lastFetch = entry?.lastFetchInitiatedAt
+              if (!lastFetch) return true
+              return Date.now() - new Date(lastFetch).getTime() >= fetchThrottleInternal
             }),
-            // Group by the serialized key.
-            groupBy(([key]) => key),
-            mergeMap((group$) =>
-              group$.pipe(
-                // Emit an initial value for pairwise comparisons.
-                startWith<[string, StoreEntry<TParams, TData> | undefined]>([
-                  group$.key,
-                  undefined,
-                ]),
-                pairwise(),
-                // Trigger only when the subscriptions array grows.
-                filter(([[, prevEntry], [, currEntry]]) => {
-                  const prevSubs = prevEntry?.subscriptions ?? []
-                  const currSubs = currEntry?.subscriptions ?? []
-                  return currSubs.length > prevSubs.length
-                }),
-                map(([, [, currEntry]]) => currEntry),
+            switchMap((entry) => {
+              // Retrieve params from the entry
+              if (!entry) return EMPTY
 
-                // Only trigger if we haven't fetched recently.
-                filter((entry) => {
-                  const lastFetch = entry?.lastFetchInitiatedAt
-                  if (!lastFetch) return true
-                  return Date.now() - new Date(lastFetch).getTime() >= fetchThrottleInternal
-                }),
-                switchMap((entry) => {
-                  // Retrieve params from the entry
-                  if (!entry) return EMPTY
+              // Record that a fetch is being initiated.
+              state.set('setLastFetchInitiatedAt', (prev: FetcherStoreState<TParams, TData>) => ({
+                stateByParams: {
+                  ...prev.stateByParams,
+                  [entry.key]: {
+                    ...entry,
+                    ...prev.stateByParams[entry.key],
+                    lastFetchInitiatedAt: new Date().toISOString(),
+                  },
+                },
+              }))
 
-                  // Record that a fetch is being initiated.
-                  state.set(
-                    'setLastFetchInitiatedAt',
-                    (prev: FetcherStoreState<TParams, TData>) => ({
-                      stateByParams: {
-                        ...prev.stateByParams,
-                        [entry.key]: {
-                          ...entry,
-                          ...prev.stateByParams[entry.key],
-                          lastFetchInitiatedAt: new Date().toISOString(),
-                        },
+              const factoryFn = getObservable(entry.instance)
+              return factoryFn(...entry.params).pipe(
+                // the `createStateSourceAction` util requires the update
+                // to
+                delay(0, asapScheduler),
+                tap((data: TData) =>
+                  state.set('setData', (prev: FetcherStoreState<TParams, TData>) => ({
+                    stateByParams: {
+                      ...prev.stateByParams,
+                      [entry.key]: {
+                        ...omit(entry, 'error'),
+                        ...omit(prev.stateByParams[entry.key], 'error'),
+                        data,
                       },
-                    }),
-                  )
-
-                  return factoryFn(...entry.params).pipe(
-                    // the `createStateSourceAction` util requires the update
-                    // to
-                    delay(0, asapScheduler),
-                    tap((data: TData) =>
-                      state.set('setData', (prev: FetcherStoreState<TParams, TData>) => ({
-                        stateByParams: {
-                          ...prev.stateByParams,
-                          [entry.key]: {
-                            ...omit(entry, 'error'),
-                            ...omit(prev.stateByParams[entry.key], 'error'),
-                            data,
-                          },
-                        },
-                      })),
-                    ),
-                    catchError((error) => {
-                      state.set('setError', (prev) => ({
-                        stateByParams: {
-                          ...prev.stateByParams,
-                          [entry.key]: {
-                            ...entry,
-                            ...prev.stateByParams[entry.key],
-                            error,
-                          },
-                        },
-                      }))
+                    },
+                  })),
+                ),
+                catchError((error) => {
+                  state.set('setError', (prev) => ({
+                    stateByParams: {
+                      ...prev.stateByParams,
+                      [entry.key]: {
+                        ...entry,
+                        ...prev.stateByParams[entry.key],
+                        error,
+                      },
+                    },
+                  }))
 
-                      return EMPTY
-                    }),
-                  )
+                  return EMPTY
                 }),
-              ),
-            ),
-          )
-          .subscribe({
-            error: (error) => state.set('setError', {error}),
-          })
-      }
-    },
-  )
+              )
+            }),
+          ),
+        ),
+      )
+      .subscribe({
+        error: (error) => state.set('setError', {error}),
+      })
+  }
 
-  const getState = createStateSourceAction(store, {
-    selector: ({stateByParams, error}: FetcherStoreState<TParams, TData>, ...params: TParams) => {
-      if (error) throw error
-      const key = getKey(...params)
-      const entry = stateByParams[key]
-      if (entry?.error) throw entry.error
-      return entry?.data
-    },
-    onSubscribe: ({state}, ...params: TParams) => {
-      const subscriptionId = insecureRandomId()
-      const key = getKey(...params)
+  const getState = bindActionGlobally(
+    store,
+    createStateSourceAction({
+      selector: (
+        {
+          instance,
+          state: {stateByParams, error},
+        }: SelectorContext<FetcherStoreState<TParams, TData>>,
+        ...params: TParams
+      ) => {
+        if (error) throw error
+        const key = getKey(instance, ...params)
+        const entry = stateByParams[key]
+        if (entry?.error) throw entry.error
+        return entry?.data
+      },
+      onSubscribe: ({instance, state}, ...params: TParams) => {
+        const subscriptionId = insecureRandomId()
+        const key = getKey(instance, ...params)
 
-      state.set('addSubscription', (prev: FetcherStoreState<TParams, TData>) => ({
-        stateByParams: {
-          ...prev.stateByParams,
-          [key]: {
-            ...prev.stateByParams[key],
-            key,
-            params: prev.stateByParams[key]?.params || params,
-            subscriptions: [...(prev.stateByParams[key]?.subscriptions || []), subscriptionId],
+        state.set('addSubscription', (prev: FetcherStoreState<TParams, TData>) => ({
+          stateByParams: {
+            ...prev.stateByParams,
+            [key]: {
+              ...prev.stateByParams[key],
+              instance,
+              key,
+              params: prev.stateByParams[key]?.params || params,
+              subscriptions: [...(prev.stateByParams[key]?.subscriptions || []), subscriptionId],
+            },
           },
-        },
-      }))
+        }))
 
-      return () => {
-        setTimeout(() => {
-          state.set('removeSubscription', (prev: FetcherStoreState<TParams, TData>) => {
-            const entry = prev.stateByParams[key]
-            if (!entry) return prev
+        return () => {
+          setTimeout(() => {
+            state.set('removeSubscription', (prev: FetcherStoreState<TParams, TData>) => {
+              const entry = prev.stateByParams[key]
+              if (!entry) return prev
 
-            const newSubs = (entry.subscriptions || []).filter((id) => id !== subscriptionId)
-            if (newSubs.length === 0) {
-              return {stateByParams: omit(prev.stateByParams, key)}
-            }
+              const newSubs = (entry.subscriptions || []).filter((id) => id !== subscriptionId)
+              if (newSubs.length === 0) {
+                return {stateByParams: omit(prev.stateByParams, key)}
+              }
 
-            return {
-              stateByParams: {
-                ...prev.stateByParams,
-                [key]: {
-                  ...entry,
-                  subscriptions: newSubs,
+              return {
+                stateByParams: {
+                  ...prev.stateByParams,
+                  [key]: {
+                    ...entry,
+                    subscriptions: newSubs,
+                  },
                 },
-              },
-            }
-          })
-        }, stateExpirationDelay)
-      }
-    },
-  })
+              }
+            })
+          }, stateExpirationDelay)
+        }
+      },
+    }),
+  )
 
-  const resolveState = createAction(store, () => {
-    return function (...params: TParams) {
-      return firstValueFrom(
-        getState(this, ...params).observable.pipe(first((i) => i !== undefined)),
-      )
-    }
-  })
+  const resolveState = bindActionGlobally(store, ({instance}, ...params: TParams) =>
+    firstValueFrom(getState(instance, ...params).observable.pipe(first((i) => i !== undefined))),
+  )
 
   return {getState, resolveState}
 }

package/src/{common/util.test.ts → utils/hashString.test.ts}

@@ -1,6 +1,6 @@
 import {describe, expect, it} from 'vitest'
 
-import {hashString} from './util'
+import {hashString} from './hashString'
 
 describe('hashString', () => {
   it('should generate consistent hashes for the same input', () => {

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