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

package/src/resources/createResource.ts

@@ -1,102 +0,0 @@
-import {Observable} from 'rxjs'
-import {devtools, type DevtoolsOptions} from 'zustand/middleware'
-import {createStore} from 'zustand/vanilla'
-
-import {type SanityInstance, type SdkIdentity} from '../instance/types'
-import {getEnv} from '../utils/getEnv'
-
-const resourceCache = new WeakMap<SdkIdentity, Map<string, InitializedResource<unknown>>>()
-
-type Teardown = () => void
-
-export interface Resource<TState> {
-  name: string
-  getInitialState(instance: SanityInstance): TState
-  initialize?: (
-    this: {instance: SanityInstance; state: ResourceState<TState>},
-    instance: SanityInstance,
-  ) => Teardown
-}
-
-export function createResource<TState>(resource: Resource<TState>): Resource<TState> {
-  return resource
-}
-
-/**
- * @public
- */
-export type ResourceState<TState> = {
-  get: () => TState
-  set: (name: string, state: Partial<TState> | ((s: TState) => Partial<TState>)) => void
-  observable: Observable<TState>
-}
-
-export interface InitializedResource<TState> {
-  state: ResourceState<TState>
-  dispose: () => void
-}
-
-export function createResourceState<TState>(
-  initialState: TState,
-  devToolsOptions?: DevtoolsOptions,
-): ResourceState<TState> {
-  const store = createStore<TState>()(devtools(() => initialState, devToolsOptions))
-  return {
-    get: store.getState,
-    set: (actionKey, updatedState) => {
-      // avoids unnecessary updates if the state remains unchanged. since we
-      // use immutable data, this is safe and aligns with React's approach
-      if (store.getState() !== updatedState) {
-        store.setState(updatedState, false, actionKey)
-      }
-    },
-    observable: new Observable((observer) => {
-      const emit = () => observer.next(store.getState())
-      emit()
-      return store.subscribe(emit)
-    }),
-  }
-}
-
-export function initializeResource<TState>(
-  instance: SanityInstance,
-  resource: Resource<TState>,
-): InitializedResource<TState> {
-  const fullName =
-    resource.name === 'Auth' ? 'Auth-global' : `${resource.name}-${instance.identity.resourceId}`
-  const initialState = resource.getInitialState(instance)
-  const state = createResourceState(initialState, {
-    name: fullName,
-    enabled: !!getEnv('DEV'),
-  })
-  const dispose = resource.initialize?.call({instance, state}, instance) ?? (() => {})
-
-  return {state, dispose}
-}
-
-export function getOrCreateResource<TState>(
-  instance: SanityInstance,
-  resource: Resource<TState>,
-): InitializedResource<TState> {
-  const fullName =
-    resource.name === 'Auth' ? 'Auth-global' : `${resource.name}-${instance.identity.resourceId}`
-  if (!resourceCache.has(instance.identity)) {
-    resourceCache.set(instance.identity, new Map())
-  }
-  const initializedResources = resourceCache.get(instance.identity)!
-  const cached = initializedResources.get(fullName)
-  if (cached) return cached as InitializedResource<TState>
-
-  const result = initializeResource(instance, resource)
-  initializedResources.set(fullName, result)
-  return result
-}
-
-export function disposeResources(identity: SdkIdentity): void {
-  const resources = resourceCache.get(identity)
-  if (!resources) return
-
-  for (const resource of resources.values()) {
-    resource.dispose()
-  }
-}

package/src/resources/createStateSourceAction.test.ts

