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

package/src/comlink/controller/comlinkControllerStore.ts

@@ -1,8 +1,12 @@
 import {type ChannelInput, type ChannelInstance, type Controller} from '@sanity/comlink'
 
-import {createResource} from '../../resources/createResource'
+import {bindActionGlobally} from '../../store/createActionBinder'
+import {defineStore} from '../../store/defineStore'
 import {type FrameMessage, type WindowMessage} from '../types'
-import {destroyController} from './actions/destroyController'
+import {destroyController as unboundDestroyController} from './actions/destroyController'
+import {getOrCreateChannel as unboundGetOrCreateChannel} from './actions/getOrCreateChannel'
+import {getOrCreateController as unboundGetOrCreateController} from './actions/getOrCreateController'
+import {releaseChannel as unboundReleaseChannel} from './actions/releaseChannel'
 
 /**
  * Individual channel with its relevant options
@@ -26,7 +30,7 @@ export interface ComlinkControllerState {
   channels: Map<string, ChannelEntry>
 }
 
-export const comlinkControllerStore = createResource<ComlinkControllerState>({
+export const comlinkControllerStore = defineStore<ComlinkControllerState>({
   name: 'connectionStore',
   getInitialState: () => {
     const initialState = {
@@ -36,10 +40,45 @@ export const comlinkControllerStore = createResource<ComlinkControllerState>({
     }
     return initialState
   },
-  initialize() {
+  initialize({instance}) {
     return () => {
       // destroying controller also destroys channels
-      destroyController(this)
+      destroyController(instance)
     }
   },
 })
+
+/**
+ * Calls the destroy method on the controller and resets the controller state.
+ * @public
+ */
+export const destroyController = bindActionGlobally(
+  comlinkControllerStore,
+  unboundDestroyController,
+)
+
+/**
+ * Retrieve or create a channel to be used for communication between
+ * an application and the controller.
+ * @public
+ */
+export const getOrCreateChannel = bindActionGlobally(
+  comlinkControllerStore,
+  unboundGetOrCreateChannel,
+)
+
+/**
+ * Initializes or fetches a controller to handle communication
+ * between an application and iframes.
+ * @public
+ */
+export const getOrCreateController = bindActionGlobally(
+  comlinkControllerStore,
+  unboundGetOrCreateController,
+)
+
+/**
+ * Signals to the store that the consumer has stopped using the channel
+ * @public
+ */
+export const releaseChannel = bindActionGlobally(comlinkControllerStore, unboundReleaseChannel)

package/src/comlink/node/actions/getOrCreateNode.test.ts

@@ -1,9 +1,11 @@
 import * as comlink from '@sanity/comlink'
