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

package/src/config/sanityConfig.ts

@@ -0,0 +1,48 @@
+import {type SanityDocumentLike} from '@sanity/types'
+
+import {type AuthConfig} from './authConfig'
+
+/**
+ * @public
+ */
+export interface ProjectHandle {
+  projectId?: string | undefined
+}
+
+/**
+ * @public
+ */
+export interface DatasetHandle extends ProjectHandle {
+  dataset?: string | undefined
+}
+
+/** @public */
+export interface DocumentTypeHandle<TDocument extends SanityDocumentLike = SanityDocumentLike>
+  extends DatasetHandle {
+  documentId?: string
+  documentType: TDocument['_type']
+}
+
+/**
+ * @public
+ * A minimal set of metadata for a given document, comprising the document's ID and type.
+ * Used by most document-related hooks (such as {@link usePreview}, {@link useDocument}, and {@link useEditDocument})
+ * to reference a particular document without fetching the entire document upfront.
+ * @category Types
+ */
+export interface DocumentHandle<TDocument extends SanityDocumentLike = SanityDocumentLike>
+  extends DocumentTypeHandle<TDocument> {
+  documentId: string
+}
+
+/**
+ * Represents the complete configuration for a Sanity SDK instance
+ * @public
+ */
+export interface SanityConfig extends DatasetHandle {
+  /**
+   * Authentication configuration for the instance
+   * @remarks Merged with parent configurations when using createChild
+   */
+  auth?: AuthConfig
+}

package/src/datasets/datasets.test.ts

@@ -3,8 +3,8 @@ import {of} from 'rxjs'
 import {describe, it} from 'vitest'
 
 import {getClientState} from '../client/clientStore'
-import {createSanityInstance} from '../instance/sanityInstance'
-import {type StateSource} from '../resources/createStateSourceAction'
+import {createSanityInstance} from '../store/createSanityInstance'
+import {type StateSource} from '../store/createStateSourceAction'
 import {resolveDatasets} from './datasets'
 
 vi.mock('../client/clientStore')

package/src/datasets/datasets.ts

@@ -1,16 +1,29 @@
 import {switchMap} from 'rxjs'
 
 import {getClientState} from '../client/clientStore'
+import {type ProjectHandle} from '../config/sanityConfig'
 import {createFetcherStore} from '../utils/createFetcherStore'
 
+const API_VERSION = 'v2025-02-19'
+
 /** @public */
 export const datasets = createFetcherStore({
   name: 'Datasets',
-  getKey: () => 'datasets',
-  fetcher: (instance) => () =>
-    getClientState(instance, {apiVersion: 'vX', scope: 'project'}).observable.pipe(
-      switchMap((client) => client.observable.datasets.list()),
-    ),
+  getKey: (instance, options?: ProjectHandle) => {
+    const projectId = options?.projectId ?? instance.config.projectId
+    if (!projectId) {
+      throw new Error('A projectId is required to use the project API.')
+    }
+    return projectId
+  },
+  fetcher: (instance) => (options?: ProjectHandle) => {
+    return getClientState(instance, {
+      apiVersion: API_VERSION,
+      // non-null assertion is fine because we check above
+      projectId: (options?.projectId ?? instance.config.projectId)!,
+      useProjectHostname: true,
+    }).observable.pipe(switchMap((client) => client.observable.datasets.list()))
+  },
 })
 
 /** @public */

package/src/document/actions.test.ts

@@ -2,6 +2,7 @@ import {at, patch, set, setIfMissing} from '@sanity/mutate'
 import {type PatchOperations} from '@sanity/types'
 import {describe, expect, it} from 'vitest'
 