@@ -1,114 +0,0 @@
-import {describe, expect, it, vi} from 'vitest'
-
-import {createSanityInstance} from '../instance/sanityInstance'
-import {createAction} from './createAction'
-import {createResource} from './createResource'
-import {createStateSourceAction} from './createStateSourceAction'
-
-describe('createStateSourceAction', () => {
-  const resource = createResource({
-    name: 'testResource',
-    getInitialState: () => ({value: 10, subscribed: false}),
-  })
-
-  const setValue = createAction(resource, ({state}) => {
-    return function (value: number) {
-      state.set('updateValue', {value})
-    }
-  })
-
-  const getValueState = createStateSourceAction(resource, {
-    selector: (state) => state.value,
-    onSubscribe: ({state}) => {
-      state.set('setSubscribedTrue', {subscribed: true})
-
-      return () => {
-        state.set('setSubscribedFalse', {subscribed: false})
-      }
-    },
-  })
-
-  const getSubscribed = createAction(resource, ({state}) => {
-    return function () {
-      return state.get().subscribed
-    }
-  })
-
-  it('should return the current value', () => {
-    const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
-    const valueState = getValueState(instance)
-
-    expect(valueState.getCurrent()).toBe(10)
-  })
-
-  it('should subscribe to state changes and call the provided function', () => {
-    const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
-    const valueState = getValueState(instance)
-
-    const mockCallback = vi.fn()
-    valueState.subscribe(mockCallback)
-
-    setValue(instance, 5)
-
-    expect(mockCallback).toHaveBeenCalledTimes(1)
-  })
-
-  it('should unsubscribe from the state changes', () => {
-    const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
-    const valueState = getValueState(instance)
-    const mockCallback = vi.fn()
-
-    const unsubscribe = valueState.subscribe(mockCallback)
-    unsubscribe()
-
-    setValue(instance, 5)
-    expect(mockCallback).toHaveBeenCalledTimes(0)
-  })
-
-  it('should emit only when the value actually changes', () => {
-    const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
-    const valueState = getValueState(instance)
-
-    const mockCallback = vi.fn()
-    valueState.subscribe(mockCallback)
-
-    setValue(instance, valueState.getCurrent())
-    expect(mockCallback).toHaveBeenCalledTimes(0)
-
-    setValue(instance, 5)
-    expect(mockCallback).toHaveBeenCalledTimes(1)
-  })
-
-  it('returns an observable that emits the current value on subscribe', () => {
-    const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
-    const valueState = getValueState(instance)
-
-    const observer = vi.fn()
-    const subscription = valueState.observable.subscribe(observer)
-
-    expect(observer).toHaveBeenCalledTimes(1)
-    expect(observer).toHaveBeenCalledWith(10)
-
-    // try a no-op change
-    setValue(instance, valueState.getCurrent())
-    expect(observer).toHaveBeenCalledTimes(1)
-
-    // set a value that will change
-    setValue(instance, 5)
-    expect(observer).toHaveBeenCalledTimes(2)
-
-    subscription.unsubscribe()
-  })
-
-  it('allows providing an `onSubscribe` handler', () => {
-    const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
-    const valueState = getValueState(instance)
-
-    expect(getSubscribed(instance)).toBe(false)
-    const unsubscribe = valueState.subscribe()
-    expect(getSubscribed(instance)).toBe(true)
-
-    unsubscribe()
-    expect(getSubscribed(instance)).toBe(false)
-  })
-})

package/src/resources/createStateSourceAction.ts

