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

package/src/store/createActionBinder.test.ts

@@ -2,6 +2,7 @@ import {beforeEach, describe, expect, it, vi} from 'vitest'
 
 import {type DocumentResource} from '../config/sanityConfig'
 import {
+  bindActionByDataset,
   bindActionByResource,
   bindActionByResourceAndPerspective,
   bindActionGlobally,
@@ -29,7 +30,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 +44,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 +56,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 +75,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)
@@ -95,6 +96,34 @@ describe('createActionBinder', () => {
   })
 })
 
+describe('bindActionByDataset', () => {
+  it('should work correctly when projectId and dataset are provided', () => {
+    const storeDefinition = {
+      name: 'DSStore',
+      getInitialState: () => ({counter: 0}),
+    }
+    const action = vi.fn((_context, {value}: {value: string}) => value)
+    const boundAction = bindActionByDataset(storeDefinition, action)
+    const instance = createSanityInstance({projectId: 'proj1', dataset: 'ds1'})
+    const result = boundAction(instance, {value: 'hello'})
+    expect(result).toBe('hello')
+  })
+
+  it('should throw an error if projectId or dataset is missing', () => {
+    const storeDefinition = {
+      name: 'DSStore',
+      getInitialState: () => ({counter: 0}),
+    }
+    const action = vi.fn((_context, _?) => 'fail')
+    const boundAction = bindActionByDataset(storeDefinition, action)
+    // Instance with missing dataset
+    const instance = createSanityInstance({projectId: 'proj1', dataset: ''})
+    expect(() => boundAction(instance)).toThrow(
+      'This API requires a project ID and dataset configured.',
+    )
+  })
+})
+
 describe('bindActionGlobally', () => {
   it('should work correctly ignoring config in key generation', () => {
     const storeDefinition = {
@@ -105,8 +134,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 +162,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'},
@@ -190,7 +214,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 +224,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 +261,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 +269,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 +277,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 +302,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 +323,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 +339,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 +350,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,8 +19,14 @@ export interface BoundResourceKey {
   resource: DocumentResource
 }
 export interface BoundPerspectiveKey extends BoundResourceKey {
-  perspective: NonNullable<PerspectiveHandle['perspective']>
+  perspective: ClientPerspective | ReleasePerspective
+}
+interface BoundDatasetKey {
+  name: string
+  projectId: string
+  dataset: string
 }
+
 /**
  * Defines a store action that operates on a specific state type
  */
@@ -115,29 +123,75 @@ 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)}`)
-}
+/**
+ * Binds an action to a store that's scoped to a specific project and dataset
+ *
+ * @remarks
+ * This creates actions that operate on state isolated to a specific projectId and dataset.
+ * Different project/dataset combinations will have separate states.
+ *
+ * @throws Error if projectId or dataset is missing from the Sanity instance config
+ *
+ * @example
+ * ```ts
+ * // Define a store
+ * const documentStore = defineStore<DocumentState>({
+ *   name: 'Document',
+ *   getInitialState: () => ({ documents: {} }),
+ *   // ...
+ * })
+ *
+ * // Create dataset-specific actions
+ * export const fetchDocument = bindActionByDataset(
+ *   documentStore,
+ *   ({instance, state}, documentId) => {
+ *     // This state is isolated to the specific project/dataset
+ *     // ...fetch logic...
+ *   }
+ * )
+ *
+ * // Usage
+ * fetchDocument(sanityInstance, 'doc123')
+ * ```
+ */
+export const bindActionByDataset = createActionBinder<
+  BoundDatasetKey,
+  [(object & {projectId?: string; dataset?: string})?, ...unknown[]]
+>((instance, options) => {
+  const projectId = options?.projectId ?? instance.config.projectId
+  const dataset = options?.dataset ?? instance.config.dataset
+  if (!projectId || !dataset) {
+    throw new Error('This API requires a project ID and dataset configured.')
+  }
+  return {name: `${projectId}.${dataset}`, projectId, dataset}
+})
 
 const createResourceKey = (
   instance: SanityInstance,
   resource?: DocumentResource,
 ): BoundResourceKey => {
+  let name: string | undefined
+  let resourceForKey: DocumentResource | undefined
   if (resource) {
-    return {name: resourceKeyName(resource), resource}
+    resourceForKey = resource
+    if (isDatasetResource(resource)) {
+      name = `${resource.projectId}.${resource.dataset}`
+    } else if (isMediaLibraryResource(resource)) {
+      name = `media-library:${resource.mediaLibraryId}`
+    } else if (isCanvasResource(resource)) {
+      name = `canvas:${resource.canvasId}`
+    } else {
+      throw new Error(`Received invalid resource: ${JSON.stringify(resource)}`)
+    }
+    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.',
-    )
+  // TODO: remove reference to instance.config when we get to v3
+  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 +199,8 @@ const createResourceKey = (
  **/
 export const bindActionByResource = createActionBinder<
   BoundResourceKey,
+  // this implies resources is optional to keep backwards compatibility
+  // but in reality, we'll always pass a resource (since we'll defer to the instance until v3)
   [{resource?: DocumentResource}, ...unknown[]]
 >((instance, {resource}) => {
   return createResourceKey(instance, resource)
@@ -161,7 +217,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,7 +242,7 @@ 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
@@ -198,15 +253,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()
@@ -29,6 +29,60 @@ describe('createSanityInstance', () => {
     expect(callback).toHaveBeenCalledTimes(1)
   })
 
+  it('should create a child instance with merged config and correct parent', () => {
+    const parent = createSanityInstance({projectId: 'proj1', dataset: 'ds1'})
+    const child = parent.createChild({dataset: 'ds2'})
+    expect(child.config).toEqual({projectId: 'proj1', dataset: 'ds2'})
+    expect(child.getParent()).toBe(parent)
+  })
+
+  it('should match an instance in the hierarchy using match', () => {
+    // three-level hierarchy
+    const grandparent = createSanityInstance({projectId: 'proj1', dataset: 'ds1'})
+    const parent = grandparent.createChild({projectId: 'proj2'})
+    const child = parent.createChild({dataset: 'ds2'})
+
+    expect(child.config).toEqual({projectId: 'proj2', dataset: 'ds2'})
+    expect(parent.config).toEqual({projectId: 'proj2', dataset: 'ds1'})
+
+    expect(child.match({dataset: 'ds2'})).toBe(child)
+    expect(child.match({projectId: 'proj2'})).toBe(child)
+    expect(child.match({projectId: 'proj1'})).toBe(grandparent)
+    expect(parent.match({projectId: 'proj1'})).toBe(grandparent)
+    expect(grandparent.match({projectId: 'proj1'})).toBe(grandparent)
+  })
+
+  it('should match `undefined` when the desired resource ID should not be set on an instance', () => {
+    const noProjectOrDataset = createSanityInstance()
+    const noDataset = noProjectOrDataset.createChild({projectId: 'proj1'})
+    const leaf = noDataset.createChild({dataset: 'ds1'})
+
+    // no keys means anything (in this case, self) will match
+    expect(leaf.match({})).toBe(leaf)
+
+    // `[resourceId]: undefined` means match an instance with no dataset set
+    expect(leaf.match({dataset: undefined})).toBe(noDataset)
+    expect(noDataset.match({dataset: undefined})).toBe(noDataset)
+    expect(leaf.match({projectId: undefined})).toBe(noProjectOrDataset)
+    expect(noDataset.match({projectId: undefined})).toBe(noProjectOrDataset)
+    expect(noProjectOrDataset.match({projectId: undefined})).toBe(noProjectOrDataset)
+  })
+
+  it('should return undefined when no match is found', () => {
+    const instance = createSanityInstance({projectId: 'proj1', dataset: 'ds1'})
+    expect(instance.match({dataset: 'non-existent'})).toBeUndefined()
+  })
+
+  it('should inherit and merge auth config', () => {
+    const parent = createSanityInstance({
+      projectId: 'proj1',
+      dataset: 'ds1',
+      auth: {apiHost: 'api.sanity.work'},
+    })
+    const child = parent.createChild({auth: {token: 'my-token'}})
+    expect(child.config.auth).toEqual({apiHost: 'api.sanity.work', token: 'my-token'})
+  })
+
   describe('logging', () => {
     const mockHandler: LogHandler = {
       error: vi.fn(),
@@ -52,30 +106,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 +141,26 @@ describe('createSanityInstance', () => {
       )
     })
 
-    it('should include instance id in logs', () => {
-      createSanityInstance()
+    it('should log child instance creation at debug level', () => {
+      const parent = createSanityInstance({projectId: 'parent-proj'})
+      vi.clearAllMocks() // Clear parent creation logs
+
+      parent.createChild({dataset: 'child-ds'})
+
+      expect(mockHandler.debug).toHaveBeenCalledWith(
+        expect.stringContaining('Creating child instance'),
+        expect.objectContaining({
+          overridingDataset: true,
+        }),
+      )
+    })
+
+    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(),
       )
     })