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

package/src/comlink/controller/actions/getOrCreateChannel.test.ts

@@ -1,39 +1,60 @@
-import {type Controller} from '@sanity/comlink'
+import {type ChannelInstance, type Controller} from '@sanity/comlink'
 import {beforeEach, describe, expect, it, vi} from 'vitest'
 
-import {config} from '../../../../test/fixtures'
-import {createSanityInstance} from '../../../instance/sanityInstance'
-import {type SanityInstance} from '../../../instance/types'
-import {getOrCreateResource} from '../../../resources/createResource'
-import {comlinkControllerStore} from '../comlinkControllerStore'
+import {createSanityInstance} from '../../../store/createSanityInstance'
+import {createStoreState} from '../../../store/createStoreState'
+import {type FrameMessage, type WindowMessage} from '../../types'
+import {type ChannelEntry, type ComlinkControllerState} from '../comlinkControllerStore'
 import {getOrCreateChannel} from './getOrCreateChannel'
-import {getOrCreateController} from './getOrCreateController'
 
 const channelConfig = {
   name: 'test',
   connectTo: 'iframe',
 }
 
-describe('createChannel', () => {
-  let instance: SanityInstance
-  let controller: Controller
+describe('getOrCreateChannel', () => {
+  const instance = createSanityInstance({
+    projectId: 'test-project-id',
+    dataset: 'test-dataset',
+  })
+  let state: ReturnType<typeof createStoreState<ComlinkControllerState>>
+  let mockController: Partial<Controller>
+  let mockChannel: Partial<ChannelInstance<FrameMessage, WindowMessage>>
 
   beforeEach(() => {
-    instance = createSanityInstance(config)
-    controller = getOrCreateController(instance, 'https://test.sanity.dev')!
+    // Set up mock channel that we can spy on
+    mockChannel = {
+      start: vi.fn(),
+      stop: vi.fn(),
+      on: vi.fn(),
+      post: vi.fn(),
+    }
+
+    // Set up mock controller that returns our mock channel
+    mockController = {
+      createChannel: vi.fn(() => mockChannel as ChannelInstance<FrameMessage, WindowMessage>),
+      destroy: vi.fn(),
+    }
+
+    // Initialize fresh test store state with a mock controller
+    state = createStoreState<ComlinkControllerState>({
+      controller: mockController as Controller,
+      controllerOrigin: 'https://test.sanity.dev',
+      channels: new Map(),
+    })
+
     vi.clearAllMocks()
   })
 
   it('should create a new channel using the controller', () => {
-    const createChannelSpy = vi.spyOn(controller, 'createChannel')
+    const createChannelSpy = vi.spyOn(mockController, 'createChannel')
 
-    const channel = getOrCreateChannel(instance, channelConfig)
+    const channel = getOrCreateChannel({state, instance}, channelConfig)
 
     expect(createChannelSpy).toHaveBeenCalledWith(channelConfig)
     expect(channel.on).toBeDefined()
     expect(channel.post).toBeDefined()
-    const store = getOrCreateResource(instance, comlinkControllerStore)
-    expect(store.state.get().channels.get('test')).toStrictEqual(
+    expect(state.get().channels.get('test')).toStrictEqual(
       expect.objectContaining({
         channel,
         options: channelConfig,
@@ -42,34 +63,42 @@ describe('createChannel', () => {
   })
 
   it('should throw error when controller is not initialized', () => {
-    const store = getOrCreateResource(instance, comlinkControllerStore)
-
-    store.state.set('test reset', {
+    // Reset state to have no controller
+    state.set('reset', {
       controller: null,
+      controllerOrigin: null,
       channels: new Map(),
     })
 
-    expect(() => getOrCreateChannel(instance, channelConfig)).toThrow(
+    expect(() => getOrCreateChannel({state, instance}, channelConfig)).toThrow(
       'Controller must be initialized before using or creating channels',
     )
   })
 
   it('should retrieve channel directly from store once created', () => {
-    const createdChannel = getOrCreateChannel(instance, channelConfig)
+    const createdChannel = getOrCreateChannel({state, instance}, channelConfig)
+    vi.clearAllMocks() // Clear call counts
 
-    const retrievedChannel = getOrCreateChannel(instance, channelConfig)
+    // Retrieve channel again
+    const retrievedChannel = getOrCreateChannel({state, instance}, channelConfig)
     expect(retrievedChannel).toBeDefined()
     expect(retrievedChannel).toBe(createdChannel)
+
+    // Should increment refCount
+    const channelEntry = state.get().channels.get('test') as ChannelEntry
+    expect(channelEntry.refCount).toBe(2)
+
+    // Start should be called again
+    expect(mockChannel.start).toHaveBeenCalled()
+    // But createChannel should not be called again
+    expect(mockController.createChannel).not.toHaveBeenCalled()
   })
 
   it('should throw error when trying to create channel with different options', () => {
-    getOrCreateChannel(instance, channelConfig)
+    getOrCreateChannel({state, instance}, channelConfig)
 
     expect(() =>
-      getOrCreateChannel(instance, {
-        ...channelConfig,
-        connectTo: 'window',
-      }),
+      getOrCreateChannel({state, instance}, {...channelConfig, connectTo: 'window'}),
     ).toThrow('Channel "test" already exists with different options')
   })
 })

package/src/comlink/controller/actions/getOrCreateChannel.ts

@@ -1,51 +1,53 @@
-import {type ChannelInput} from '@sanity/comlink'
+import {type ChannelInput, type ChannelInstance} from '@sanity/comlink'
 import {isEqual} from 'lodash-es'
 
-import {createAction} from '../../../resources/createAction'
-import {comlinkControllerStore} from '../comlinkControllerStore'
+import {type StoreContext} from '../../../store/defineStore'
+import {type FrameMessage, type WindowMessage} from '../../types'
+import {type ComlinkControllerState} from '../comlinkControllerStore'
 
 /**
  * Retrieve or create a channel to be used for communication between
  * an application and the controller.
  * @public
  */
-export const getOrCreateChannel = createAction(comlinkControllerStore, ({state}) => {
-  return (options: ChannelInput) => {
-    const controller = state.get().controller
+export const getOrCreateChannel = (
+  {state}: StoreContext<ComlinkControllerState>,
+  options: ChannelInput,
+): ChannelInstance<FrameMessage, WindowMessage> => {
+  const controller = state.get().controller
+
+  if (!controller) {
+    throw new Error('Controller must be initialized before using or creating channels')
+  }
 
-    if (!controller) {
-      throw new Error('Controller must be initialized before using or creating channels')
-    }
+  const channels = state.get().channels
+  const existing = channels.get(options.name)
 
-    const channels = state.get().channels
-    const existing = channels.get(options.name)
-
-    // limit channels to one per name
-    if (existing) {
-      if (!isEqual(existing.options, options)) {
-        throw new Error(`Channel "${options.name}" already exists with different options`)
-      }
-
-      state.set('incrementChannelRefCount', {
-        channels: new Map(channels).set(options.name, {
-          ...existing,
-          refCount: existing.refCount + 1,
-        }),
-      })
-      existing.channel.start()
-      return existing.channel
+  // limit channels to one per name
+  if (existing) {
+    if (!isEqual(existing.options, options)) {
+      throw new Error(`Channel "${options.name}" already exists with different options`)
     }
 
-    const channel = controller.createChannel(options)
-    channel.start()
-    state.set('createChannel', {
+    state.set('incrementChannelRefCount', {
       channels: new Map(channels).set(options.name, {
-        channel,
-        options,
-        refCount: 1,
+        ...existing,
+        refCount: existing.refCount + 1,
       }),
     })
-
-    return channel
+    existing.channel.start()
+    return existing.channel
   }
-})
+
+  const channel = controller.createChannel(options)
+  channel.start()
+  state.set('createChannel', {
+    channels: new Map(channels).set(options.name, {
+      channel,
+      options,
+      refCount: 1,
+    }),
+  })
+
+  return channel
+}

package/src/comlink/controller/actions/getOrCreateController.test.ts

@@ -1,11 +1,9 @@
 import * as comlink from '@sanity/comlink'
-import {beforeEach, describe, expect, it, vi} from 'vitest'
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
 
-import {config} from '../../../../test/fixtures'
-import {createSanityInstance} from '../../../instance/sanityInstance'
-import {type SanityInstance} from '../../../instance/types'
-import {getOrCreateResource} from '../../../resources/createResource'
-import {comlinkControllerStore} from '../comlinkControllerStore'
+import {createSanityInstance, type SanityInstance} from '../../../store/createSanityInstance'
+import {createStoreState} from '../../../store/createStoreState'
+import {type ComlinkControllerState} from '../comlinkControllerStore'
 import {getOrCreateController} from './getOrCreateController'
 
 vi.mock('@sanity/comlink', () => {
@@ -20,36 +18,46 @@ vi.mock('@sanity/comlink', () => {
 
 describe('getOrCreateController', () => {
   let instance: SanityInstance
+  let state: ReturnType<typeof createStoreState<ComlinkControllerState>>
 
   beforeEach(() => {
-    instance = createSanityInstance(config)
-    const store = getOrCreateResource(instance, comlinkControllerStore)
+    instance = createSanityInstance({
+      projectId: 'test-project-id',
+      dataset: 'test-dataset',
+    })
 
-    // Reset store state
-    store.state.set('test reset', {
+    state = createStoreState<ComlinkControllerState>({
       controller: null,
+      controllerOrigin: null,
       channels: new Map(),
     })
+
     vi.clearAllMocks()
   })
 
+  afterEach(() => {
+    instance.dispose()
+  })
+
   it('should create a new controller if none exists', () => {
     const controllerSpy = vi.spyOn(comlink, 'createController')
     const targetOrigin = 'https://test.sanity.dev'
 
-    const controller = getOrCreateController(instance, targetOrigin)
+    const controller = getOrCreateController({state, instance}, targetOrigin)
 
     expect(controllerSpy).toHaveBeenCalledWith({targetOrigin})
     expect(controller).toBeDefined()
-    expect(controller!.destroy).toBeDefined() // Verify it's a real controller
+    expect(controller.destroy).toBeDefined() // Verify it's a real controller
+    expect(state.get().controller).toBe(controller)
+    expect(state.get().controllerOrigin).toBe(targetOrigin)
   })
 
   it('should return existing controller if one exists', () => {
     const controllerSpy = vi.spyOn(comlink, 'createController')
     const targetOrigin = 'https://test.sanity.dev'
 
-    const firstController = getOrCreateController(instance, targetOrigin)
-    const secondController = getOrCreateController(instance, targetOrigin)
+    const firstController = getOrCreateController({state, instance}, targetOrigin)
+    const secondController = getOrCreateController({state, instance}, targetOrigin)
 
     expect(controllerSpy).toHaveBeenCalledTimes(1)
     expect(firstController).toBe(secondController)
@@ -60,10 +68,13 @@ describe('getOrCreateController', () => {
     const targetOrigin = 'https://test.sanity.dev'
     const targetOrigin2 = 'https://test2.sanity.dev'
 
-    const firstController = getOrCreateController(instance, targetOrigin)
-    const secondController = getOrCreateController(instance, targetOrigin2)
+    const firstController = getOrCreateController({state, instance}, targetOrigin)
+    const destroySpy = vi.spyOn(firstController, 'destroy')
+    const secondController = getOrCreateController({state, instance}, targetOrigin2)
 
     expect(controllerSpy).toHaveBeenCalledTimes(2)
+    expect(destroySpy).toHaveBeenCalled()
     expect(firstController).not.toBe(secondController)
+    expect(state.get().controllerOrigin).toBe(targetOrigin2)
   })
 })

package/src/comlink/controller/actions/getOrCreateController.ts

@@ -1,7 +1,7 @@
-import {createController} from '@sanity/comlink'
+import {type Controller, createController} from '@sanity/comlink'
 
-import {createAction} from '../../../resources/createAction'
-import {comlinkControllerStore} from '../comlinkControllerStore'
+import {type StoreContext} from '../../../store/defineStore'
+import {type ComlinkControllerState} from '../comlinkControllerStore'
 import {destroyController} from './destroyController'
 
 /**
@@ -9,25 +9,26 @@ import {destroyController} from './destroyController'
  * between an application and iframes.
  * @public
  */
-export const getOrCreateController = createAction(comlinkControllerStore, ({state, instance}) => {
-  return (targetOrigin: string) => {
-    const {controller, controllerOrigin} = state.get()
-    if (controller && controllerOrigin === targetOrigin) {
-      return controller
-    }
+export const getOrCreateController = (
+  {state, instance}: StoreContext<ComlinkControllerState>,
+  targetOrigin: string,
+): Controller => {
+  const {controller, controllerOrigin} = state.get()
+  if (controller && controllerOrigin === targetOrigin) {
+    return controller
+  }
 
-    // if the target origin has changed, we'll create a new controller,
-    // but need to clean up first
-    if (controller) {
-      destroyController({state, instance})
-    }
+  // if the target origin has changed, we'll create a new controller,
+  // but need to clean up first
+  if (controller) {
+    destroyController({state, instance})
+  }
 
-    const newController = createController({targetOrigin})
-    state.set('initializeController', {
-      controllerOrigin: targetOrigin,
-      controller: newController,
-    })
+  const newController = createController({targetOrigin})
+  state.set('initializeController', {
+    controllerOrigin: targetOrigin,
+    controller: newController,
+  })
 
-    return newController
-  }
-})
+  return newController
+}

package/src/comlink/controller/actions/releaseChannel.test.ts

@@ -1,13 +1,15 @@
+import {type ChannelInput, type ChannelInstance, type Controller} from '@sanity/comlink'
 import {beforeEach, describe, expect, it, vi} from 'vitest'
 
-import {config} from '../../../../test/fixtures'
-import {createSanityInstance} from '../../../instance/sanityInstance'
-import {type SanityInstance} from '../../../instance/types'
-import {getOrCreateResource} from '../../../resources/createResource'
-import {comlinkControllerStore} from '../comlinkControllerStore'
-import {getOrCreateChannel} from './getOrCreateChannel'
-import {getOrCreateController} from './getOrCreateController'
-import {releaseChannel} from './releaseChannel'
+import {type StoreAction} from '../../../store/createActionBinder'
+import {createSanityInstance, type SanityInstance} from '../../../store/createSanityInstance'
+import {} from '../../../store/createStateSourceAction'
+import {createStoreInstance, type StoreInstance} from '../../../store/createStoreInstance'
+import {type FrameMessage, type WindowMessage} from '../../types'
+import {type ComlinkControllerState, comlinkControllerStore} from '../comlinkControllerStore'
+import {getOrCreateChannel as unboundGetOrCreateChannel} from './getOrCreateChannel'
+import {getOrCreateController as unboundGetOrCreateController} from './getOrCreateController'
+import {releaseChannel as unboundReleaseChannel} from './releaseChannel'
 
 const channelConfig = {
   name: 'test',
@@ -16,19 +18,44 @@ const channelConfig = {
 
 describe('releaseChannel', () => {
   let instance: SanityInstance
+  let store: StoreInstance<ComlinkControllerState>
+
+  let getOrCreateChannel: (
+    inst: SanityInstance,
+    options: ChannelInput,
+  ) => ChannelInstance<FrameMessage, WindowMessage>
+  let getOrCreateController: (inst: SanityInstance, targetOrigin: string) => Controller
+  let releaseChannel: (inst: SanityInstance, channelName: string) => void
 
   beforeEach(() => {
-    instance = createSanityInstance(config)
+    instance = createSanityInstance({projectId: 'test-project-id', dataset: 'test-dataset'})
+    store = createStoreInstance(instance, comlinkControllerStore)
+
+    const bind =
+      <TParams extends unknown[], TReturn>(
+        action: StoreAction<ComlinkControllerState, TParams, TReturn>,
+      ) =>
+      (inst: SanityInstance, ...params: TParams) =>
+        action({instance: inst, state: store.state}, ...params)
+
+    getOrCreateChannel = bind(unboundGetOrCreateChannel)
+    getOrCreateController = bind(unboundGetOrCreateController)
+    releaseChannel = bind(unboundReleaseChannel)
+
     getOrCreateController(instance, 'https://test.sanity.dev')!
     vi.clearAllMocks()
   })
 
+  afterEach(() => {
+    instance.dispose()
+    store.dispose()
+  })
+
   it('should remove channel when released', () => {
     // Create a channel
     getOrCreateChannel(instance, channelConfig)
 
     // Get store state
-    const store = getOrCreateResource(instance, comlinkControllerStore)
     expect(store.state.get().channels.has('test')).toBe(true)
 
     // Release the channel
@@ -75,7 +102,6 @@ describe('releaseChannel', () => {
     expect(stopSpy).not.toHaveBeenCalled()
 
     // Verify refCount is 1
-    const store = getOrCreateResource(instance, comlinkControllerStore)
     const channelEntry = store.state.get().channels.get('test')
     expect(channelEntry?.refCount).toBe(1)
   })
@@ -89,7 +115,6 @@ describe('releaseChannel', () => {
     releaseChannel(instance, 'test')
     releaseChannel(instance, 'test')
 
-    const store = getOrCreateResource(instance, comlinkControllerStore)
     expect(store.state.get().channels.has('test')).toBe(false)
   })
 
@@ -104,7 +129,6 @@ describe('releaseChannel', () => {
     getOrCreateChannel(instance, channelConfig)
     getOrCreateChannel(instance, channelConfig)
 
-    const store = getOrCreateResource(instance, comlinkControllerStore)
     let channelEntry = store.state.get().channels.get('test')
 
     // Initial refCount should be 3

package/src/comlink/controller/actions/releaseChannel.ts

@@ -1,30 +1,31 @@
-import {createAction} from '../../../resources/createAction'
-import {comlinkControllerStore} from '../comlinkControllerStore'
+import {type StoreContext} from '../../../store/defineStore'
+import {type ComlinkControllerState} from '../comlinkControllerStore'
 
 /**
  * Signals to the store that the consumer has stopped using the channel
  * @public
  */
-export const releaseChannel = createAction(comlinkControllerStore, ({state}) => {
-  return (name: string) => {
-    const channels = state.get().channels
-    const channelEntry = channels.get(name)
+export const releaseChannel = (
+  {state}: StoreContext<ComlinkControllerState>,
+  name: string,
+): void => {
+  const channels = state.get().channels
+  const channelEntry = channels.get(name)
 
-    if (channelEntry) {
-      const newRefCount = channelEntry.refCount === 0 ? 0 : channelEntry.refCount - 1
+  if (channelEntry) {
+    const newRefCount = channelEntry.refCount === 0 ? 0 : channelEntry.refCount - 1
 
-      if (newRefCount === 0) {
-        channelEntry.channel.stop()
-        channels.delete(name)
-        state.set('releaseChannel', {channels: new Map(channels)})
-      } else {
-        state.set('releaseChannel', {
-          channels: new Map(channels).set(name, {
-            ...channelEntry,
-            refCount: newRefCount,
-          }),
-        })
-      }
+    if (newRefCount === 0) {
+      channelEntry.channel.stop()
+      channels.delete(name)
+      state.set('releaseChannel', {channels: new Map(channels)})
+    } else {
+      state.set('releaseChannel', {
+        channels: new Map(channels).set(name, {
+          ...channelEntry,
+          refCount: newRefCount,
+        }),
+      })
     }
   }
-})
+}

package/src/comlink/controller/comlinkControllerStore.test.ts

@@ -1,59 +1,88 @@
-import {describe, expect, it} from 'vitest'
+import {type Controller} from '@sanity/comlink'
+import {describe, expect, it, vi} from 'vitest'
 
-import {config} from '../../../test/fixtures'
-import {createSanityInstance} from '../../instance/sanityInstance'
-import {type SanityInstance} from '../../instance/types'
-import {createResourceState, getOrCreateResource} from '../../resources/createResource'
-import {getOrCreateController} from './actions/getOrCreateController'
-import {comlinkControllerStore} from './comlinkControllerStore'
+import {bindActionGlobally} from '../../store/createActionBinder'
+import {createSanityInstance, type SanityInstance} from '../../store/createSanityInstance'
+import {} from '../../store/createStateSourceAction'
+import {createStoreState} from '../../store/createStoreState'
+import {type ComlinkControllerState} from './comlinkControllerStore'
 
-describe('comlinkStore', () => {
+vi.mock('../../store/createActionBinder', async (importOriginal) => ({
+  ...(await importOriginal<typeof import('../../store/createActionBinder')>()),
+  bindActionGlobally: vi.fn(),
+}))
+
+describe('comlinkControllerStore', () => {
   let instance: SanityInstance
   beforeEach(() => {
-    instance = createSanityInstance(config)
+    vi.resetModules()
+    instance = createSanityInstance({
+      projectId: 'test-project-id',
+      dataset: 'test-dataset',
+    })
+  })
+
+  afterEach(() => {
+    instance.dispose()
   })
 
-  it('should have correct initial state', () => {
-    const store = getOrCreateResource(instance, comlinkControllerStore)
-    const initialState = store.state.get()
+  it('should have correct initial state', async () => {
+    const {comlinkControllerStore} = await import('./comlinkControllerStore')
+
+    // Create store state directly
+    const state = createStoreState<ComlinkControllerState>(
+      comlinkControllerStore.getInitialState(instance),
+    )
+
+    const initialState = state.get()
 
     expect(initialState.controller).toBeNull()
     expect(initialState.channels).toBeInstanceOf(Map)
     expect(initialState.channels.size).toBe(0)
   })
 
-  it('should cleanup controller on dispose', () => {
-    // Create instance and initialize controller
-    const controller = getOrCreateController(instance, 'https://test.sanity.dev')
-    const destroySpy = vi.spyOn(controller!, 'destroy')
-
-    // Get initial state and create resource state
-    const initialState = comlinkControllerStore.getInitialState(instance)
-    initialState.controller = controller // Set the controller in our initial state
-
-    const dispose = comlinkControllerStore.initialize!.call(
-      {
-        instance,
-        state: createResourceState(initialState),
-      },
-      instance,
+  it('should cleanup controller on dispose', async () => {
+    const controller = {
+      destroy: vi.fn() as Controller['destroy'],
+    } as Controller
+
+    // Set up state with controller
+    const state = createStoreState<ComlinkControllerState>({
+      controller,
+      controllerOrigin: 'https://test.sanity.dev',
+      channels: new Map(),
+    })
+
+    vi.mocked(bindActionGlobally).mockImplementation(
+      (_storeDef, action) =>
+        (inst: SanityInstance, ...params: unknown[]) =>
+          action({instance: inst, state}, ...params),
     )
 
+    const {comlinkControllerStore} = await import('./comlinkControllerStore')
+
+    // Get the cleanup function from the store
+    const dispose = comlinkControllerStore.initialize?.({state, instance})
+
     // Run cleanup
     dispose?.()
 
     // Verify controller.destroy was called
-    expect(destroySpy).toHaveBeenCalled()
+    expect(controller.destroy).toHaveBeenCalled()
   })
 
-  it('should handle cleanup when no controller exists', () => {
-    const cleanup = comlinkControllerStore.initialize!.call(
-      {
-        instance,
-        state: createResourceState(comlinkControllerStore.getInitialState(instance)),
-      },
-      instance,
-    )
+  it('should handle cleanup when no controller exists', async () => {
+    const {comlinkControllerStore} = await import('./comlinkControllerStore')
+
+    // Set up state with no controller
+    const state = createStoreState<ComlinkControllerState>({
+      controller: null,
+      controllerOrigin: null,
+      channels: new Map(),
+    })
+
+    // Get the cleanup function
+    const cleanup = comlinkControllerStore.initialize?.({state, instance})
 
     // Should not throw when no controller exists
     expect(() => cleanup?.()).not.toThrow()