@@ -1,83 +0,0 @@
-import {distinctUntilChanged, map, Observable, share, skip} from 'rxjs'
-
-import {type ActionContext, createAction, type ResourceAction} from './createAction'
-import {type Resource} from './createResource'
-
-/**
- * @public
- */
-export interface StateSource<T> {
-  subscribe: (onStoreChanged?: () => void) => () => void
-  getCurrent: () => T
-  observable: Observable<T>
-}
-
-type Selector<TState, TParams extends unknown[], TReturn> = (
-  state: TState,
-  ...params: TParams
-) => TReturn
-interface StateSourceOptions<TState, TParams extends unknown[], TReturn> {
-  selector: Selector<TState, TParams, TReturn>
-  onSubscribe?: (context: ActionContext<TState>, ...params: TParams) => void | (() => void)
-  isEqual?: (prev: TReturn, curr: TReturn) => boolean
-}
-
-export function createStateSourceAction<TState, TParams extends unknown[], TReturn>(
-  resource: Resource<TState>,
-  options: Selector<TState, TParams, TReturn> | StateSourceOptions<TState, TParams, TReturn>,
-): ResourceAction<TState, TParams, StateSource<TReturn>> {
-  const selector = typeof options === 'function' ? options : options.selector
-  const subscribeHandler = options && 'onSubscribe' in options ? options.onSubscribe : undefined
-  const isEqual = options && 'isEqual' in options ? (options.isEqual ?? Object.is) : Object.is
-
-  return createAction(resource, ({state}) => {
-    return function (...args: TParams): StateSource<TReturn> {
-      const getCurrent = () => selector(state.get(), ...args)
-
-      const subscribe = (onStoreChanged?: () => void) => {
-        const cleanup = subscribeHandler?.(this, ...args)
-
-        const subscription = state.observable
-          .pipe(
-            map(getCurrent),
-            distinctUntilChanged(isEqual),
-            // skip the first emission because we only want to emit when the
-            // value changes. `distinctUntilChanged` will always emit the first
-            // the first value so we skip this emission
-            skip(1),
-          )
-          .subscribe({
-            next: () => onStoreChanged?.(),
-            // the convention is to have the selector throw the error so we
-            // invoke onStoreChanged on error as well. this will cause the
-            // observable code path below to emit an error because the selector
-            // will throw and that will be used to emit an .error on the observer
-            error: () => onStoreChanged?.(),
-          })
-
-        return () => {
-          subscription.unsubscribe()
-          cleanup?.()
-        }
-      }
-
-      const observable = new Observable<TReturn>((observer) => {
-        const emitCurrent = () => {
-          try {
-            observer.next(getCurrent())
-          } catch (error) {
-            observer.error(error)
-          }
-        }
-        emitCurrent()
-        return subscribe(emitCurrent)
-      }).pipe(share())
-
-      return {
-        getCurrent,
-        subscribe,
-        observable,
-      }
-    }
-  })
-}

package/src/resources/createStore.test.ts

@@ -1,67 +0,0 @@
-import {describe, expect, it, vi} from 'vitest'
-
-import {createSanityInstance} from '../instance/sanityInstance'
-import {createAction} from './createAction'
-import {createResource, createResourceState} from './createResource'
-import {createStore} from './createStore'
-
-describe('createStore', () => {
-  const mockInstance = createSanityInstance({projectId: 'test', dataset: 'test'})
-
-  interface TestState {
-    value: number
-  }
-
-  const testResource = createResource<TestState>({
-    name: 'test',
-    getInitialState: () => ({value: 0}),
-    initialize: vi.fn(),
-  })
-
-  const incrementAction = createAction(testResource, ({state}) => {
-    return function () {
-      state.set('increment', (prevState) => ({value: prevState.value + 1}))
-    }
-  })
-
-  const setAction = createAction(testResource, ({state}) => {
-    return function (value: number) {
-      state.set('setValue', {value})
-    }
-  })
-
-  it('should return a store with bound actions and a dispose function', () => {
-    const store = createStore(testResource, {incrementAction, setAction})
-    const instanceStore = store(mockInstance)
-
-    expect(instanceStore).toHaveProperty('dispose')
-    expect(instanceStore).toHaveProperty('incrementAction')
-    expect(instanceStore).toHaveProperty('setAction')
-  })
-
-  it('should bind the actions with state and instance from the sanity instance', () => {
-    const store = createStore(testResource, {incrementAction, setAction})
-    const instanceStore = store(mockInstance)
-
-    instanceStore.incrementAction()
-    const state = createResourceState<TestState>({value: 0})
-    const instanceStore2 = store(mockInstance)
-    instanceStore2.setAction(10)
-
-    expect(state.get()).toEqual({value: 0})
-    expect(instanceStore2.setAction).toBeDefined()
-  })
-
-  it('should dispose of the resource', () => {
-    const resource = createResource<TestState>({
-      name: 'test',
-      getInitialState: () => ({value: 0}),
-      initialize: vi.fn(() => vi.fn()),
-    })
-    const store = createStore(resource, {})
-    const instanceStore = store(mockInstance)
-    instanceStore.dispose()
-    expect(resource.initialize).toHaveBeenCalledTimes(1)
-    expect(resource.initialize).toHaveReturnedWith(expect.any(Function))
-  })
-})