+import {type Node} 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 {createSanityInstance} from '../../../store/createSanityInstance'
+import {createStoreState} from '../../../store/createStoreState'
+import {type FrameMessage, type WindowMessage} from '../../types'
+import {type ComlinkNodeState} from '../comlinkNodeStore'
 import {getOrCreateNode} from './getOrCreateNode'
 
 vi.mock('@sanity/comlink', () => ({
@@ -17,35 +19,49 @@ const nodeConfig = {
   name: 'test-node',
   connectTo: 'parent',
 }
-describe('createNode', () => {
-  let instance: SanityInstance
+
+describe('getOrCreateNode', () => {
+  const instance = createSanityInstance({
+    projectId: 'test-project-id',
+    dataset: 'test-dataset',
+  })
+  let state: ReturnType<typeof createStoreState<ComlinkNodeState>>
+  let mockNode: Partial<Node<WindowMessage, FrameMessage>> & {
+    start: ReturnType<typeof vi.fn>
+    stop: ReturnType<typeof vi.fn>
+  }
 
   beforeEach(() => {
-    instance = createSanityInstance(config)
+    mockNode = {start: vi.fn(), stop: vi.fn()}
+    vi.mocked(comlink.createNode).mockReturnValue(mockNode as Node<WindowMessage, FrameMessage>)
+    state = createStoreState<ComlinkNodeState>({nodes: new Map()})
     vi.clearAllMocks()
   })
 
   it('should create and start a node', () => {
-    const node = getOrCreateNode(instance, nodeConfig)
+    const node = getOrCreateNode({state, instance}, nodeConfig)
 
     expect(comlink.createNode).toHaveBeenCalledWith(nodeConfig)
     expect(node.start).toHaveBeenCalled()
   })
 
-  it('should store the node in nodeStore', () => {
-    const node = getOrCreateNode(instance, nodeConfig)
+  it('sshould store the node in nodeStore', () => {
+    const node = getOrCreateNode({state, instance}, nodeConfig)
 
-    expect(getOrCreateNode(instance, nodeConfig)).toBe(node)
+    expect(getOrCreateNode({state, instance}, nodeConfig)).toBe(node)
   })
 
   it('should throw error when trying to create node with different options', () => {
-    getOrCreateNode(instance, nodeConfig)
+    getOrCreateNode({state, instance}, nodeConfig)
 
     expect(() =>
-      getOrCreateNode(instance, {
-        ...nodeConfig,
-        connectTo: 'window',
-      }),
+      getOrCreateNode(
+        {state, instance},
+        {
+          ...nodeConfig,
+          connectTo: 'window',
+        },
+      ),
     ).toThrow('Node "test-node" already exists with different options')
   })
 })

package/src/comlink/node/actions/getOrCreateNode.ts

@@ -1,9 +1,9 @@
 import {createNode, type Node, type NodeInput} from '@sanity/comlink'
 import {isEqual} from 'lodash-es'
 
-import {createAction} from '../../../resources/createAction'
+import {type StoreContext} from '../../../store/defineStore'
 import {type FrameMessage, type WindowMessage} from '../../types'
-import {comlinkNodeStore} from '../comlinkNodeStore'
+import {type ComlinkNodeState} from '../comlinkNodeStore'
 
 /**
  * Retrieve or create a node to be used for communication between
@@ -11,35 +11,36 @@ import {comlinkNodeStore} from '../comlinkNodeStore'
  * be created within a frame / window to communicate with the controller.
  * @public
  */
-export const getOrCreateNode = createAction(comlinkNodeStore, ({state}) => {
-  return (options: NodeInput) => {
-    const nodes = state.get().nodes
-    const existing = nodes.get(options.name)
-
-    // limit nodes to one per name
-    if (existing) {
-      if (!isEqual(existing.options, options)) {
-        throw new Error(`Node "${options.name}" already exists with different options`)
-      }
-
-      state.set('incrementNodeRefCount', {
-        nodes: new Map(nodes).set(options.name, {
-          ...existing,
-          refCount: existing.refCount + 1,
-        }),
-      })
-
-      existing.node.start()
-      return existing.node
+export const getOrCreateNode = (
+  {state}: StoreContext<ComlinkNodeState>,
+  options: NodeInput,
+): Node<WindowMessage, FrameMessage> => {
+  const nodes = state.get().nodes
+  const existing = nodes.get(options.name)
+
+  // limit nodes to one per name
+  if (existing) {
+    if (!isEqual(existing.options, options)) {
+      throw new Error(`Node "${options.name}" already exists with different options`)
     }
 
-    const node: Node<WindowMessage, FrameMessage> = createNode(options)
-    node.start()
+    state.set('incrementNodeRefCount', {
+      nodes: new Map(nodes).set(options.name, {
+        ...existing,
+        refCount: existing.refCount + 1,
+      }),
+    })
 
-    nodes.set(options.name, {node, options, refCount: 1})
+    existing.node.start()
+    return existing.node
+  }
 
-    state.set('createNode', {nodes})
+  const node: Node<WindowMessage, FrameMessage> = createNode(options)
+  node.start()
 
-    return node
-  }
-})
+  nodes.set(options.name, {node, options, refCount: 1})
+
+  state.set('createNode', {nodes})
+
+  return node
+}

package/src/comlink/node/actions/releaseNode.test.ts

@@ -1,11 +1,10 @@
+import {type Node} 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 {comlinkNodeStore} from '../comlinkNodeStore'
-import {getOrCreateNode} from './getOrCreateNode'
+import {createSanityInstance, type SanityInstance} from '../../../store/createSanityInstance'
+import {createStoreState} from '../../../store/createStoreState'
+import {type FrameMessage, type WindowMessage} from '../../types'
+import {type ComlinkNodeState, type NodeEntry} from '../comlinkNodeStore'
 import {releaseNode} from './releaseNode'
 
 const nodeConfig = {
@@ -13,104 +12,125 @@ const nodeConfig = {
   connectTo: 'parent',
 }
 
-vi.mock('@sanity/comlink', () => ({
-  createNode: vi.fn(() => ({
-    start: vi.fn(),
-    stop: vi.fn(),
-  })),
-}))
-
 describe('releaseNode', () => {
   let instance: SanityInstance
+  let state: ReturnType<typeof createStoreState<ComlinkNodeState>>
+  let mockNode: Partial<Node<WindowMessage, FrameMessage>> & {
+    start: ReturnType<typeof vi.fn>
+    stop: ReturnType<typeof vi.fn>
+  }
 
   beforeEach(() => {
-    instance = createSanityInstance(config)
+    instance = createSanityInstance({
+      projectId: 'test-project-id',
+      dataset: 'test-dataset',
+    })
+    mockNode = {start: vi.fn(), stop: vi.fn()}
+    state = createStoreState<ComlinkNodeState>({nodes: new Map()})
     vi.clearAllMocks()
   })
 
+  afterEach(() => {
+    instance.dispose()
+  })
+
   it('should stop and remove node when released', () => {
-    const store = getOrCreateResource(instance, comlinkNodeStore)
-    // Create a node
-    const node = getOrCreateNode(instance, nodeConfig)
-    const stopSpy = vi.spyOn(node, 'stop')
+    // Set up a node in the state
+    const nodes = new Map()
+    nodes.set('test-node', {
+      node: mockNode as Node<WindowMessage, FrameMessage>,
+      options: nodeConfig,
+      refCount: 1,
+    })
+    state.set('setup', {nodes})
 
-    expect(store.state.get().nodes.has('test-node')).toBe(true)
+    expect(state.get().nodes.has('test-node')).toBe(true)
 
     // Release the node
-    releaseNode(instance, 'test-node')
+    releaseNode({state, instance}, 'test-node')
 
     // Check node is removed
-    expect(stopSpy).toHaveBeenCalled()
-    expect(store.state.get().nodes.has('test-node')).toBe(false)
+    expect(mockNode.stop).toHaveBeenCalled()
+    expect(state.get().nodes.has('test-node')).toBe(false)
   })
 
   it('should not stop the node if refCount is still above 0', () => {
     // Create a node twice to increment refCount
-    const node = getOrCreateNode(instance, nodeConfig)
-    getOrCreateNode(instance, nodeConfig)
-    const stopSpy = vi.spyOn(node, 'stop')
+    const nodes = new Map()
+    nodes.set('test-node', {
+      node: mockNode as Node<WindowMessage, FrameMessage>,
+      options: nodeConfig,
+      refCount: 2,
+    })
+    state.set('setup', {nodes})
 
     // Release once
-    releaseNode(instance, 'test-node')
+    releaseNode({state, instance}, 'test-node')
 
     // Node should not be stopped
-    expect(stopSpy).not.toHaveBeenCalled()
+    expect(mockNode.stop).not.toHaveBeenCalled()
 
     // Verify refCount is 1
-    const store = getOrCreateResource(instance, comlinkNodeStore)
-    const nodeEntry = store.state.get().nodes.get('test-node')
+    const nodeEntry = state.get().nodes.get('test-node') as NodeEntry
     expect(nodeEntry?.refCount).toBe(1)
   })
 
   it('should handle multiple releases gracefully', () => {
-    // Create a node
-    getOrCreateNode(instance, nodeConfig)
+    // Set up a node in the state
+    const nodes = new Map()
+    nodes.set('test-node', {
+      node: mockNode as Node<WindowMessage, FrameMessage>,
+      options: nodeConfig,
+      refCount: 1,
+    })
+    state.set('setup', {nodes})
 
     // Release multiple times
-    releaseNode(instance, 'test-node')
-    releaseNode(instance, 'test-node')
-    releaseNode(instance, 'test-node')
-
-    // Verify refCount doesn't go below 0
-    const store = getOrCreateResource(instance, comlinkNodeStore)
-    expect(store.state.get().nodes.has('test-node')).toBe(false)
+    releaseNode({state, instance}, 'test-node')
+    releaseNode({state, instance}, 'test-node')
+    releaseNode({state, instance}, 'test-node')
+
+    // Verify node is removed after first release
+    expect(state.get().nodes.has('test-node')).toBe(false)
+    // Stop should be called exactly once
+    expect(mockNode.stop).toHaveBeenCalledTimes(1)
   })
 
   it('should handle releasing non-existent nodes', () => {
     // Should not throw when releasing non-existent node
-    expect(() => releaseNode(instance, 'non-existent')).not.toThrow()
+    expect(() => releaseNode({state, instance}, 'non-existent')).not.toThrow()
   })
 
   it('should maintain correct state after complex operations', () => {
-    // Create node multiple times
-    const node = getOrCreateNode(instance, nodeConfig)
-    getOrCreateNode(instance, nodeConfig)
-    getOrCreateNode(instance, nodeConfig)
-
-    const store = getOrCreateResource(instance, comlinkNodeStore)
-    let nodeEntry = store.state.get().nodes.get('test-node')
+    // Set up a node with refCount = 3
+    const nodes = new Map()
+    nodes.set('test-node', {
+      node: mockNode as Node<WindowMessage, FrameMessage>,
+      options: nodeConfig,
+      refCount: 3,
+    })
+    state.set('setup', {nodes})
 
     // Initial refCount should be 3
+    let nodeEntry = state.get().nodes.get('test-node') as NodeEntry
     expect(nodeEntry?.refCount).toBe(3)
 
     // Release twice
-    releaseNode(instance, 'test-node')
-    releaseNode(instance, 'test-node')
+    releaseNode({state, instance}, 'test-node')
+    releaseNode({state, instance}, 'test-node')
 
-    nodeEntry = store.state.get().nodes.get('test-node')
+    nodeEntry = state.get().nodes.get('test-node') as NodeEntry
     expect(nodeEntry?.refCount).toBe(1)
 
     // Verify node hasn't been stopped yet
-    const stopSpy = vi.spyOn(node, 'stop')
-    expect(stopSpy).not.toHaveBeenCalled()
+    expect(mockNode.stop).not.toHaveBeenCalled()
 
     // Release final reference
-    releaseNode(instance, 'test-node')
+    releaseNode({state, instance}, 'test-node')
 
     // Verify node was stopped
-    expect(stopSpy).toHaveBeenCalled()
+    expect(mockNode.stop).toHaveBeenCalled()
 
-    nodeEntry = store.state.get().nodes.get('test-node')
-    expect(store.state.get().nodes.has('test-node')).toBe(false)
+    expect(state.get().nodes.has('test-node')).toBe(false)
   })
 })

package/src/comlink/node/actions/releaseNode.ts

@@ -1,30 +1,28 @@
-import {createAction} from '../../../resources/createAction'
-import {comlinkNodeStore} from '../comlinkNodeStore'
+import {type StoreContext} from '../../../store/defineStore'
+import {type ComlinkNodeState} from '../comlinkNodeStore'
 
 /**
  * Signals to the store that the consumer has stopped using the node
  * @public
  */
-export const releaseNode = createAction(comlinkNodeStore, ({state}) => {
-  return (name: string) => {
-    const nodes = state.get().nodes
-    const nodeEntry = nodes.get(name)
+export const releaseNode = ({state}: StoreContext<ComlinkNodeState>, name: string): void => {
+  const nodes = state.get().nodes
+  const nodeEntry = nodes.get(name)
 
-    if (nodeEntry) {
-      const newRefCount = nodeEntry.refCount === 0 ? 0 : nodeEntry.refCount - 1
+  if (nodeEntry) {
+    const newRefCount = nodeEntry.refCount === 0 ? 0 : nodeEntry.refCount - 1
 
-      if (newRefCount === 0) {
-        nodeEntry.node.stop()
-        nodes.delete(name)
-        state.set('releaseNode', {nodes: new Map(nodes)})
-      } else {
-        state.set('releaseNode', {
-          nodes: new Map(nodes).set(name, {
-            ...nodeEntry,
-            refCount: newRefCount,
-          }),
-        })
-      }
+    if (newRefCount === 0) {
+      nodeEntry.node.stop()
+      nodes.delete(name)
+      state.set('releaseNode', {nodes: new Map(nodes)})
+    } else {
+      state.set('releaseNode', {
+        nodes: new Map(nodes).set(name, {
+          ...nodeEntry,
+          refCount: newRefCount,
+        }),
+      })
     }
   }
-})
+}

package/src/comlink/node/comlinkNodeStore.test.ts

@@ -1,10 +1,8 @@
 import {type Node} from '@sanity/comlink'
 import {beforeEach, describe, expect, it} from 'vitest'
 
-import {config} from '../../../test/fixtures'
-import {createSanityInstance} from '../../instance/sanityInstance'
-import {type SanityInstance} from '../../instance/types'
-import {createResourceState} from '../../resources/createResource'
+import {createSanityInstance, type SanityInstance} from '../../store/createSanityInstance'
+import {createStoreState} from '../../store/createStoreState'
 import {type FrameMessage, type WindowMessage} from '../types'
 import {comlinkNodeStore} from './comlinkNodeStore'
 
@@ -12,7 +10,7 @@ describe('nodeStore', () => {
   let instance: SanityInstance
 
   beforeEach(() => {
-    instance = createSanityInstance(config)
+    instance = createSanityInstance({projectId: 'test-project-id', dataset: 'test-dataset'})
   })
 
   it('should have correct initial state', () => {
@@ -34,13 +32,10 @@ describe('nodeStore', () => {
       refCount: 1,
     })
 
-    const cleanup = comlinkNodeStore.initialize!.call(
-      {
-        instance,
-        state: createResourceState(initialState),
-      },
+    const cleanup = comlinkNodeStore.initialize?.({
       instance,
-    )
+      state: createStoreState(initialState),
+    })
 
     cleanup?.()
     expect(mockNode.stop).toHaveBeenCalled()

package/src/comlink/node/comlinkNodeStore.ts

@@ -1,7 +1,10 @@
 import {type Node, type NodeInput} from '@sanity/comlink'
 
-import {createResource} from '../../resources/createResource'
+import {bindActionGlobally} from '../../store/createActionBinder'
+import {defineStore} from '../../store/defineStore'
 import {type FrameMessage, type WindowMessage} from '../types'
+import {getOrCreateNode as unboundGetOrCreateNode} from './actions/getOrCreateNode'
+import {releaseNode as unboundReleaseNode} from './actions/releaseNode'
 
 /**
  * Individual node with its relevant options
@@ -23,17 +26,31 @@ export interface ComlinkNodeState {
   nodes: Map<string, NodeEntry>
 }
 
-export const comlinkNodeStore = createResource<ComlinkNodeState>({
+export const comlinkNodeStore = defineStore<ComlinkNodeState>({
   name: 'nodeStore',
   getInitialState: () => ({
     nodes: new Map(),
   }),
-  initialize() {
+
+  initialize({state}) {
     return () => {
-      const state = this.state.get()
-      state.nodes.forEach(({node}) => {
+      state.get().nodes.forEach(({node}) => {
         node.stop()
       })
     }
   },
 })
+
+/**
+ * Signals to the store that the consumer has stopped using the node
+ * @public
+ */
+export const releaseNode = bindActionGlobally(comlinkNodeStore, unboundReleaseNode)
+
+/**
+ * Retrieve or create a node to be used for communication between
+ * an application and the controller -- specifically, a node should
+ * be created within a frame / window to communicate with the controller.
+ * @public
+ */
+export const getOrCreateNode = bindActionGlobally(comlinkNodeStore, unboundGetOrCreateNode)

package/src/config/authConfig.ts

@@ -0,0 +1,79 @@
+import {type ClientConfig, type SanityClient} from '@sanity/client'
+
+/**
+ * Configuration for an authentication provider
+ * @public
+ */
+export interface AuthProvider {
+  /**
+   * Unique identifier for the auth provider (e.g., 'google', 'github')
+   */
+  name: string
+
+  /**
+   * Display name for the auth provider in the UI
+   */
+  title: string
+
+  /**
+   * Complete authentication URL including callback and token parameters
+   */
+  url: string
+
+  /**
+   * Optional URL for direct sign-up flow
+   */
+  signUpUrl?: string
+}
+
+/**
+ * Configuration options for creating an auth store.
+ *
+ * @public
+ */
+export interface AuthConfig {
+  /**
+   * The initial location href to use when handling auth callbacks.
+   * Defaults to the current window location if available.
+   */
+  initialLocationHref?: string
+
+  /**
+   * Factory function to create a SanityClient instance.
+   * Defaults to the standard Sanity client factory if not provided.
+   */
+  clientFactory?: (config: ClientConfig) => SanityClient
+
+  /**
+   * Custom authentication providers to use instead of or in addition to the default ones.
+   * Can be an array of providers or a function that takes the default providers and returns
+   * a modified array or a Promise resolving to one.
+   */
+  providers?: AuthProvider[] | ((prev: AuthProvider[]) => AuthProvider[] | Promise<AuthProvider[]>)
+
+  /**
+   * The API hostname for requests. Usually leave this undefined, but it can be set
+   * if using a custom domain or CNAME for the API endpoint.
+   */
+  apiHost?: string
+
+  /**
+   * Storage implementation to persist authentication state.
+   * Defaults to `localStorage` if available.
+   */
+  storageArea?: Storage
+
+  /**
+   * A callback URL for your application.
+   * If none is provided, the auth API will redirect back to the current location (`location.href`).
+   * When handling callbacks, this URL's pathname is checked to ensure it matches the callback.
+   */
+  callbackUrl?: string
+
+  /**
+   * A static authentication token to use instead of handling the OAuth flow.
+   * When provided, the auth store will remain in a logged-in state with this token,
+   * ignoring any storage or callback handling.
+   */
+  token?: string
+}