@sanity/sdk 3.0.0-rc.0 → 3.0.0-rc.2

package/src/releases/utils/sortReleases.ts

@@ -1,4 +1,4 @@
-import {type ReleaseDocument} from '../releasesStore'
+import {type ReleaseDocument} from '@sanity/client'
 
 // mirrors the order of the releases in the releases list in Studio
 // https://github.com/sanity-io/sanity/blob/main/packages/sanity/src/core/releases/hooks/utils.ts
@@ -6,25 +6,30 @@ export function sortReleases(releases: ReleaseDocument[] = []): ReleaseDocument[
   // The order should always be:
   // [undecided (sortByCreatedAt), scheduled(sortBy publishAt || metadata.intendedPublishAt), asap(sortByCreatedAt)]
   return [...releases].sort((a, b) => {
+    // metadata is optional on a release document; guard against releases that
+    // have no metadata at all so sorting can't throw and wipe out the list.
+    const aType = a.metadata?.releaseType
+    const bType = b.metadata?.releaseType
+
     // undecided are always first, then by createdAt descending
-    if (a.metadata.releaseType === 'undecided' && b.metadata.releaseType !== 'undecided') {
+    if (aType === 'undecided' && bType !== 'undecided') {
       return -1
     }
-    if (a.metadata.releaseType !== 'undecided' && b.metadata.releaseType === 'undecided') {
+    if (aType !== 'undecided' && bType === 'undecided') {
       return 1
     }
-    if (a.metadata.releaseType === 'undecided' && b.metadata.releaseType === 'undecided') {
+    if (aType === 'undecided' && bType === 'undecided') {
       // Sort by createdAt
       return new Date(b._createdAt).getTime() - new Date(a._createdAt).getTime()
     }
 
     // Scheduled are always at the middle, then by publishAt descending
-    if (a.metadata.releaseType === 'scheduled' && b.metadata.releaseType === 'scheduled') {
-      const aPublishAt = a['publishAt'] || a.metadata['intendedPublishAt']
+    if (aType === 'scheduled' && bType === 'scheduled') {
+      const aPublishAt = a['publishAt'] || a.metadata?.['intendedPublishAt']
       if (!aPublishAt) {
         return 1
       }
-      const bPublishAt = b['publishAt'] || b.metadata['intendedPublishAt']
+      const bPublishAt = b['publishAt'] || b.metadata?.['intendedPublishAt']
       if (!bPublishAt) {
         return -1
       }
@@ -32,13 +37,13 @@ export function sortReleases(releases: ReleaseDocument[] = []): ReleaseDocument[
     }
 
     // ASAP are always last, then by createdAt descending
-    if (a.metadata.releaseType === 'asap' && b.metadata.releaseType !== 'asap') {
+    if (aType === 'asap' && bType !== 'asap') {
       return 1
     }
-    if (a.metadata.releaseType !== 'asap' && b.metadata.releaseType === 'asap') {
+    if (aType !== 'asap' && bType === 'asap') {
       return -1
     }
-    if (a.metadata.releaseType === 'asap' && b.metadata.releaseType === 'asap') {
+    if (aType === 'asap' && bType === 'asap') {
       // Sort by createdAt
       return new Date(b._createdAt).getTime() - new Date(a._createdAt).getTime()
     }

package/src/store/createActionBinder.test.ts

@@ -29,7 +29,7 @@ describe('createActionBinder', () => {
       return context.state.counter
     })
     const boundAction = binder(storeDefinition, action)
-    const instance = createSanityInstance()
+    const instance = createSanityInstance({projectId: 'proj1', dataset: 'ds1'})
 
     // First call creates store instance
     const result1 = boundAction(instance, 5)
@@ -43,9 +43,9 @@ describe('createActionBinder', () => {
   })
 
   it('should create separate store instances for different composite keys', () => {
-    const binder = createActionBinder((instance, ..._rest) => {
-      return {name: instance.instanceId}
-    })
+    const binder = createActionBinder(({config: {projectId, dataset}}, ..._rest) => ({
+      name: `${projectId}.${dataset}`,
+    }))
     const storeDefinition = {
       name: 'TestStore',
       getInitialState: () => ({counter: 0}),
@@ -55,8 +55,8 @@ describe('createActionBinder', () => {
       return context.state.counter
     })
     const boundAction = binder(storeDefinition, action)
-    const instanceA = createSanityInstance()
-    const instanceB = createSanityInstance()
+    const instanceA = createSanityInstance({projectId: 'p1', dataset: 'd1'})
+    const instanceB = createSanityInstance({projectId: 'p2', dataset: 'd2'})
 
     const resultA = boundAction(instanceA, 3)
     const resultB = boundAction(instanceB, 4)
@@ -74,8 +74,8 @@ describe('createActionBinder', () => {
     }
     const action = vi.fn((context) => context.state.counter)
     const boundAction = binder(storeDefinition, action)
-    const instance1 = createSanityInstance()
-    const instance2 = createSanityInstance()
+    const instance1 = createSanityInstance({projectId: 'p1', dataset: 'd1'})
+    const instance2 = createSanityInstance({projectId: 'p1', dataset: 'd1'})
 
     // Call action on both instances
     boundAction(instance1)
@@ -105,8 +105,8 @@ describe('bindActionGlobally', () => {
     const boundAction = bindActionGlobally(storeDefinition, action)
 
     // Create instances with different configs
-    const instance1 = createSanityInstance()
-    const instance2 = createSanityInstance()
+    const instance1 = createSanityInstance({projectId: 'any', dataset: 'any'})
+    const instance2 = createSanityInstance({projectId: 'different', dataset: 'config'})
 
     // Both instances should use the same store
     const result1 = boundAction(instance1, 42)
@@ -133,47 +133,42 @@ describe('bindActionGlobally', () => {
 })
 
 describe('bindActionByResource', () => {
-  it('should resolve from config.defaultResource when no resource provided', () => {
+  it('should throw an error when provided an invalid resource', () => {
     const storeDefinition = {
-      name: 'ResourceNamedStore',
+      name: 'SourceStore',
       getInitialState: () => ({counter: 0}),
     }
-    const action = vi.fn((context) => context.key)
+    const action = vi.fn((_context) => 'success')
     const boundAction = bindActionByResource(storeDefinition, action)
-    const instance = createSanityInstance({
-      defaultResource: {projectId: 'named-proj', dataset: 'named-ds'},
-    })
-    const result = boundAction(instance, {})
-    expect(result).toEqual(
-      expect.objectContaining({
-        name: 'named-proj.named-ds',
-        resource: {projectId: 'named-proj', dataset: 'named-ds'},
-      }),
-    )
+    const instance = createSanityInstance({projectId: 'proj1', dataset: 'ds1'})
+
+    expect(() =>
+      boundAction(instance, {resource: {invalid: 'resource'} as unknown as DocumentResource}),
+    ).toThrow('Received invalid resource:')
   })
 
-  it('should throw an error when provided an invalid resource', () => {
+  it('should throw an error when no resource provided and projectId/dataset are missing', () => {
     const storeDefinition = {
-      name: 'ResourceStore',
+      name: 'SourceStore',
       getInitialState: () => ({counter: 0}),
     }
     const action = vi.fn((_context) => 'success')
     const boundAction = bindActionByResource(storeDefinition, action)
-    const instance = createSanityInstance()
+    const instance = createSanityInstance({projectId: '', dataset: ''})
 
-    expect(() =>
-      boundAction(instance, {resource: {invalid: 'resource'} as unknown as DocumentResource}),
-    ).toThrow('Received invalid resource:')
+    expect(() => boundAction(instance, {})).toThrow(
+      'This API requires a project ID and dataset configured.',
+    )
   })
 
   it('should work correctly with a valid dataset resource', () => {
     const storeDefinition = {
-      name: 'ResourceStore',
+      name: 'SourceStore',
       getInitialState: () => ({counter: 0}),
     }
     const action = vi.fn((_context) => 'success')
     const boundAction = bindActionByResource(storeDefinition, action)
-    const instance = createSanityInstance()
+    const instance = createSanityInstance({projectId: 'proj1', dataset: 'ds1'})
 
     const result = boundAction(instance, {
       resource: {projectId: 'proj2', dataset: 'ds2'},
@@ -182,6 +177,57 @@ describe('bindActionByResource', () => {
   })
 })
 
+describe('instance default resource', () => {
+  const storeDefinition = {
+    name: 'DefaultResourceStore',
+    getInitialState: () => ({counter: 0}),
+  }
+  const whichResource = bindActionByResource(storeDefinition, ({key}) => key)
+
+  it('uses config.resource when no resource is passed', () => {
+    const instance = createSanityInstance({resource: {projectId: 'p', dataset: 'd'}})
+    expect(whichResource(instance, {})).toMatchObject({
+      name: 'p.d',
+      resource: {projectId: 'p', dataset: 'd'},
+    })
+    instance.dispose()
+  })
+
+  it('supports a media library as the instance default', () => {
+    const instance = createSanityInstance({resource: {mediaLibraryId: 'ml-123'}})
+    expect(whichResource(instance, {})).toMatchObject({
+      name: 'media-library:ml-123',
+      resource: {mediaLibraryId: 'ml-123'},
+    })
+    instance.dispose()
+  })
+
+  it('supports a canvas as the instance default', () => {
+    const instance = createSanityInstance({resource: {canvasId: 'c-1'}})
+    expect(whichResource(instance, {})).toMatchObject({
+      name: 'canvas:c-1',
+      resource: {canvasId: 'c-1'},
+    })
+    instance.dispose()
+  })
+
+  it('lets a per-call resource override the instance default', () => {
+    const instance = createSanityInstance({resource: {mediaLibraryId: 'ml-123'}})
+    expect(whichResource(instance, {resource: {projectId: 'x', dataset: 'y'}})).toMatchObject({
+      resource: {projectId: 'x', dataset: 'y'},
+    })
+    instance.dispose()
+  })
+
+  it('still accepts the projectId/dataset shorthand', () => {
+    const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
+    expect(whichResource(instance, {})).toMatchObject({
+      resource: {projectId: 'p', dataset: 'd'},
+    })
+    instance.dispose()
+  })
+})
+
 describe('bindActionByResourceAndPerspective', () => {
   it('should throw an error when provided an invalid resource', () => {
     const storeDefinition = {
@@ -190,7 +236,7 @@ describe('bindActionByResourceAndPerspective', () => {
     }
     const action = vi.fn((_context) => 'success')
     const boundAction = bindActionByResourceAndPerspective(storeDefinition, action)
-    const instance = createSanityInstance()
+    const instance = createSanityInstance({projectId: 'proj1', dataset: 'ds1'})
 
     expect(() =>
       boundAction(instance, {
@@ -200,35 +246,34 @@ describe('bindActionByResourceAndPerspective', () => {
     ).toThrow('Received invalid resource:')
   })
 
-  it('should work correctly with a valid dataset resource and explicit perspective', () => {
+  it('should throw an error when no resource provided and projectId/dataset are missing', () => {
     const storeDefinition = {
       name: 'PerspectiveStore',
       getInitialState: () => ({counter: 0}),
     }
     const action = vi.fn((_context) => 'success')
     const boundAction = bindActionByResourceAndPerspective(storeDefinition, action)
-    const instance = createSanityInstance()
+    const instance = createSanityInstance({projectId: '', dataset: ''})
 
-    const result = boundAction(instance, {
-      resource: {projectId: 'proj2', dataset: 'ds2'},
-      perspective: 'drafts',
-    })
-    expect(result).toBe('success')
+    expect(() => boundAction(instance, {perspective: 'drafts'})).toThrow(
+      'This API requires a project ID and dataset configured.',
+    )
   })
 
-  it('should throw an error when no resource provided and no default resource configured', () => {
+  it('should work correctly with a valid dataset resource and explicit perspective', () => {
     const storeDefinition = {
       name: 'PerspectiveStore',
       getInitialState: () => ({counter: 0}),
     }
     const action = vi.fn((_context) => 'success')
     const boundAction = bindActionByResourceAndPerspective(storeDefinition, action)
-    const instance = createSanityInstance({})
+    const instance = createSanityInstance({projectId: 'proj1', dataset: 'ds1'})
 
-    // @ts-expect-error - test invalid argument
-    expect(() => boundAction(instance, {perspective: 'drafts' as const})).toThrow(
-      'No resource provided and no default resource configured.',
-    )
+    const result = boundAction(instance, {
+      resource: {projectId: 'proj2', dataset: 'ds2'},
+      perspective: 'drafts',
+    })
+    expect(result).toBe('success')
   })
 
   it('should work correctly with valid dataset resource and no perspective (falls back to drafts)', () => {
@@ -238,7 +283,7 @@ describe('bindActionByResourceAndPerspective', () => {
     }
     const action = vi.fn((_context) => 'success')
     const boundAction = bindActionByResourceAndPerspective(storeDefinition, action)
-    const instance = createSanityInstance()
+    const instance = createSanityInstance({projectId: 'proj1', dataset: 'ds1'})
 
     const result = boundAction(instance, {
       resource: {projectId: 'proj1', dataset: 'ds1'},
@@ -246,7 +291,7 @@ describe('bindActionByResourceAndPerspective', () => {
     expect(result).toBe('success')
   })
 
-  it('should fall back to "drafts" when options.perspective is not provided', () => {
+  it('should use instance.config.perspective when options.perspective is not provided', () => {
     const storeDefinition = {
       name: 'PerspectiveStore',
       getInitialState: () => ({counter: 0}),
@@ -254,13 +299,15 @@ describe('bindActionByResourceAndPerspective', () => {
     const action = vi.fn((context) => context.key)
     const boundAction = bindActionByResourceAndPerspective(storeDefinition, action)
     const instance = createSanityInstance({
+      projectId: 'proj1',
+      dataset: 'ds1',
       perspective: 'published',
     })
 
-    const result = boundAction(instance, {resource: {projectId: 'proj2', dataset: 'ds2'}})
+    const result = boundAction(instance, {})
     expect(result).toEqual(
       expect.objectContaining({
-        name: 'proj2.ds2:published',
+        name: 'proj1.ds1:published',
         perspective: 'published',
       }),
     )
@@ -277,18 +324,13 @@ describe('bindActionByResourceAndPerspective', () => {
     })
     const boundAction = bindActionByResourceAndPerspective(storeDefinition, action)
     // Use unique project/dataset so we don't reuse stores from other tests
-    const instance = createSanityInstance()
+    const instance = createSanityInstance({
+      projectId: 'perspective-isolation',
+      dataset: 'ds1',
+    })
 
-    const resultDrafts = boundAction(
-      instance,
-      {resource: {projectId: 'proj3', dataset: 'ds3'}, perspective: 'drafts'},
-      3,
-    )
-    const resultPublished = boundAction(
-      instance,
-      {resource: {projectId: 'proj3', dataset: 'ds3'}, perspective: 'published'},
-      4,
-    )
+    const resultDrafts = boundAction(instance, {perspective: 'drafts'}, 3)
+    const resultPublished = boundAction(instance, {perspective: 'published'}, 4)
 
     expect(resultDrafts).toBe(3)
     expect(resultPublished).toBe(4)
@@ -303,10 +345,9 @@ describe('bindActionByResourceAndPerspective', () => {
     }
     const action = vi.fn((_context) => 'success')
     const boundAction = bindActionByResourceAndPerspective(storeDefinition, action)
-    const instance = createSanityInstance()
+    const instance = createSanityInstance({projectId: 'proj1', dataset: 'ds1'})
 
     const result = boundAction(instance, {
-      resource: {projectId: 'proj1', dataset: 'ds1'},
       perspective: {releaseName: 'release1'},
     })
     expect(result).toBe('success')
@@ -320,23 +361,6 @@ describe('bindActionByResourceAndPerspective', () => {
     )
   })
 
-  it('should throw when provided a stackable perspective', () => {
-    const storeDefinition = {
-      name: 'PerspectiveStore',
-      getInitialState: () => ({counter: 0}),
-    }
-    const action = vi.fn((_context) => 'success')
-    const boundAction = bindActionByResourceAndPerspective(storeDefinition, action)
-    const instance = createSanityInstance()
-
-    expect(() =>
-      boundAction(instance, {
-        resource: {projectId: 'proj1', dataset: 'ds1'},
-        perspective: ['drafts', 'release1'] as unknown as 'drafts',
-      }),
-    ).toThrow('Stackable perspectives are not supported.')
-  })
-
   it('should reuse same store when same resource and perspective are used', () => {
     const storeDefinition = {
       name: 'PerspectiveStore',
@@ -348,18 +372,13 @@ describe('bindActionByResourceAndPerspective', () => {
     })
     const boundAction = bindActionByResourceAndPerspective(storeDefinition, action)
     // Use unique project/dataset so we don't reuse stores from other tests
-    const instance = createSanityInstance()
+    const instance = createSanityInstance({
+      projectId: 'perspective-reuse',
+      dataset: 'ds1',
+    })
 
-    const result1 = boundAction(
-      instance,
-      {resource: {projectId: 'proj4', dataset: 'ds4'}, perspective: 'drafts'},
-      2,
-    )
-    const result2 = boundAction(
-      instance,
-      {resource: {projectId: 'proj4', dataset: 'ds4'}, perspective: 'drafts'},
-      3,
-    )
+    const result1 = boundAction(instance, {perspective: 'drafts'}, 2)
+    const result2 = boundAction(instance, {perspective: 'drafts'}, 3)
 
     expect(result1).toBe(2)
     expect(result2).toBe(5)

package/src/store/createActionBinder.ts

@@ -1,10 +1,12 @@
+import {type ClientPerspective} from '@sanity/client'
+
 import {
+  type DatasetHandle,
   type DocumentResource,
   isCanvasResource,
   isDatasetResource,
   isMediaLibraryResource,
-  type PerspectiveHandle,
-  type ResourceHandle,
+  type ReleasePerspective,
 } from '../config/sanityConfig'
 import {isReleasePerspective} from '../releases/utils/isReleasePerspective'
 import {type SanityInstance} from './createSanityInstance'
@@ -17,7 +19,7 @@ export interface BoundResourceKey {
   resource: DocumentResource
 }
 export interface BoundPerspectiveKey extends BoundResourceKey {
-  perspective: NonNullable<PerspectiveHandle['perspective']>
+  perspective: ClientPerspective | ReleasePerspective
 }
 /**
  * Defines a store action that operates on a specific state type
@@ -115,29 +117,34 @@ export function createActionBinder<
   }
 }
 
-const resourceKeyName = (resource: DocumentResource): string => {
-  if (isDatasetResource(resource)) return `${resource.projectId}.${resource.dataset}`
-  if (isMediaLibraryResource(resource)) return `media-library:${resource.mediaLibraryId}`
-  if (isCanvasResource(resource)) return `canvas:${resource.canvasId}`
-  throw new Error(`Received invalid resource: ${JSON.stringify(resource)}`)
-}
-
 const createResourceKey = (
   instance: SanityInstance,
   resource?: DocumentResource,
 ): BoundResourceKey => {
-  if (resource) {
-    return {name: resourceKeyName(resource), resource}
+  let name: string | undefined
+  let resourceForKey: DocumentResource | undefined
+  // A per-call resource wins; otherwise use the instance's default resource.
+  const effectiveResource = resource ?? instance.config.resource
+  if (effectiveResource) {
+    resourceForKey = effectiveResource
+    if (isDatasetResource(effectiveResource)) {
+      name = `${effectiveResource.projectId}.${effectiveResource.dataset}`
+    } else if (isMediaLibraryResource(effectiveResource)) {
+      name = `media-library:${effectiveResource.mediaLibraryId}`
+    } else if (isCanvasResource(effectiveResource)) {
+      name = `canvas:${effectiveResource.canvasId}`
+    } else {
+      throw new Error(`Received invalid resource: ${JSON.stringify(effectiveResource)}`)
+    }
+    return {name, resource: resourceForKey}
   }
 
-  const defaultResource = instance.config.defaultResource
-  if (!defaultResource) {
-    throw new Error(
-      'No resource provided and no default resource configured. ' +
-        'Provide a "default" resource in your resources map, or pass an explicit resource.',
-    )
+  // `projectId`/`dataset` on the config are shorthand for a dataset resource.
+  const {projectId, dataset} = instance.config
+  if (!projectId || !dataset) {
+    throw new Error('This API requires a project ID and dataset configured.')
   }
-  return {name: resourceKeyName(defaultResource), resource: defaultResource}
+  return {name: `${projectId}.${dataset}`, resource: {projectId, dataset}}
 }
 
 /**
@@ -145,6 +152,8 @@ const createResourceKey = (
  **/
 export const bindActionByResource = createActionBinder<
   BoundResourceKey,
+  // `resource` is optional because it falls back to the instance config in
+  // `createResourceKey` — see the note there on why that fallback still exists.
   [{resource?: DocumentResource}, ...unknown[]]
 >((instance, {resource}) => {
   return createResourceKey(instance, resource)
@@ -161,7 +170,6 @@ export const bindActionByResource = createActionBinder<
  * can isolate single queries by perspective.
  *
  * @throws Error if resource or perspective is missing from the Sanity instance config
- * @throws Error if a stackable perspective (array) is provided, as they are not supported
  *
  * @example
  * ```ts
@@ -187,10 +195,11 @@ export const bindActionByResource = createActionBinder<
  */
 export const bindActionByResourceAndPerspective = createActionBinder<
   BoundPerspectiveKey,
-  [ResourceHandle, ...unknown[]]
+  [DatasetHandle, ...unknown[]]
 >((instance, options): BoundPerspectiveKey => {
   const {resource, perspective} = options
-  // TODO: remove reference to instance.config.perspective when we get to v3
+  // Same trade-off as the resource fallback in `createResourceKey`: configured once on the
+  // instance rather than passed to every call. Kept for the same reason.
   const utilizedPerspective = perspective ?? instance.config.perspective ?? 'drafts'
   let perspectiveKey: string
   if (isReleasePerspective(utilizedPerspective)) {
@@ -198,15 +207,14 @@ export const bindActionByResourceAndPerspective = createActionBinder<
   } else if (typeof utilizedPerspective === 'string') {
     perspectiveKey = utilizedPerspective
   } else {
-    throw new Error(
-      `Stackable perspectives are not supported. Received perspective: ${JSON.stringify(utilizedPerspective)}`,
-    )
+    // "StackablePerspective", shouldn't be a common case, but just in case
+    perspectiveKey = JSON.stringify(utilizedPerspective)
   }
-  const resourceKey = createResourceKey(instance, resource)
+  const sourceKey = createResourceKey(instance, resource)
 
   return {
-    name: `${resourceKey.name}:${perspectiveKey}`,
-    resource: resourceKey.resource,
+    name: `${sourceKey.name}:${perspectiveKey}`,
+    resource: sourceKey.resource,
     perspective: utilizedPerspective,
   }
 })

package/src/store/createSanityInstance.test.ts

@@ -5,14 +5,14 @@ import {createSanityInstance} from './createSanityInstance'
 
 describe('createSanityInstance', () => {
   it('should create an instance with a unique instanceId and given config', () => {
-    const instance = createSanityInstance()
+    const instance = createSanityInstance({projectId: 'proj1', dataset: 'ds1'})
     expect(typeof instance.instanceId).toBe('string')
-    expect(instance.config).toEqual({})
+    expect(instance.config).toEqual({projectId: 'proj1', dataset: 'ds1'})
     expect(instance.isDisposed()).toBe(false)
   })
 
   it('should dispose an instance and call onDispose callbacks', () => {
-    const instance = createSanityInstance()
+    const instance = createSanityInstance({projectId: 'proj1', dataset: 'ds1'})
     const callback = vi.fn()
     instance.onDispose(callback)
     instance.dispose()
@@ -21,7 +21,7 @@ describe('createSanityInstance', () => {
   })
 
   it('should not call onDispose callbacks more than once when disposed multiple times', () => {
-    const instance = createSanityInstance()
+    const instance = createSanityInstance({projectId: 'proj1', dataset: 'ds1'})
     const callback = vi.fn()
     instance.onDispose(callback)
     instance.dispose()
@@ -52,30 +52,31 @@ describe('createSanityInstance', () => {
     })
 
     it('should log instance creation at info level', () => {
-      createSanityInstance()
+      createSanityInstance({projectId: 'test-proj', dataset: 'test-ds'})
 
       expect(mockHandler.info).toHaveBeenCalledWith(
         expect.stringContaining('[INFO] [sdk]'),
         expect.objectContaining({
-          hasAuth: false,
-          hasPerspective: false,
+          hasProjectId: true,
+          hasDataset: true,
         }),
       )
     })
 
     it('should log configuration details at debug level', () => {
-      createSanityInstance({defaultResource: {projectId: 'test-proj', dataset: 'test-dataset'}})
+      createSanityInstance({projectId: 'test-proj', dataset: 'test-ds'})
 
       expect(mockHandler.debug).toHaveBeenCalledWith(
         expect.stringContaining('[DEBUG] [sdk]'),
         expect.objectContaining({
-          hasStudioConfig: false,
+          projectId: 'test-proj',
+          dataset: 'test-ds',
         }),
       )
     })
 
     it('should log instance disposal', () => {
-      const instance = createSanityInstance()
+      const instance = createSanityInstance({projectId: 'test-proj'})
       vi.clearAllMocks() // Clear creation logs
 
       instance.dispose()
@@ -86,11 +87,12 @@ describe('createSanityInstance', () => {
       )
     })
 
-    it('should include instance id in logs', () => {
-      createSanityInstance()
+    it('should include instance context in logs', () => {
+      createSanityInstance({projectId: 'my-project', dataset: 'my-dataset'})
 
+      // Check that logs include the instance context (project and dataset)
       expect(mockHandler.info).toHaveBeenCalledWith(
-        expect.stringMatching(/\[instance:/),
+        expect.stringMatching(/\[project:my-project\].*\[dataset:my-dataset\]/),
         expect.anything(),
       )
     })

package/src/store/createSanityInstance.ts

@@ -3,7 +3,7 @@ import {insecureRandomId} from '../utils/ids'
 import {createLogger, type InstanceContext} from '../utils/logger'
 
 /**
- * Represents a Sanity.io resource instance with its own configuration and lifecycle.
+ * Represents a Sanity.io resource instance with its own configuration and lifecycle
  *
  * @public
  */
@@ -14,7 +14,9 @@ export interface SanityInstance {
    */
   readonly instanceId: string
 
-  /** Resolved configuration for this instance */
+  /**
+   * Resolved configuration for this instance
+   */
   readonly config: SanityConfig
 
   /**
@@ -49,18 +51,28 @@ export function createSanityInstance(config: SanityConfig = {}): SanityInstance
   const disposeListeners = new Map<string, () => void>()
   const disposed = {current: false}
 
+  // Create instance context for logging
   const instanceContext: InstanceContext = {
     instanceId,
+    projectId: config.projectId,
+    dataset: config.dataset,
   }
 
+  // Create logger with instance context
   const logger = createLogger('sdk', {instanceContext})
 
+  // Log instance creation
   logger.info('Sanity instance created', {
+    hasProjectId: !!config.projectId,
+    hasDataset: !!config.dataset,
     hasAuth: !!config.auth,
     hasPerspective: !!config.perspective,
   })
 
+  // Log configuration details at debug level
   logger.debug('Instance configuration', {
+    projectId: config.projectId,
+    dataset: config.dataset,
     perspective: config.perspective,
     hasStudioConfig: !!config.studio,
     hasStudioTokenSource: !!config.studio?.auth?.token,