package/src/resources/createStore.ts

@@ -1,46 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import {noop} from 'lodash-es'
-
-import {type SanityInstance} from '../instance/types'
-import {type ActionContext, type ResourceAction} from './createAction'
-import {initializeResource, type Resource} from './createResource'
-
-/**
- * @public
- */
-export type BoundResourceAction<TParams extends unknown[], TReturn> = (
-  ...params: TParams
-) => TReturn
-
-type BoundActions<TActions extends {[key: string]: ResourceAction<any, any, any>}> = {
-  [K in keyof TActions]: TActions[K] extends ResourceAction<any, infer TParams, infer TReturn>
-    ? BoundResourceAction<TParams, TReturn>
-    : never
-}
-
-type StoreFactory<TActions extends {[key: string]: ResourceAction<any, any, any>}> = (
-  instance: SanityInstance | ActionContext<any>,
-) => {
-  dispose: () => void
-} & BoundActions<TActions>
-
-export function createStore<
-  TState,
-  TActions extends {[key: string]: ResourceAction<any, any, any>},
->(resource: Resource<TState>, actions: TActions): StoreFactory<TActions> {
-  return function storeFactory(dependencies: SanityInstance | ActionContext<TState>) {
-    const instance = 'instance' in dependencies ? dependencies.instance : dependencies
-    const {state, dispose} =
-      'state' in dependencies
-        ? {state: dependencies.state, dispose: noop}
-        : initializeResource(instance, resource)
-    const boundActions = Object.entries(actions).reduce<
-      Record<string, BoundResourceAction<unknown[], unknown>>
-    >((acc, [key, action]) => {
-      acc[key] = action.bind(null, {state, instance})
-      return acc
-    }, {}) as BoundActions<TActions>
-
-    return {dispose, ...boundActions}
-  }
-}

package/src/store/createStore.test.ts

@@ -1,108 +0,0 @@
-import {describe, expect, it, vi} from 'vitest'
-
-import {type SanityInstance} from '../instance/types'
-import {createStore, type StoreActionContext} from './createStore'
-
-// Mock the devtools middleware
-vi.mock('zustand/middleware', () => ({
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  devtools: (storeFunction: any) => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return (...args: any[]) => storeFunction(...args)
-  },
-}))
-
-beforeEach(() => {
-  vi.clearAllMocks()
-})
-
-describe('createStore', () => {
-  // Setup mock instance
-  const mockInstance = {
-    identity: {
-      id: 'test-id',
-    },
-  } as SanityInstance
-
-  // Setup types for our test store
-  interface TestState {
-    count: number
-    text: string
-  }
-
-  const initialState: TestState = {
-    count: 0,
-    text: '',
-  }
-
-  // Setup test actions
-  const createTestActions = () => ({
-    increment: ({store}: StoreActionContext<TestState>) => {
-      const state = store.getState()
-      store.setState({...state, count: state.count + 1})
-    },
-    setText: ({store}: StoreActionContext<TestState>, newText: string) => {
-      const state = store.getState()
-      store.setState({...state, text: newText})
-      return newText
-    },
-    getCount: ({store}: StoreActionContext<TestState>) => {
-      return store.getState().count
-    },
-    getText: ({store}: StoreActionContext<TestState>) => {
-      return store.getState().text
-    },
-  })
-
-  it('creates a store with initial state with all properties', () => {
-    const actions = createTestActions()
-    const store = createStore(initialState, actions, {
-      name: 'test-store',
-      instance: mockInstance,
-    })
-
-    // Verify store has all action methods
-    expect(store).toHaveProperty('increment')
-    expect(store).toHaveProperty('setText')
-    expect(store).toHaveProperty('getCount')
-  })
-
-  it('maintains separate state for different stores', () => {
-    const actions = createTestActions()
-    const store1 = createStore(initialState, actions, {
-      name: 'store-1',
-      instance: mockInstance,
-    })
-    const store2 = createStore(initialState, actions, {
-      name: 'store-2',
-      instance: mockInstance,
-    })
-
-    store1.increment()
-    store2.setText('hello')
-
-    // Verify stores are unaffected
-    expect(store1.getCount()).toBe(1)
-    expect(store2.getCount()).toBe(0)
-
-    expect(store1.getText()).toBe('')
-    expect(store2.getText()).toBe('hello')
-  })
-
-  it('correctly updates state through actions', () => {
-    const actions = createTestActions()
-    const store = createStore(initialState, actions, {
-      name: 'test-store',
-      instance: mockInstance,
-    })
-
-    store.increment()
-    expect(store.getCount()).toBe(1)
-
-    store.increment()
-    expect(store.getCount()).toBe(2)
-
-    store.setText('hello world')
-    expect(store.getText()).toBe('hello world')
-  })
-})