+import {type DocumentHandle} from '../config/sanityConfig'
 import {
   createDocument,
   deleteDocument,
@@ -10,14 +11,13 @@ import {
   publishDocument,
   unpublishDocument,
 } from '../document/actions'
-import {type DocumentHandle} from './patchOperations'
 
 const dummyPatch: PatchOperations = {
   diffMatchPatch: {'dummy.path': 'dummy patch'},
 }
 
-const dummyDocHandle: DocumentHandle = {_id: 'drafts.abc123', _type: 'testType'}
-const dummyDocString = {_id: 'drafts.abc123', _type: 'testType'}
+const dummyDocHandle: DocumentHandle = {documentId: 'drafts.abc123', documentType: 'testType'}
+const dummyDocString = {documentId: 'drafts.abc123', documentType: 'testType'}
 
 describe('document actions', () => {
   describe('createDocument', () => {
@@ -26,20 +26,20 @@ describe('document actions', () => {
       expect(action).toEqual({
         type: 'document.create',
         // getId returns the input if it does not end with a dot.
-        documentId: dummyDocHandle._id,
-        documentType: dummyDocHandle._type,
+        documentId: 'abc123',
+        documentType: dummyDocHandle.documentType,
       })
     })
 
     it('creates a document action from a document type handle', () => {
       // A document type handle is similar to a document handle,
       // but _id is optional.
-      const typeHandle = {_id: 'abc456', _type: 'anotherType'}
+      const typeHandle = {documentId: 'abc456', documentType: 'anotherType'}
       const action = createDocument(typeHandle)
       expect(action).toEqual({
         type: 'document.create',
-        documentId: typeHandle._id,
-        documentType: typeHandle._type,
+        documentId: 'abc456',
+        documentType: typeHandle.documentType,
       })
     })
   })
@@ -51,6 +51,7 @@ describe('document actions', () => {
       expect(action).toEqual({
         type: 'document.delete',
         documentId: 'abc123',
+        documentType: dummyDocString.documentType,
       })
     })
 
@@ -59,6 +60,7 @@ describe('document actions', () => {
       expect(action).toEqual({
         type: 'document.delete',
         documentId: 'abc123',
+        documentType: dummyDocHandle.documentType,
       })
     })
   })
@@ -69,6 +71,7 @@ describe('document actions', () => {
       expect(action).toEqual({
         type: 'document.edit',
         documentId: 'abc123',
+        documentType: dummyDocString.documentType,
         patches: [dummyPatch],
       })
     })
@@ -78,14 +81,16 @@ describe('document actions', () => {
       expect(action).toEqual({
         type: 'document.edit',
         documentId: 'abc123',
+        documentType: dummyDocHandle.documentType,
         patches: [dummyPatch],
       })
     })
 
     it('allows @sanity/mutate-style patches', () => {
       const action = editDocument(
+        dummyDocHandle,
         patch(
-          dummyDocString._id,
+          dummyDocHandle.documentId,
           [
             at('published', set(true)),
             at('address', setIfMissing({_type: 'address'})),
@@ -96,7 +101,8 @@ describe('document actions', () => {
       )
 
       expect(action).toEqual({
-        documentId: 'drafts.abc123',
+        documentId: 'abc123',
+        documentType: 'testType',
         patches: [
           {ifRevisionID: 'txn0', set: {published: true}},
           {ifRevisionID: 'txn0', setIfMissing: {address: {_type: 'address'}}},
@@ -113,6 +119,7 @@ describe('document actions', () => {
       expect(action).toEqual({
         type: 'document.publish',
         documentId: 'abc123',
+        documentType: dummyDocString.documentType,
       })
     })
 
@@ -121,6 +128,7 @@ describe('document actions', () => {
       expect(action).toEqual({
         type: 'document.publish',
         documentId: 'abc123',
+        documentType: dummyDocHandle.documentType,
       })
     })
   })
@@ -131,6 +139,7 @@ describe('document actions', () => {
       expect(action).toEqual({
         type: 'document.unpublish',
         documentId: 'abc123',
+        documentType: dummyDocString.documentType,
       })
     })
 
@@ -139,6 +148,7 @@ describe('document actions', () => {
       expect(action).toEqual({
         type: 'document.unpublish',
         documentId: 'abc123',
+        documentType: dummyDocHandle.documentType,
       })
     })
   })
@@ -149,6 +159,7 @@ describe('document actions', () => {
       expect(action).toEqual({
         type: 'document.discard',
         documentId: 'abc123',
+        documentType: dummyDocString.documentType,
       })
     })
 
@@ -157,6 +168,7 @@ describe('document actions', () => {
       expect(action).toEqual({
         type: 'document.discard',
         documentId: 'abc123',
+        documentType: dummyDocHandle.documentType,
       })
     })
   })

package/src/document/actions.ts

@@ -2,12 +2,8 @@ import {SanityEncoder} from '@sanity/mutate'
 import {type PatchMutation as SanityMutatePatchMutation} from '@sanity/mutate/_unstable_store'
 import {type PatchMutation, type PatchOperations, type SanityDocumentLike} from '@sanity/types'
 
+import {type DocumentHandle, type DocumentTypeHandle} from '../config/sanityConfig'
 import {getPublishedId} from '../utils/ids'
-import {
-  type DocumentHandle,
-  type DocumentResourceId,
-  type DocumentTypeHandle,
-} from './patchOperations'
 
 const isSanityMutatePatch = (value: unknown): value is SanityMutatePatchMutation => {
   if (typeof value !== 'object' || !value) return false
@@ -18,51 +14,40 @@ const isSanityMutatePatch = (value: unknown): value is SanityMutatePatchMutation
 }
 
 /** @beta */
-export interface CreateDocumentAction<TDocument extends SanityDocumentLike = SanityDocumentLike> {
+export interface CreateDocumentAction<TDocument extends SanityDocumentLike = SanityDocumentLike>
+  extends DocumentTypeHandle<TDocument> {
   type: 'document.create'
-  documentId?: string
-  resourceId?: DocumentResourceId
-  documentType: TDocument['_type']
 }
 
-// the unused `_TDocument` is primarily for typescript meta-programming to
-// capture and preserve the document type as best as possible
 /** @beta */
-export interface DeleteDocumentAction<_TDocument extends SanityDocumentLike = SanityDocumentLike> {
+export interface DeleteDocumentAction<TDocument extends SanityDocumentLike = SanityDocumentLike>
+  extends DocumentHandle<TDocument> {
   type: 'document.delete'
-  documentId: string
-  resourceId?: DocumentResourceId
 }
 
 /** @beta */
-export interface EditDocumentAction<_TDocument extends SanityDocumentLike = SanityDocumentLike> {
+export interface EditDocumentAction<TDocument extends SanityDocumentLike = SanityDocumentLike>
+  extends DocumentHandle<TDocument> {
   type: 'document.edit'
-  documentId: string
-  resourceId?: DocumentResourceId
   patches?: PatchOperations[]
 }
 
 /** @beta */
-export interface PublishDocumentAction<_TDocument extends SanityDocumentLike = SanityDocumentLike> {
+export interface PublishDocumentAction<TDocument extends SanityDocumentLike = SanityDocumentLike>
+  extends DocumentHandle<TDocument> {
   type: 'document.publish'
-  documentId: string
-  resourceId?: DocumentResourceId
 }
 
 /** @beta */
-export interface UnpublishDocumentAction<
-  _TDocument extends SanityDocumentLike = SanityDocumentLike,
-> {
+export interface UnpublishDocumentAction<TDocument extends SanityDocumentLike = SanityDocumentLike>
+  extends DocumentHandle<TDocument> {
   type: 'document.unpublish'
-  documentId: string
-  resourceId?: DocumentResourceId
 }
 
 /** @beta */
-export interface DiscardDocumentAction<_TDocument extends SanityDocumentLike = SanityDocumentLike> {
+export interface DiscardDocumentAction<TDocument extends SanityDocumentLike = SanityDocumentLike>
+  extends DocumentHandle<TDocument> {
   type: 'document.discard'
-  documentId: string
-  resourceId?: DocumentResourceId
 }
 
 /** @beta */
@@ -76,13 +61,12 @@ export type DocumentAction<TDocument extends SanityDocumentLike = SanityDocument
 
 /** @beta */
 export function createDocument<TDocument extends SanityDocumentLike>(
-  doc: DocumentTypeHandle<TDocument> | DocumentHandle<TDocument>,
+  doc: DocumentTypeHandle<TDocument>,
 ): CreateDocumentAction<TDocument> {
   return {
     type: 'document.create',
-    ...(doc._id && {documentId: doc._id}),
-    documentType: doc._type,
-    ...(doc.resourceId && {resourceId: doc.resourceId}),
+    ...doc,
+    ...(doc.documentId && {documentId: getPublishedId(doc.documentId)}),
   }
 }
 
@@ -92,29 +76,25 @@ export function deleteDocument<TDocument extends SanityDocumentLike>(
 ): DeleteDocumentAction<TDocument> {
   return {
     type: 'document.delete',
-    documentId: getPublishedId(doc._id),
-    ...(doc.resourceId && {resourceId: doc.resourceId}),
+    ...doc,
+    documentId: getPublishedId(doc.documentId),
   }
 }
 
 function convertSanityMutatePatch(
   sanityPatchMutation: SanityMutatePatchMutation,
-): EditDocumentAction {
+): EditDocumentAction['patches'] {
   const encoded = SanityEncoder.encode(sanityPatchMutation) as PatchMutation[]
-
-  return {
-    documentId: sanityPatchMutation.id,
-    type: 'document.edit',
-    patches: encoded.map((i) => {
-      const copy: PatchOperations = {...i.patch}
-      if ('id' in copy) delete copy.id
-      return copy
-    }),
-  }
+  return encoded.map((i) => {
+    const copy: PatchOperations = {...i.patch}
+    if ('id' in copy) delete copy.id
+    return copy
+  })
 }
 
 /** @beta */
 export function editDocument<TDocument extends SanityDocumentLike>(
+  doc: DocumentHandle<TDocument>,
   sanityMutatePatch: SanityMutatePatchMutation,
 ): EditDocumentAction<TDocument>
 /** @beta */
@@ -124,16 +104,24 @@ export function editDocument<TDocument extends SanityDocumentLike>(
 ): EditDocumentAction<TDocument>
 /** @beta */
 export function editDocument<TDocument extends SanityDocumentLike>(
-  doc: SanityMutatePatchMutation | DocumentHandle<TDocument>,
-  patches?: PatchOperations | PatchOperations[],
+  doc: DocumentHandle<TDocument>,
+  patches?: PatchOperations | PatchOperations[] | SanityMutatePatchMutation,
 ): EditDocumentAction<TDocument> {
-  if (isSanityMutatePatch(doc)) return convertSanityMutatePatch(doc)
+  if (isSanityMutatePatch(patches)) {
+    const converted = convertSanityMutatePatch(patches) ?? []
+    return {
+      ...doc,
+      type: 'document.edit',
+      documentId: getPublishedId(doc.documentId),
+      patches: converted,
+    }
+  }
 
   return {
+    ...doc,
     type: 'document.edit',
-    documentId: getPublishedId(doc._id),
+    documentId: getPublishedId(doc.documentId),
     ...(patches && {patches: Array.isArray(patches) ? patches : [patches]}),
-    ...(doc.resourceId && {resourceId: doc.resourceId}),
   }
 }
 
@@ -143,8 +131,8 @@ export function publishDocument<TDocument extends SanityDocumentLike>(
 ): PublishDocumentAction<TDocument> {
   return {
     type: 'document.publish',
-    documentId: getPublishedId(doc._id),
-    ...(doc.resourceId && {resourceId: doc.resourceId}),
+    ...doc,
+    documentId: getPublishedId(doc.documentId),
   }
 }
 
@@ -154,8 +142,8 @@ export function unpublishDocument<TDocument extends SanityDocumentLike>(
 ): UnpublishDocumentAction<TDocument> {
   return {
     type: 'document.unpublish',
-    documentId: getPublishedId(doc._id),
-    ...(doc.resourceId && {resourceId: doc.resourceId}),
+    ...doc,
+    documentId: getPublishedId(doc.documentId),
   }
 }
 
@@ -165,7 +153,7 @@ export function discardDocument<TDocument extends SanityDocumentLike>(
 ): DiscardDocumentAction<TDocument> {
   return {
     type: 'document.discard',
-    documentId: getPublishedId(doc._id),
-    ...(doc.resourceId && {resourceId: doc.resourceId}),
+    ...doc,
+    documentId: getPublishedId(doc.documentId),
   }
 }

package/src/document/applyDocumentActions.test.ts

@@ -3,15 +3,20 @@ import {type SanityDocument} from '@sanity/types'
 import {Subject} from 'rxjs'
 import {describe, expect, it} from 'vitest'
 
-import {createSanityInstance} from '../instance/sanityInstance'
-import {type ActionContext} from '../resources/createAction'
-import {createResourceState} from '../resources/createResource'
+import {bindActionByDataset} from '../store/createActionBinder'
+import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
+import {} from '../store/createStateSourceAction'
+import {createStoreState, type StoreState} from '../store/createStoreState'
 import {type DocumentAction} from './actions'
-import {applyDocumentActions} from './applyDocumentActions'
 import {type DocumentStoreState} from './documentStore'
 import {type DocumentEvent} from './events'
 import {type AppliedTransaction, type OutgoingTransaction} from './reducers'
 
+vi.mock('../store/createActionBinder', async (importOriginal) => ({
+  ...(await importOriginal<typeof import('../store/createActionBinder')>()),
+  bindActionByDataset: vi.fn(),
+}))
+
 type TestState = Pick<
   DocumentStoreState,
   'documentStates' | 'queued' | 'applied' | 'outgoing' | 'error' | 'events'
@@ -26,8 +31,13 @@ const exampleDoc: SanityDocument = {
 }
 
 describe('applyDocumentActions', () => {
-  it('resolves with a successful applied transaction and accepted event', async () => {
-    const eventsSubject = new Subject<DocumentEvent>()
+  let state: StoreState<TestState>
+  let instance: SanityInstance
+  let eventsSubject: Subject<DocumentEvent>
+  let applyDocumentActions: typeof import('./applyDocumentActions').applyDocumentActions
+
+  beforeEach(async () => {
+    eventsSubject = new Subject<DocumentEvent>()
     const initialState: TestState = {
       documentStates: {},
       queued: [],
@@ -36,24 +46,35 @@ describe('applyDocumentActions', () => {
       error: undefined,
       events: eventsSubject,
     }
-    const state = createResourceState(initialState)
-    const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
-    const context: ActionContext<TestState> = {instance, state}
+    state = createStoreState(initialState)
+    instance = createSanityInstance({projectId: 'p', dataset: 'd'})
+
+    vi.mocked(bindActionByDataset).mockImplementation(
+      (_storeDef, action) =>
+        (instanceParam: SanityInstance, ...params: unknown[]) =>
+          action({instance: instanceParam, state}, ...params),
+    )
+    // Import dynamically to ensure mocks are set up before the module under test is loaded
+    const module = await import('./applyDocumentActions')
+    applyDocumentActions = module.applyDocumentActions
+  })
+
+  afterEach(() => {
+    instance.dispose()
+  })
 
+  it('resolves with a successful applied transaction and accepted event', async () => {
     const action: DocumentAction = {
       type: 'document.edit',
       documentId: 'doc1',
+      documentType: 'example',
       patches: [{set: {foo: 'bar'}}],
     }
 
     // Call applyDocumentActions with a fixed transactionId for reproducibility.
-    const applyPromise = applyDocumentActions(
-      context as ActionContext<DocumentStoreState>,
-      action,
-      {
-        transactionId: 'txn-success',
-      },
-    )
+    const applyPromise = applyDocumentActions(instance, action, {
+      transactionId: 'txn-success',
+    })
 
     const appliedTx: AppliedTransaction = {
       transactionId: 'txn-success',
@@ -99,33 +120,17 @@ describe('applyDocumentActions', () => {
   })
 
   it('throws an error if a transaction error event is emitted', async () => {
-    const eventsSubject = new Subject<DocumentEvent>()
-    const initialState: TestState = {
-      documentStates: {},
-      queued: [],
-      applied: [],
-      outgoing: undefined,
-      error: undefined,
-      events: eventsSubject,
-    }
-    const state = createResourceState(initialState)
-    const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
-    const context: ActionContext<TestState> = {instance, state}
-
     const action: DocumentAction = {
       type: 'document.edit',
       documentId: 'doc1',
+      documentType: 'example',
       patches: [{set: {foo: 'error'}}],
     }
 
     // Call applyDocumentActions with a fixed transactionId.
-    const applyPromise = applyDocumentActions(
-      context as ActionContext<DocumentStoreState>,
-      action,
-      {
-        transactionId: 'txn-error',
-      },
-    )
+    const applyPromise = applyDocumentActions(instance, action, {
+      transactionId: 'txn-error',
+    })
 
     const errorEvent: DocumentEvent = {
       type: 'error',
@@ -138,4 +143,59 @@ describe('applyDocumentActions', () => {
 
     await expect(applyPromise).rejects.toThrow('Simulated error')
   })
+
+  it('matches parent instance via child when action projectId and dataset do not match child config', async () => {
+    // Create a parent instance
+    const parentInstance = createSanityInstance({projectId: 'p', dataset: 'd'})
+    // Create a child instance with different config
+    const childInstance = parentInstance.createChild({projectId: 'child-p', dataset: 'child-d'})
+    // Use the child instance in context
+    // Create an action that refers to the parent's configuration
+    const action: DocumentAction = {
+      type: 'document.edit',
+      documentId: 'doc1',
+      documentType: 'example',
+      patches: [{set: {foo: 'childTest'}}],
+      projectId: 'p',
+      dataset: 'd',
+    }
+    // Call applyDocumentActions with the context using childInstance, but with action requiring parent's config
+    const applyPromise = applyDocumentActions(childInstance, action, {
+      transactionId: 'txn-child-match',
+    })
+
+    // Simulate an applied transaction on the parent's instance
+    const appliedTx: AppliedTransaction = {
+      transactionId: 'txn-child-match',
+      actions: [action],
+      disableBatching: false,
+      outgoingActions: [],
+      outgoingMutations: [],
+      base: {doc1: {...exampleDoc, _id: 'doc1', foo: 'old', _rev: 'rev-old'}},
+      working: {doc1: {...exampleDoc, _id: 'doc1', foo: 'childTest', _rev: 'rev-new'}},
+      previous: {doc1: {...exampleDoc, _id: 'doc1', foo: 'old', _rev: 'rev-old'}},
+      previousRevs: {doc1: 'rev-old'},
+      timestamp: new Date().toISOString(),
+    }
+    state.set('simulateApplied', {applied: [appliedTx]})
+
+    const result = await applyPromise
+    expect(result.transactionId).toEqual('txn-child-match')
+    expect(result.documents).toEqual(appliedTx.working)
+    expect(result.previous).toEqual(appliedTx.previous)
+    expect(result.previousRevs).toEqual(appliedTx.previousRevs)
+
+    const acceptedResult = {transactionId: 'accepted-child'}
+    const acceptedEvent: DocumentEvent = {
+      type: 'accepted',
+      outgoing: {batchedTransactionIds: ['txn-child-match']} as OutgoingTransaction,
+      result: acceptedResult,
+    }
+    eventsSubject.next(acceptedEvent)
+    const submittedResult = await result.submitted()
+    expect(submittedResult).toEqual(acceptedResult)
+
+    childInstance.dispose()
+    parentInstance.dispose()
+  })
 })