package/src/store/createStore.ts

@@ -1,106 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import {devtools} from 'zustand/middleware'
-import {createStore as createZustandStore, type StoreApi} from 'zustand/vanilla'
-
-import {type SanityInstance} from '../instance/types'
-
-/**
- * Creates a (vanilla) zustand store with the given initial state and actions.
- * Only the actions will be returned - actions should be created to interact with it.
- *
- * The rationale for this is to encapsulate the internal state so only the store knows about it,
- * making refactoring easier and more predictable. While this seems like good practice, I am unsure
- * if it might get in our way once we start wanting to subscribe to finer piece of state or similar.
- * I will leave it for now, and we can see if it becomes a problem.
- *
- * @param initialState - Initial state of the store
- * @param actions - The actions available on the store
- * @param options - Options for the store
- * @returns The actions available on the store
- * @internal
- */
-export function createStore<S, A extends StoreActionMap<S>>(
-  initialState: S,
-  actions: A,
-  {name, instance}: StoreOptions,
-): CurriedActions<S, A> {
-  const uniqueName = `${name}-${instance.identity.id}`
-  const store = createZustandStore<S>()(devtools(() => ({...initialState}), {name: uniqueName}))
-  const context = {store, instance}
-  return createCurriedActions(actions, context)
-}
-
-/**
- * Context passed to store actions as first argument.
- *
- * @internal
- */
-export interface StoreActionContext<S> {
-  /**
-   * The store API, from zustand. Contains `getState()`, `setState()`, and `subscribe()`.
-   */
-  store: StoreApi<S>
-
-  /**
-   * The Sanity SDK instance associated with the store. Often used
-   */
-  instance: SanityInstance
-}
-
-/**
- * An action that can be performed on a store.
- *
- * @param context - Store context. Contains the store API (`getState()`, `setState()`, `subscribe()`), as well as the SDK instance associated with it.
- * @internal
- */
-type StoreAction<S> = (context: StoreActionContext<S>, ...args: any[]) => any
-
-/**
- * A map of actions that can be performed on a store.
- *
- * @internal
- */
-type StoreActionMap<S> = Record<string, StoreAction<S>>
-
-/**
- * Options for creating a store.
- *
- * @internal
- */
-interface StoreOptions {
-  /**
-   * Name used for debugging
-   */
-  name: string
-
-  /**
-   * The Sanity SDK instance associated with the store
-   */
-  instance: SanityInstance
-}
-
-function createCurriedActions<S, A extends StoreActionMap<S>>(
-  actions: A,
-  store: StoreActionContext<S>,
-): CurriedActions<S, A> {
-  const curried: CurriedActions<S, A> = {} as CurriedActions<S, A>
-  return Object.entries(actions).reduce((acc, [key, action]) => {
-    const curriedAction = (...args: RestParameters<typeof action>) => action(store, ...args)
-    return {...acc, [key]: curriedAction}
-  }, curried)
-}
-
-type RestParameters<T extends (...args: any[]) => any> = T extends (
-  first: any,
-  ...rest: infer R
-) => any
-  ? R
-  : never
-
-type ActionReturn<T extends (...args: any[]) => any> = ReturnType<T>
-
-type CurriedActions<S, A extends StoreActionMap<S>> = {
-  [K in keyof A]: A[K] extends StoreAction<S>
-    ? (...args: RestParameters<A[K]>) => ActionReturn<A[K]>
-    : never
-}